index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
6,782 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
double height;
double weight;
} StudentDetails;
typedef struct {
char name[50];
StudentDetails details;
} Student;
| int func0(Student students[], int count, double h, double w, Student result[]) {
int index = 0;
for (int i = 0; i < count; i++) {
if (students[i].details.height >= h && students[i].details.weight >= w) {
result[index++] = students[i];
}
}
return index;
}
| int main() {
Student students[] = {
{"Cierra Vega", {6.2, 70}},
{"Alden Cantrell", {5.9, 65}},
{"Kierra Gentry", {6.0, 68}},
{"Pierre Cox", {5.8, 66}}
};
Student result[4];
int count;
count = func0(students, 4, 6.0, 70, result);
assert(count == 1 && strcmp(result[0].name, "Cierra Vega") == 0 && result[0].details.height == 6.2 && result[0].details.weight == 70);
count = func0(students, 4, 5.9, 67, result);
assert(count == 2 && strcmp(result[0].name, "Cierra Vega") == 0 && result[0].details.height == 6.2 && result[0].details.weight == 70
&& strcmp(result[1].name, "Kierra Gentry") == 0 && result[1].details.height == 6.0 && result[1].details.weight == 68);
count = func0(students, 4, 5.7, 64, result);
assert(count == 4 && strcmp(result[0].name, "Cierra Vega") == 0 && result[0].details.height == 6.2 && result[0].details.weight == 70
&& strcmp(result[1].name, "Alden Cantrell") == 0 && result[1].details.height == 5.9 && result[1].details.weight == 65
&& strcmp(result[2].name, "Kierra Gentry") == 0 && result[2].details.height == 6.0 && result[2].details.weight == 68
&& strcmp(result[3].name, "Pierre Cox") == 0 && result[3].details.height == 5.8 && result[3].details.weight == 66);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1580 <func0+0x80>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea (%rax,%rax,8),%rax
lea 0x48(%rdi,%rax,8),%rcx
nopw 0x0(%rax,%rax,1)
movsd 0x38(%rdi),%xmm2
comisd %xmm0,%xmm2
jb 156f <func0+0x6f>
movsd 0x40(%rdi),%xmm2
comisd %xmm1,%xmm2
jb 156f <func0+0x6f>
movslq %r8d,%rax
movdqu (%rdi),%xmm3
add $0x1,%r8d
lea (%rax,%rax,8),%rax
lea (%rdx,%rax,8),%rax
movups %xmm3,(%rax)
movdqu 0x10(%rdi),%xmm4
movups %xmm4,0x10(%rax)
movdqu 0x20(%rdi),%xmm5
movups %xmm5,0x20(%rax)
movdqu 0x30(%rdi),%xmm6
movups %xmm6,0x30(%rax)
mov 0x40(%rdi),%rsi
mov %rsi,0x40(%rax)
add $0x48,%rdi
cmp %rcx,%rdi
jne 1520 <func0+0x20>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1590
lea eax, [rsi-1]
xor r8d, r8d
lea rax, [rax+rax*8]
lea rcx, [rdi+rax*8+48h]
nop word ptr [rax+rax+00000000h]
loc_1530:
movsd xmm2, qword ptr [rdi+38h]
comisd xmm2, xmm0
jb short loc_157F
movsd xmm2, qword ptr [rdi+40h]
comisd xmm2, xmm1
jb short loc_157F
movsxd rax, r8d
movdqu xmm3, xmmword ptr [rdi]
add r8d, 1
lea rax, [rax+rax*8]
lea rax, [rdx+rax*8]
movups xmmword ptr [rax], xmm3
movdqu xmm4, xmmword ptr [rdi+10h]
movups xmmword ptr [rax+10h], xmm4
movdqu xmm5, xmmword ptr [rdi+20h]
movups xmmword ptr [rax+20h], xmm5
movdqu xmm6, xmmword ptr [rdi+30h]
movups xmmword ptr [rax+30h], xmm6
mov rsi, [rdi+40h]
mov [rax+40h], rsi
loc_157F:
add rdi, 48h ; 'H'
cmp rdi, rcx
jnz short loc_1530
mov eax, r8d
retn
loc_1590:
xor r8d, r8d
mov eax, r8d
retn | long long func0(long long a1, int a2, long long a3, double a4, double a5)
{
unsigned int v5; // r8d
long long v6; // rcx
long long v7; // rax
__m128i *v8; // rax
if ( a2 <= 0 )
return 0LL;
v5 = 0;
v6 = a1 + 72LL * (unsigned int)(a2 - 1) + 72;
do
{
if ( *(double *)(a1 + 56) >= a4 && *(double *)(a1 + 64) >= a5 )
{
v7 = (int)v5++;
v8 = (__m128i *)(a3 + 72 * v7);
*v8 = _mm_loadu_si128((const __m128i *)a1);
v8[1] = _mm_loadu_si128((const __m128i *)(a1 + 16));
v8[2] = _mm_loadu_si128((const __m128i *)(a1 + 32));
v8[3] = _mm_loadu_si128((const __m128i *)(a1 + 48));
v8[4].m128i_i64[0] = *(_QWORD *)(a1 + 64);
}
a1 += 72LL;
}
while ( a1 != v6 );
return v5;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101590
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
LEA RAX,[RAX + RAX*0x8]
LEA RCX,[RDI + RAX*0x8 + 0x48]
NOP word ptr [RAX + RAX*0x1]
LAB_00101530:
MOVSD XMM2,qword ptr [RDI + 0x38]
COMISD XMM2,XMM0
JC 0x0010157f
MOVSD XMM2,qword ptr [RDI + 0x40]
COMISD XMM2,XMM1
JC 0x0010157f
MOVSXD RAX,R8D
MOVDQU XMM3,xmmword ptr [RDI]
ADD R8D,0x1
LEA RAX,[RAX + RAX*0x8]
LEA RAX,[RDX + RAX*0x8]
MOVUPS xmmword ptr [RAX],XMM3
MOVDQU XMM4,xmmword ptr [RDI + 0x10]
MOVUPS xmmword ptr [RAX + 0x10],XMM4
MOVDQU XMM5,xmmword ptr [RDI + 0x20]
MOVUPS xmmword ptr [RAX + 0x20],XMM5
MOVDQU XMM6,xmmword ptr [RDI + 0x30]
MOVUPS xmmword ptr [RAX + 0x30],XMM6
MOV RSI,qword ptr [RDI + 0x40]
MOV qword ptr [RAX + 0x40],RSI
LAB_0010157f:
ADD RDI,0x48
CMP RDI,RCX
JNZ 0x00101530
MOV EAX,R8D
RET
LAB_00101590:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(double param_1,double param_2,int8 *param_3,int param_4,long param_5)
{
int8 *puVar1;
int8 *puVar2;
int8 uVar3;
long lVar4;
int iVar5;
if (0 < param_4) {
iVar5 = 0;
puVar2 = param_3 + (ulong)(param_4 - 1) * 9 + 9;
do {
if ((param_1 <= (double)param_3[7]) && (param_2 <= (double)param_3[8])) {
lVar4 = (long)iVar5;
uVar3 = param_3[1];
iVar5 = iVar5 + 1;
puVar1 = (int8 *)(param_5 + lVar4 * 0x48);
*puVar1 = *param_3;
puVar1[1] = uVar3;
uVar3 = param_3[3];
puVar1[2] = param_3[2];
puVar1[3] = uVar3;
uVar3 = param_3[5];
puVar1[4] = param_3[4];
puVar1[5] = uVar3;
uVar3 = param_3[7];
puVar1[6] = param_3[6];
puVar1[7] = uVar3;
puVar1[8] = param_3[8];
}
param_3 = param_3 + 9;
} while (param_3 != puVar2);
return iVar5;
}
return 0;
} |
6,783 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
double height;
double weight;
} StudentDetails;
typedef struct {
char name[50];
StudentDetails details;
} Student;
| int func0(Student students[], int count, double h, double w, Student result[]) {
int index = 0;
for (int i = 0; i < count; i++) {
if (students[i].details.height >= h && students[i].details.weight >= w) {
result[index++] = students[i];
}
}
return index;
}
| int main() {
Student students[] = {
{"Cierra Vega", {6.2, 70}},
{"Alden Cantrell", {5.9, 65}},
{"Kierra Gentry", {6.0, 68}},
{"Pierre Cox", {5.8, 66}}
};
Student result[4];
int count;
count = func0(students, 4, 6.0, 70, result);
assert(count == 1 && strcmp(result[0].name, "Cierra Vega") == 0 && result[0].details.height == 6.2 && result[0].details.weight == 70);
count = func0(students, 4, 5.9, 67, result);
assert(count == 2 && strcmp(result[0].name, "Cierra Vega") == 0 && result[0].details.height == 6.2 && result[0].details.weight == 70
&& strcmp(result[1].name, "Kierra Gentry") == 0 && result[1].details.height == 6.0 && result[1].details.weight == 68);
count = func0(students, 4, 5.7, 64, result);
assert(count == 4 && strcmp(result[0].name, "Cierra Vega") == 0 && result[0].details.height == 6.2 && result[0].details.weight == 70
&& strcmp(result[1].name, "Alden Cantrell") == 0 && result[1].details.height == 5.9 && result[1].details.weight == 65
&& strcmp(result[2].name, "Kierra Gentry") == 0 && result[2].details.height == 6.0 && result[2].details.weight == 68
&& strcmp(result[3].name, "Pierre Cox") == 0 && result[3].details.height == 5.8 && result[3].details.weight == 66);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1580 <func0+0x80>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea (%rax,%rax,8),%rax
lea 0x48(%rdi,%rax,8),%rcx
nopw 0x0(%rax,%rax,1)
movsd 0x38(%rdi),%xmm2
comisd %xmm0,%xmm2
jb 156f <func0+0x6f>
movsd 0x40(%rdi),%xmm2
comisd %xmm1,%xmm2
jb 156f <func0+0x6f>
movslq %r8d,%rax
movdqu (%rdi),%xmm3
add $0x1,%r8d
lea (%rax,%rax,8),%rax
lea (%rdx,%rax,8),%rax
movups %xmm3,(%rax)
movdqu 0x10(%rdi),%xmm4
movups %xmm4,0x10(%rax)
movdqu 0x20(%rdi),%xmm5
movups %xmm5,0x20(%rax)
movdqu 0x30(%rdi),%xmm6
movups %xmm6,0x30(%rax)
mov 0x40(%rdi),%rsi
mov %rsi,0x40(%rax)
add $0x48,%rdi
cmp %rcx,%rdi
jne 1520 <func0+0x20>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1558
movsxd rsi, esi
lea rax, [rsi+rsi*8]
xor esi, esi
lea rcx, [rdi+rax*8]
nop dword ptr [rax]
loc_14F8:
movsd xmm2, qword ptr [rdi+38h]
comisd xmm2, xmm0
jb short loc_1546
movsd xmm2, qword ptr [rdi+40h]
comisd xmm2, xmm1
jb short loc_1546
movsxd rax, esi
movdqu xmm3, xmmword ptr [rdi]
add esi, 1
lea rax, [rax+rax*8]
lea rax, [rdx+rax*8]
movups xmmword ptr [rax], xmm3
movdqu xmm4, xmmword ptr [rdi+10h]
movups xmmword ptr [rax+10h], xmm4
movdqu xmm5, xmmword ptr [rdi+20h]
movups xmmword ptr [rax+20h], xmm5
movdqu xmm6, xmmword ptr [rdi+30h]
movups xmmword ptr [rax+30h], xmm6
mov r8, [rdi+40h]
mov [rax+40h], r8
loc_1546:
add rdi, 48h ; 'H'
cmp rdi, rcx
jnz short loc_14F8
mov eax, esi
retn
loc_1558:
xor esi, esi
mov eax, esi
retn | long long func0(long long a1, int a2, long long a3, double a4, double a5)
{
long long v5; // rax
unsigned int v6; // esi
long long v7; // rcx
long long v8; // rax
__m128i *v9; // rax
if ( a2 <= 0 )
return 0LL;
v5 = 9LL * a2;
v6 = 0;
v7 = a1 + 8 * v5;
do
{
if ( *(double *)(a1 + 56) >= a4 && *(double *)(a1 + 64) >= a5 )
{
v8 = (int)v6++;
v9 = (__m128i *)(a3 + 72 * v8);
*v9 = _mm_loadu_si128((const __m128i *)a1);
v9[1] = _mm_loadu_si128((const __m128i *)(a1 + 16));
v9[2] = _mm_loadu_si128((const __m128i *)(a1 + 32));
v9[3] = _mm_loadu_si128((const __m128i *)(a1 + 48));
v9[4].m128i_i64[0] = *(_QWORD *)(a1 + 64);
}
a1 += 72LL;
}
while ( a1 != v7 );
return v6;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101558
MOVSXD RSI,ESI
LEA RAX,[RSI + RSI*0x8]
XOR ESI,ESI
LEA RCX,[RDI + RAX*0x8]
NOP dword ptr [RAX]
LAB_001014f8:
MOVSD XMM2,qword ptr [RDI + 0x38]
COMISD XMM2,XMM0
JC 0x00101546
MOVSD XMM2,qword ptr [RDI + 0x40]
COMISD XMM2,XMM1
JC 0x00101546
MOVSXD RAX,ESI
MOVDQU XMM3,xmmword ptr [RDI]
ADD ESI,0x1
LEA RAX,[RAX + RAX*0x8]
LEA RAX,[RDX + RAX*0x8]
MOVUPS xmmword ptr [RAX],XMM3
MOVDQU XMM4,xmmword ptr [RDI + 0x10]
MOVUPS xmmword ptr [RAX + 0x10],XMM4
MOVDQU XMM5,xmmword ptr [RDI + 0x20]
MOVUPS xmmword ptr [RAX + 0x20],XMM5
MOVDQU XMM6,xmmword ptr [RDI + 0x30]
MOVUPS xmmword ptr [RAX + 0x30],XMM6
MOV R8,qword ptr [RDI + 0x40]
MOV qword ptr [RAX + 0x40],R8
LAB_00101546:
ADD RDI,0x48
CMP RDI,RCX
JNZ 0x001014f8
MOV EAX,ESI
RET
LAB_00101558:
XOR ESI,ESI
MOV EAX,ESI
RET | int func0(double param_1,double param_2,int8 *param_3,int param_4,long param_5)
{
int8 *puVar1;
int8 *puVar2;
int8 uVar3;
long lVar4;
int iVar5;
if (0 < param_4) {
iVar5 = 0;
puVar1 = param_3 + (long)param_4 * 9;
do {
if ((param_1 <= (double)param_3[7]) && (param_2 <= (double)param_3[8])) {
lVar4 = (long)iVar5;
uVar3 = param_3[1];
iVar5 = iVar5 + 1;
puVar2 = (int8 *)(param_5 + lVar4 * 0x48);
*puVar2 = *param_3;
puVar2[1] = uVar3;
uVar3 = param_3[3];
puVar2[2] = param_3[2];
puVar2[3] = uVar3;
uVar3 = param_3[5];
puVar2[4] = param_3[4];
puVar2[5] = uVar3;
uVar3 = param_3[7];
puVar2[6] = param_3[6];
puVar2[7] = uVar3;
puVar2[8] = param_3[8];
}
param_3 = param_3 + 9;
} while (param_3 != puVar1);
return iVar5;
}
return 0;
} |
6,784 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int* nums1, int* nums2, int size) {
int result = 0;
for (int i = 0; i < size; i++) {
if (nums1[i] == nums2[i]) {
result++;
}
}
return result;
}
| int main() {
int arr1_1[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr2_1[] = {2, 2, 3, 1, 2, 6, 7, 9};
int size_1 = sizeof(arr1_1) / sizeof(arr1_1[0]);
assert(func0(arr1_1, arr2_1, size_1) == 4);
int arr1_2[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
int arr2_2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
int size_2 = sizeof(arr1_2) / sizeof(arr1_2[0]);
assert(func0(arr1_2, arr2_2, size_2) == 11);
int arr1_3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int arr2_3[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
int size_3 = sizeof(arr1_3) / sizeof(arr1_3[0]);
assert(func0(arr1_3, arr2_3, size_3) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c4 <func0+0x5b>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x20(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 11c0 <func0+0x57>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x24(%rbp),%eax
jl 118c <func0+0x23>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11C4
loc_118C:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_11C0
add [rbp+var_8], 1
loc_11C0:
add [rbp+var_4], 1
loc_11C4:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_24]
jl short loc_118C
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, long long a2, int a3)
{
unsigned int v4; // [rsp+1Ch] [rbp-8h]
int i; // [rsp+20h] [rbp-4h]
v4 = 0;
for ( i = 0; i < a3; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * i + a2) )
++v4;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c4
LAB_0010118c:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x001011c0
ADD dword ptr [RBP + -0x8],0x1
LAB_001011c0:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011c4:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x0010118c
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,long param_2,int param_3)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) == *(int *)(param_2 + (long)local_c * 4)) {
local_10 = local_10 + 1;
}
}
return local_10;
} |
6,785 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int* nums1, int* nums2, int size) {
int result = 0;
for (int i = 0; i < size; i++) {
if (nums1[i] == nums2[i]) {
result++;
}
}
return result;
}
| int main() {
int arr1_1[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr2_1[] = {2, 2, 3, 1, 2, 6, 7, 9};
int size_1 = sizeof(arr1_1) / sizeof(arr1_1[0]);
assert(func0(arr1_1, arr2_1, size_1) == 4);
int arr1_2[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
int arr2_2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
int size_2 = sizeof(arr1_2) / sizeof(arr1_2[0]);
assert(func0(arr1_2, arr2_2, size_2) == 11);
int arr1_3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int arr2_3[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
int size_3 = sizeof(arr1_3) / sizeof(arr1_3[0]);
assert(func0(arr1_3, arr2_3, size_3) == 1);
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
jle 119b <func0+0x32>
lea -0x1(%rdx),%ecx
mov $0x0,%eax
mov $0x0,%r8d
jmp 118d <func0+0x24>
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 11a1 <func0+0x38>
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jne 1181 <func0+0x18>
add $0x1,%r8d
jmp 1181 <func0+0x18>
mov $0x0,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
test edx, edx
jle short loc_1197
mov edx, edx
mov eax, 0
mov ecx, 0
jmp short loc_1188
loc_117F:
add rax, 1
cmp rax, rdx
jz short loc_119C
loc_1188:
mov r8d, [rsi+rax*4]
cmp [rdi+rax*4], r8d
jnz short loc_117F
add ecx, 1
jmp short loc_117F
loc_1197:
mov ecx, 0
loc_119C:
mov eax, ecx
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
unsigned int v4; // ecx
if ( a3 <= 0 )
{
return 0;
}
else
{
v3 = 0LL;
v4 = 0;
do
{
if ( *(_DWORD *)(a1 + 4 * v3) == *(_DWORD *)(a2 + 4 * v3) )
++v4;
++v3;
}
while ( v3 != a3 );
}
return v4;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x00101197
MOV EDX,EDX
MOV EAX,0x0
MOV ECX,0x0
JMP 0x00101188
LAB_0010117f:
ADD RAX,0x1
CMP RAX,RDX
JZ 0x0010119c
LAB_00101188:
MOV R8D,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],R8D
JNZ 0x0010117f
ADD ECX,0x1
JMP 0x0010117f
LAB_00101197:
MOV ECX,0x0
LAB_0010119c:
MOV EAX,ECX
RET | int func0(long param_1,long param_2,uint param_3)
{
ulong uVar1;
int iVar2;
if ((int)param_3 < 1) {
iVar2 = 0;
}
else {
uVar1 = 0;
iVar2 = 0;
do {
if (*(int *)(param_1 + uVar1 * 4) == *(int *)(param_2 + uVar1 * 4)) {
iVar2 = iVar2 + 1;
}
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
}
return iVar2;
} |
6,786 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int* nums1, int* nums2, int size) {
int result = 0;
for (int i = 0; i < size; i++) {
if (nums1[i] == nums2[i]) {
result++;
}
}
return result;
}
| int main() {
int arr1_1[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr2_1[] = {2, 2, 3, 1, 2, 6, 7, 9};
int size_1 = sizeof(arr1_1) / sizeof(arr1_1[0]);
assert(func0(arr1_1, arr2_1, size_1) == 4);
int arr1_2[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
int arr2_2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
int size_2 = sizeof(arr1_2) / sizeof(arr1_2[0]);
assert(func0(arr1_2, arr2_2, size_2) == 11);
int arr1_3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int arr2_3[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
int size_3 = sizeof(arr1_3) / sizeof(arr1_3[0]);
assert(func0(arr1_3, arr2_3, size_3) == 1);
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
jle 14e8 <func0+0x38>
lea -0x1(%rdx),%ecx
xor %eax,%eax
xor %r8d,%r8d
jmp 14cb <func0+0x1b>
nopw 0x0(%rax,%rax,1)
mov %rdx,%rax
mov (%rsi,%rax,4),%edx
cmp %edx,(%rdi,%rax,4)
jne 14d7 <func0+0x27>
add $0x1,%r8d
lea 0x1(%rax),%rdx
cmp %rcx,%rax
jne 14c8 <func0+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
| func0:
endbr64
test edx, edx
jle short loc_14E0
movsxd rdx, edx
xor eax, eax
xor r8d, r8d
loc_14C0:
mov ecx, [rsi+rax*4]
cmp [rdi+rax*4], ecx
jnz short loc_14CC
add r8d, 1
loc_14CC:
add rax, 1
cmp rax, rdx
jnz short loc_14C0
mov eax, r8d
retn
loc_14E0:
xor r8d, r8d
mov eax, r8d
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
unsigned int v4; // r8d
if ( a3 <= 0 )
return 0LL;
v3 = 0LL;
v4 = 0;
do
{
if ( *(_DWORD *)(a1 + 4 * v3) == *(_DWORD *)(a2 + 4 * v3) )
++v4;
++v3;
}
while ( v3 != a3 );
return v4;
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001014e0
MOVSXD RDX,EDX
XOR EAX,EAX
XOR R8D,R8D
LAB_001014c0:
MOV ECX,dword ptr [RSI + RAX*0x4]
CMP dword ptr [RDI + RAX*0x4],ECX
JNZ 0x001014cc
ADD R8D,0x1
LAB_001014cc:
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x001014c0
MOV EAX,R8D
RET
LAB_001014e0:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,long param_2,int param_3)
{
long lVar1;
int iVar2;
if (0 < param_3) {
lVar1 = 0;
iVar2 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) == *(int *)(param_2 + lVar1 * 4)) {
iVar2 = iVar2 + 1;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_3);
return iVar2;
}
return 0;
} |
6,787 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int* nums1, int* nums2, int size) {
int result = 0;
for (int i = 0; i < size; i++) {
if (nums1[i] == nums2[i]) {
result++;
}
}
return result;
}
| int main() {
int arr1_1[] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr2_1[] = {2, 2, 3, 1, 2, 6, 7, 9};
int size_1 = sizeof(arr1_1) / sizeof(arr1_1[0]);
assert(func0(arr1_1, arr2_1, size_1) == 4);
int arr1_2[] = {0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8};
int arr2_2[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
int size_2 = sizeof(arr1_2) / sizeof(arr1_2[0]);
assert(func0(arr1_2, arr2_2, size_2) == 11);
int arr1_3[] = {2, 4, -6, -9, 11, -12, 14, -5, 17};
int arr2_3[] = {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8};
int size_3 = sizeof(arr1_3) / sizeof(arr1_3[0]);
assert(func0(arr1_3, arr2_3, size_3) == 1);
return 0;
}
| O3 | c | func0:
endbr64
test %edx,%edx
jle 14c0 <func0+0xd0>
lea -0x1(%rdx),%eax
cmp $0x2,%eax
jbe 14c3 <func0+0xd3>
mov %edx,%ecx
xor %eax,%eax
pxor %xmm0,%xmm0
shr $0x2,%ecx
shl $0x4,%rcx
nopw 0x0(%rax,%rax,1)
movdqu (%rdi,%rax,1),%xmm1
movdqu (%rsi,%rax,1),%xmm2
add $0x10,%rax
pcmpeqd %xmm2,%xmm1
psubd %xmm1,%xmm0
cmp %rcx,%rax
jne 1420 <func0+0x30>
movdqa %xmm0,%xmm1
mov %edx,%ecx
psrldq $0x8,%xmm1
and $0xfffffffc,%ecx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
test $0x3,%dl
je 14b0 <func0+0xc0>
movslq %ecx,%r8
mov (%rsi,%r8,4),%r9d
cmp %r9d,(%rdi,%r8,4)
je 14a0 <func0+0xb0>
lea 0x1(%rcx),%r8d
cmp %edx,%r8d
jge 1498 <func0+0xa8>
movslq %r8d,%r8
mov (%rdi,%r8,4),%r10d
cmp %r10d,(%rsi,%r8,4)
je 14a8 <func0+0xb8>
add $0x2,%ecx
cmp %ecx,%edx
jle 1498 <func0+0xa8>
movslq %ecx,%rcx
mov (%rsi,%rcx,4),%edx
cmp %edx,(%rdi,%rcx,4)
je 14b8 <func0+0xc8>
retq
nopl 0x0(%rax)
add $0x1,%eax
jmp 1470 <func0+0x80>
nopl (%rax)
add $0x1,%eax
jmp 1486 <func0+0x96>
nopl (%rax)
retq
nopl 0x0(%rax)
add $0x1,%eax
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
xor %ecx,%ecx
xor %eax,%eax
jmp 1463 <func0+0x73>
nopl 0x0(%rax)
| func0:
endbr64
mov rcx, rsi
test edx, edx
jle loc_1218
lea eax, [rdx-1]
cmp eax, 2
jbe loc_121B
mov esi, edx
xor eax, eax
pxor xmm0, xmm0
shr esi, 2
shl rsi, 4
nop word ptr [rax+rax+00h]
loc_1170:
movdqu xmm1, xmmword ptr [rdi+rax]
movdqu xmm2, xmmword ptr [rcx+rax]
add rax, 10h
pcmpeqd xmm1, xmm2
psubd xmm0, xmm1
cmp rax, rsi
jnz short loc_1170
movdqa xmm1, xmm0
mov esi, edx
psrldq xmm1, 8
and esi, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test dl, 3
jz short locret_1208
loc_11B3:
movsxd r9, esi
mov r10d, [rcx+r9*4]
lea r8, ds:0[r9*4]
cmp [rdi+r9*4], r10d
jz short loc_11F8
loc_11C8:
lea r9d, [rsi+1]
cmp edx, r9d
jle short locret_11F0
mov r11d, [rdi+r8+4]
cmp [rcx+r8+4], r11d
jz short loc_1200
loc_11DD:
add esi, 2
cmp edx, esi
jle short locret_11F0
mov ecx, [rcx+r8+8]
cmp [rdi+r8+8], ecx
jz short loc_1210
locret_11F0:
retn
loc_11F8:
add eax, 1
jmp short loc_11C8
loc_1200:
add eax, 1
jmp short loc_11DD
locret_1208:
retn
loc_1210:
add eax, 1
retn
loc_1218:
xor eax, eax
retn
loc_121B:
xor esi, esi
xor eax, eax
jmp short loc_11B3 | long long func0(long long a1, long long a2, int a3)
{
long long v4; // rax
__m128i v5; // xmm0
__m128i v6; // xmm1
__m128i v7; // xmm2
int v8; // esi
__m128i v9; // xmm0
long long result; // rax
long long v11; // r8
if ( a3 <= 0 )
return 0LL;
if ( (unsigned int)(a3 - 1) <= 2 )
{
v8 = 0;
result = 0LL;
}
else
{
v4 = 0LL;
v5 = 0LL;
do
{
v6 = _mm_loadu_si128((const __m128i *)(a1 + v4));
v7 = _mm_loadu_si128((const __m128i *)(a2 + v4));
v4 += 16LL;
v5 = _mm_sub_epi32(v5, _mm_cmpeq_epi32(v6, v7));
}
while ( v4 != 16LL * ((unsigned int)a3 >> 2) );
v8 = a3 & 0x7FFFFFFC;
v9 = _mm_add_epi32(v5, _mm_srli_si128(v5, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v9, _mm_srli_si128(v9, 4)));
if ( (a3 & 3) == 0 )
return result;
}
v11 = 4LL * v8;
if ( *(_DWORD *)(a1 + v11) == *(_DWORD *)(a2 + v11) )
result = (unsigned int)(result + 1);
if ( a3 > v8 + 1 )
{
if ( *(_DWORD *)(a2 + v11 + 4) == *(_DWORD *)(a1 + v11 + 4) )
result = (unsigned int)(result + 1);
if ( a3 > v8 + 2 && *(_DWORD *)(a1 + v11 + 8) == *(_DWORD *)(a2 + v11 + 8) )
return (unsigned int)(result + 1);
}
return result;
} | func0:
ENDBR64
MOV RCX,RSI
TEST EDX,EDX
JLE 0x00101218
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x0010121b
MOV ESI,EDX
XOR EAX,EAX
PXOR XMM0,XMM0
SHR ESI,0x2
SHL RSI,0x4
NOP word ptr [RAX + RAX*0x1]
LAB_00101170:
MOVDQU XMM1,xmmword ptr [RDI + RAX*0x1]
MOVDQU XMM2,xmmword ptr [RCX + RAX*0x1]
ADD RAX,0x10
PCMPEQD XMM1,XMM2
PSUBD XMM0,XMM1
CMP RAX,RSI
JNZ 0x00101170
MOVDQA XMM1,XMM0
MOV ESI,EDX
PSRLDQ XMM1,0x8
AND ESI,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST DL,0x3
JZ 0x00101208
LAB_001011b3:
MOVSXD R9,ESI
MOV R10D,dword ptr [RCX + R9*0x4]
LEA R8,[R9*0x4]
CMP dword ptr [RDI + R9*0x4],R10D
JZ 0x001011f8
LAB_001011c8:
LEA R9D,[RSI + 0x1]
CMP EDX,R9D
JLE 0x001011f0
MOV R11D,dword ptr [RDI + R8*0x1 + 0x4]
CMP dword ptr [RCX + R8*0x1 + 0x4],R11D
JZ 0x00101200
LAB_001011dd:
ADD ESI,0x2
CMP EDX,ESI
JLE 0x001011f0
MOV ECX,dword ptr [RCX + R8*0x1 + 0x8]
CMP dword ptr [RDI + R8*0x1 + 0x8],ECX
JZ 0x00101210
LAB_001011f0:
RET
LAB_001011f8:
ADD EAX,0x1
JMP 0x001011c8
LAB_00101200:
ADD EAX,0x1
JMP 0x001011dd
LAB_00101208:
RET
LAB_00101210:
ADD EAX,0x1
RET
LAB_00101218:
XOR EAX,EAX
RET
LAB_0010121b:
XOR ESI,ESI
XOR EAX,EAX
JMP 0x001011b3 | int func0(long param_1,long param_2,uint param_3)
{
int *piVar1;
int *piVar2;
long lVar3;
uint uVar4;
long lVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
if ((int)param_3 < 1) {
return 0;
}
if (param_3 - 1 < 3) {
uVar4 = 0;
iVar6 = 0;
}
else {
lVar3 = 0;
iVar6 = 0;
iVar7 = 0;
iVar8 = 0;
iVar9 = 0;
do {
piVar1 = (int *)(param_1 + lVar3);
piVar2 = (int *)(param_2 + lVar3);
lVar3 = lVar3 + 0x10;
iVar6 = iVar6 + (uint)(*piVar1 == *piVar2);
iVar7 = iVar7 + (uint)(piVar1[1] == piVar2[1]);
iVar8 = iVar8 + (uint)(piVar1[2] == piVar2[2]);
iVar9 = iVar9 + (uint)(piVar1[3] == piVar2[3]);
} while (lVar3 != (ulong)(param_3 >> 2) << 4);
uVar4 = param_3 & 0xfffffffc;
iVar6 = iVar6 + iVar8 + iVar7 + iVar9;
if ((param_3 & 3) == 0) {
return iVar6;
}
}
lVar5 = (long)(int)uVar4;
lVar3 = lVar5 * 4;
if (*(int *)(param_1 + lVar5 * 4) == *(int *)(param_2 + lVar5 * 4)) {
iVar6 = iVar6 + 1;
}
if ((int)(uVar4 + 1) < (int)param_3) {
if (*(int *)(param_2 + 4 + lVar3) == *(int *)(param_1 + 4 + lVar3)) {
iVar6 = iVar6 + 1;
}
if (((int)(uVar4 + 2) < (int)param_3) &&
(*(int *)(param_1 + 8 + lVar3) == *(int *)(param_2 + 8 + lVar3))) {
return iVar6 + 1;
}
}
return iVar6;
} |
6,788 | func0 |
#include <assert.h>
| int func0(int base, int power) {
int digits[1000];
int size = 1;
digits[0] = 1;
for (int p = 0; p < power; p++) {
int carry = 0;
for (int i = 0; i < size; i++) {
long temp = (long)digits[i] * base + carry;
digits[i] = temp % 10;
carry = temp / 10;
}
while (carry > 0) {
digits[size] = carry % 10;
carry /= 10;
size++;
}
}
int sum = 0;
for (int i = 0; i < size; i++) {
sum += digits[i];
}
return sum;
}
| int main() {
assert(func0(2, 100) == 115);
assert(func0(8, 10) == 37);
assert(func0(8, 15) == 62);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xfe0,%rsp
mov %edi,-0xfd4(%rbp)
mov %esi,-0xfd8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x1,-0xfd0(%rbp)
movl $0x1,-0xfb0(%rbp)
movl $0x0,-0xfcc(%rbp)
jmpq 1306 <func0+0x19d>
movl $0x0,-0xfc8(%rbp)
movl $0x0,-0xfc4(%rbp)
jmpq 127b <func0+0x112>
mov -0xfc4(%rbp),%eax
cltq
mov -0xfb0(%rbp,%rax,4),%eax
movslq %eax,%rdx
mov -0xfd4(%rbp),%eax
cltq
imul %rax,%rdx
mov -0xfc8(%rbp),%eax
cltq
add %rdx,%rax
mov %rax,-0xfb8(%rbp)
mov -0xfb8(%rbp),%rcx
movabs $0x6666666666666667,%rdx
mov %rcx,%rax
imul %rdx
sar $0x2,%rdx
mov %rcx,%rax
sar $0x3f,%rax
sub %rax,%rdx
mov %rdx,%rax
shl $0x2,%rax
add %rdx,%rax
add %rax,%rax
sub %rax,%rcx
mov %rcx,%rdx
mov -0xfc4(%rbp),%eax
cltq
mov %edx,-0xfb0(%rbp,%rax,4)
mov -0xfb8(%rbp),%rcx
movabs $0x6666666666666667,%rdx
mov %rcx,%rax
imul %rdx
sar $0x2,%rdx
mov %rcx,%rax
sar $0x3f,%rax
sub %rax,%rdx
mov %rdx,%rax
mov %eax,-0xfc8(%rbp)
addl $0x1,-0xfc4(%rbp)
mov -0xfc4(%rbp),%eax
cmp -0xfd0(%rbp),%eax
jl 11cf <func0+0x66>
jmp 12f6 <func0+0x18d>
mov -0xfc8(%rbp),%ecx
movslq %ecx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar $0x2,%edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
sub %eax,%ecx
mov %ecx,%edx
mov -0xfd0(%rbp),%eax
cltq
mov %edx,-0xfb0(%rbp,%rax,4)
mov -0xfc8(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0xfc8(%rbp)
addl $0x1,-0xfd0(%rbp)
cmpl $0x0,-0xfc8(%rbp)
jg 128f <func0+0x126>
addl $0x1,-0xfcc(%rbp)
mov -0xfcc(%rbp),%eax
cmp -0xfd8(%rbp),%eax
jl 11b6 <func0+0x4d>
movl $0x0,-0xfc0(%rbp)
movl $0x0,-0xfbc(%rbp)
jmp 134a <func0+0x1e1>
mov -0xfbc(%rbp),%eax
cltq
mov -0xfb0(%rbp,%rax,4),%eax
add %eax,-0xfc0(%rbp)
addl $0x1,-0xfbc(%rbp)
mov -0xfbc(%rbp),%eax
cmp -0xfd0(%rbp),%eax
jl 132e <func0+0x1c5>
mov -0xfc0(%rbp),%eax
mov -0x8(%rbp),%rsi
xor %fs:0x28,%rsi
je 1372 <func0+0x209>
callq 1060 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0FE0h
mov [rbp+var_FD4], edi
mov [rbp+var_FD8], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_FD0], 1
mov [rbp+var_FB0], 1
mov [rbp+var_FCC], 0
jmp loc_1306
loc_11B6:
mov [rbp+var_FC8], 0
mov [rbp+var_FC4], 0
jmp loc_127B
loc_11CF:
mov eax, [rbp+var_FC4]
cdqe
mov eax, [rbp+rax*4+var_FB0]
movsxd rdx, eax
mov eax, [rbp+var_FD4]
cdqe
imul rdx, rax
mov eax, [rbp+var_FC8]
cdqe
add rax, rdx
mov [rbp+var_FB8], rax
mov rcx, [rbp+var_FB8]
mov rdx, 6666666666666667h
mov rax, rcx
imul rdx
sar rdx, 2
mov rax, rcx
sar rax, 3Fh
sub rdx, rax
mov rax, rdx
shl rax, 2
add rax, rdx
add rax, rax
sub rcx, rax
mov rdx, rcx
mov eax, [rbp+var_FC4]
cdqe
mov [rbp+rax*4+var_FB0], edx
mov rcx, [rbp+var_FB8]
mov rdx, 6666666666666667h
mov rax, rcx
imul rdx
mov rax, rdx
sar rax, 2
sar rcx, 3Fh
mov rdx, rcx
sub rax, rdx
mov [rbp+var_FC8], eax
add [rbp+var_FC4], 1
loc_127B:
mov eax, [rbp+var_FC4]
cmp eax, [rbp+var_FD0]
jl loc_11CF
jmp short loc_12F6
loc_128F:
mov ecx, [rbp+var_FC8]
movsxd rax, ecx
imul rax, 66666667h
shr rax, 20h
mov edx, eax
sar edx, 2
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
sub ecx, eax
mov edx, ecx
mov eax, [rbp+var_FD0]
cdqe
mov [rbp+rax*4+var_FB0], edx
mov eax, [rbp+var_FC8]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_FC8], eax
add [rbp+var_FD0], 1
loc_12F6:
cmp [rbp+var_FC8], 0
jg short loc_128F
add [rbp+var_FCC], 1
loc_1306:
mov eax, [rbp+var_FCC]
cmp eax, [rbp+var_FD8]
jl loc_11B6
mov [rbp+var_FC0], 0
mov [rbp+var_FBC], 0
jmp short loc_134A
loc_132E:
mov eax, [rbp+var_FBC]
cdqe
mov eax, [rbp+rax*4+var_FB0]
add [rbp+var_FC0], eax
add [rbp+var_FBC], 1
loc_134A:
mov eax, [rbp+var_FBC]
cmp eax, [rbp+var_FD0]
jl short loc_132E
mov eax, [rbp+var_FC0]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1372
call ___stack_chk_fail
locret_1372:
leave
retn | long long func0(int a1, int a2)
{
int v3; // [rsp+10h] [rbp-FD0h]
int i; // [rsp+14h] [rbp-FCCh]
int v5; // [rsp+18h] [rbp-FC8h]
int j; // [rsp+1Ch] [rbp-FC4h]
unsigned int v7; // [rsp+20h] [rbp-FC0h]
int k; // [rsp+24h] [rbp-FBCh]
long long v9; // [rsp+28h] [rbp-FB8h]
_DWORD v10[1002]; // [rsp+30h] [rbp-FB0h]
unsigned long long v11; // [rsp+FD8h] [rbp-8h]
v11 = __readfsqword(0x28u);
v3 = 1;
v10[0] = 1;
for ( i = 0; i < a2; ++i )
{
v5 = 0;
for ( j = 0; j < v3; ++j )
{
v9 = a1 * (long long)(int)v10[j] + v5;
v10[j] = (int)v9 % 10;
v5 = v9 / 10;
}
while ( v5 > 0 )
{
v10[v3] = v5 % 10;
v5 /= 10;
++v3;
}
}
v7 = 0;
for ( k = 0; k < v3; ++k )
v7 += v10[k];
return v7;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xfe0
MOV dword ptr [RBP + -0xfd4],EDI
MOV dword ptr [RBP + -0xfd8],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0xfd0],0x1
MOV dword ptr [RBP + -0xfb0],0x1
MOV dword ptr [RBP + -0xfcc],0x0
JMP 0x00101306
LAB_001011b6:
MOV dword ptr [RBP + -0xfc8],0x0
MOV dword ptr [RBP + -0xfc4],0x0
JMP 0x0010127b
LAB_001011cf:
MOV EAX,dword ptr [RBP + -0xfc4]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0xfb0]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0xfd4]
CDQE
IMUL RDX,RAX
MOV EAX,dword ptr [RBP + -0xfc8]
CDQE
ADD RAX,RDX
MOV qword ptr [RBP + -0xfb8],RAX
MOV RCX,qword ptr [RBP + -0xfb8]
MOV RDX,0x6666666666666667
MOV RAX,RCX
IMUL RDX
SAR RDX,0x2
MOV RAX,RCX
SAR RAX,0x3f
SUB RDX,RAX
MOV RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
ADD RAX,RAX
SUB RCX,RAX
MOV RDX,RCX
MOV EAX,dword ptr [RBP + -0xfc4]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0xfb0],EDX
MOV RCX,qword ptr [RBP + -0xfb8]
MOV RDX,0x6666666666666667
MOV RAX,RCX
IMUL RDX
MOV RAX,RDX
SAR RAX,0x2
SAR RCX,0x3f
MOV RDX,RCX
SUB RAX,RDX
MOV dword ptr [RBP + -0xfc8],EAX
ADD dword ptr [RBP + -0xfc4],0x1
LAB_0010127b:
MOV EAX,dword ptr [RBP + -0xfc4]
CMP EAX,dword ptr [RBP + -0xfd0]
JL 0x001011cf
JMP 0x001012f6
LAB_0010128f:
MOV ECX,dword ptr [RBP + -0xfc8]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x2
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
SUB ECX,EAX
MOV EDX,ECX
MOV EAX,dword ptr [RBP + -0xfd0]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0xfb0],EDX
MOV EAX,dword ptr [RBP + -0xfc8]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0xfc8],EAX
ADD dword ptr [RBP + -0xfd0],0x1
LAB_001012f6:
CMP dword ptr [RBP + -0xfc8],0x0
JG 0x0010128f
ADD dword ptr [RBP + -0xfcc],0x1
LAB_00101306:
MOV EAX,dword ptr [RBP + -0xfcc]
CMP EAX,dword ptr [RBP + -0xfd8]
JL 0x001011b6
MOV dword ptr [RBP + -0xfc0],0x0
MOV dword ptr [RBP + -0xfbc],0x0
JMP 0x0010134a
LAB_0010132e:
MOV EAX,dword ptr [RBP + -0xfbc]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0xfb0]
ADD dword ptr [RBP + -0xfc0],EAX
ADD dword ptr [RBP + -0xfbc],0x1
LAB_0010134a:
MOV EAX,dword ptr [RBP + -0xfbc]
CMP EAX,dword ptr [RBP + -0xfd0]
JL 0x0010132e
MOV EAX,dword ptr [RBP + -0xfc0]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101372
CALL 0x00101060
LAB_00101372:
LEAVE
RET | int func0(int param_1,int param_2)
{
long lVar1;
long in_FS_OFFSET;
int local_fd8;
int local_fd4;
int local_fd0;
int local_fcc;
int local_fc8;
int local_fc4;
int local_fb8 [1002];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_fd8 = 1;
local_fb8[0] = 1;
for (local_fd4 = 0; local_fd4 < param_2; local_fd4 = local_fd4 + 1) {
local_fd0 = 0;
for (local_fcc = 0; local_fcc < local_fd8; local_fcc = local_fcc + 1) {
lVar1 = (long)local_fd0 + (long)local_fb8[local_fcc] * (long)param_1;
local_fb8[local_fcc] = (int)lVar1 + (int)(lVar1 / 10) * -10;
local_fd0 = (int)(lVar1 / 10);
}
for (; 0 < local_fd0; local_fd0 = local_fd0 / 10) {
local_fb8[local_fd8] = local_fd0 % 10;
local_fd8 = local_fd8 + 1;
}
}
local_fc8 = 0;
for (local_fc4 = 0; local_fc4 < local_fd8; local_fc4 = local_fc4 + 1) {
local_fc8 = local_fc8 + local_fb8[local_fc4];
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_fc8;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,789 | func0 |
#include <assert.h>
| int func0(int base, int power) {
int digits[1000];
int size = 1;
digits[0] = 1;
for (int p = 0; p < power; p++) {
int carry = 0;
for (int i = 0; i < size; i++) {
long temp = (long)digits[i] * base + carry;
digits[i] = temp % 10;
carry = temp / 10;
}
while (carry > 0) {
digits[size] = carry % 10;
carry /= 10;
size++;
}
}
int sum = 0;
for (int i = 0; i < size; i++) {
sum += digits[i];
}
return sum;
}
| int main() {
assert(func0(2, 100) == 115);
assert(func0(8, 10) == 37);
assert(func0(8, 15) == 62);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0xfb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
movl $0x1,(%rsp)
test %esi,%esi
jle 1294 <func0+0x12b>
mov $0x0,%r9d
mov $0x1,%ebp
lea 0x4(%rsp),%r11
mov $0x0,%r10d
movslq %edi,%rdi
movabs $0x6666666666666667,%r8
jmpq 1249 <func0+0xe0>
mov %rsp,%rbx
lea -0x1(%rbp),%eax
lea (%r11,%rax,4),%r12
mov %r10d,%edx
movslq (%rbx),%rcx
imul %rdi,%rcx
movslq %edx,%rdx
add %rdx,%rcx
mov %rcx,%rax
imul %r8
sar $0x2,%rdx
mov %rcx,%rax
sar $0x3f,%rax
sub %rax,%rdx
lea (%rdx,%rdx,4),%rax
add %rax,%rax
sub %rax,%rcx
mov %ecx,(%rbx)
add $0x4,%rbx
cmp %r12,%rbx
jne 11cf <func0+0x66>
test %edx,%edx
jle 1240 <func0+0xd7>
add $0x1,%ebp
movslq %ebp,%rcx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edx,%ebx
sar $0x1f,%ebx
sub %ebx,%eax
lea (%rax,%rax,4),%ebx
add %ebx,%ebx
mov %edx,%ebp
sub %ebx,%ebp
mov %ebp,-0x4(%rsp,%rcx,4)
mov %edx,%ebx
mov %eax,%edx
mov %ecx,%ebp
add $0x1,%rcx
cmp $0x9,%ebx
jg 120f <func0+0xa6>
add $0x1,%r9d
cmp %r9d,%esi
je 1253 <func0+0xea>
test %ebp,%ebp
jg 11c2 <func0+0x59>
jmp 1240 <func0+0xd7>
test %ebp,%ebp
jle 128d <func0+0x124>
mov $0x0,%eax
mov $0x0,%edx
add (%rsp,%rax,4),%edx
add $0x1,%rax
cmp %eax,%ebp
jg 1261 <func0+0xf8>
mov 0xfa8(%rsp),%rax
xor %fs:0x28,%rax
jne 1299 <func0+0x130>
mov %edx,%eax
add $0xfb0,%rsp
pop %rbx
pop %rbp
pop %r12
retq
mov $0x0,%edx
jmp 126c <func0+0x103>
mov (%rsp),%edx
jmp 126c <func0+0x103>
callq 1060 <__stack_chk_fail@plt>
| func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 0FB0h
mov rax, fs:28h
mov [rsp+0FC8h+var_20], rax
xor eax, eax
mov [rsp+0FC8h+var_FC8], 1
test esi, esi
jle loc_1297
mov r9d, esi
mov r8d, 0
mov ebp, 1
lea r11, [rsp+0FC8h+var_FC4]
mov r10d, 0
movsxd rsi, edi
mov rdi, 6666666666666667h
jmp loc_124C
loc_11C5:
mov rbx, rsp
lea eax, [rbp-1]
lea r12, [r11+rax*4]
mov edx, r10d
loc_11D2:
movsxd rcx, dword ptr [rbx]
imul rcx, rsi
movsxd rdx, edx
add rcx, rdx
mov rax, rcx
imul rdi
sar rdx, 2
mov rax, rcx
sar rax, 3Fh
sub rdx, rax
lea rax, [rdx+rdx*4]
add rax, rax
sub rcx, rax
mov [rbx], ecx
add rbx, 4
cmp rbx, r12
jnz short loc_11D2
test edx, edx
jle short loc_1243
lea ecx, [rbp+1]
movsxd rcx, ecx
loc_1212:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ebx, edx
sar ebx, 1Fh
sub eax, ebx
lea ebx, [rax+rax*4]
add ebx, ebx
mov ebp, edx
sub ebp, ebx
mov [rsp+rcx*4+0FC8h+var_FCC], ebp
mov ebx, edx
mov edx, eax
mov ebp, ecx
add rcx, 1
cmp ebx, 9
jg short loc_1212
loc_1243:
add r8d, 1
cmp r9d, r8d
jz short loc_1256
loc_124C:
test ebp, ebp
jg loc_11C5
jmp short loc_1243
loc_1256:
test ebp, ebp
jle short loc_1290
mov eax, 0
mov edx, 0
loc_1264:
add edx, [rsp+rax*4+0FC8h+var_FC8]
add rax, 1
cmp ebp, eax
jg short loc_1264
loc_126F:
mov rax, [rsp+0FC8h+var_20]
sub rax, fs:28h
jnz short loc_129C
mov eax, edx
add rsp, 0FB0h
pop rbx
pop rbp
pop r12
retn
loc_1290:
mov edx, 0
jmp short loc_126F
loc_1297:
mov edx, [rsp+0FC8h+var_FC8]
jmp short loc_126F
loc_129C:
call ___stack_chk_fail | long long func0(int a1, int a2)
{
int v2; // r8d
int v3; // ebp
int *v4; // rbx
long long v5; // rdx
long long v6; // rcx
long long v7; // rcx
int v8; // ebx
long long v9; // rax
unsigned int v10; // edx
_DWORD v13[1002]; // [rsp+4h] [rbp-FC8h] BYREF
unsigned long long v14; // [rsp+FACh] [rbp-20h]
v14 = __readfsqword(0x28u);
v13[0] = 1;
if ( a2 <= 0 )
{
return v13[0];
}
else
{
v2 = 0;
v3 = 1;
do
{
if ( v3 > 0 )
{
v4 = v13;
LODWORD(v5) = 0;
do
{
v6 = (int)v5 + a1 * (long long)*v4;
v5 = v6 / 10;
*v4++ = v6 % 10;
}
while ( v4 != &v13[v3 - 1 + 1] );
if ( (int)v5 > 0 )
{
v7 = v3 + 1;
do
{
v13[v7 - 1] = (int)v5 % 10;
v8 = v5;
LODWORD(v5) = (int)v5 / 10;
v3 = v7++;
}
while ( v8 > 9 );
}
}
++v2;
}
while ( a2 != v2 );
if ( v3 <= 0 )
{
return 0;
}
else
{
v9 = 0LL;
v10 = 0;
do
v10 += v13[v9++];
while ( v3 > (int)v9 );
}
}
return v10;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xfb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x1
TEST ESI,ESI
JLE 0x00101297
MOV R9D,ESI
MOV R8D,0x0
MOV EBP,0x1
LEA R11,[RSP + 0x4]
MOV R10D,0x0
MOVSXD RSI,EDI
MOV RDI,0x6666666666666667
JMP 0x0010124c
LAB_001011c5:
MOV RBX,RSP
LEA EAX,[RBP + -0x1]
LEA R12,[R11 + RAX*0x4]
MOV EDX,R10D
LAB_001011d2:
MOVSXD RCX,dword ptr [RBX]
IMUL RCX,RSI
MOVSXD RDX,EDX
ADD RCX,RDX
MOV RAX,RCX
IMUL RDI
SAR RDX,0x2
MOV RAX,RCX
SAR RAX,0x3f
SUB RDX,RAX
LEA RAX,[RDX + RDX*0x4]
ADD RAX,RAX
SUB RCX,RAX
MOV dword ptr [RBX],ECX
ADD RBX,0x4
CMP RBX,R12
JNZ 0x001011d2
TEST EDX,EDX
JLE 0x00101243
LEA ECX,[RBP + 0x1]
MOVSXD RCX,ECX
LAB_00101212:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EBX,EDX
SAR EBX,0x1f
SUB EAX,EBX
LEA EBX,[RAX + RAX*0x4]
ADD EBX,EBX
MOV EBP,EDX
SUB EBP,EBX
MOV dword ptr [RSP + RCX*0x4 + -0x4],EBP
MOV EBX,EDX
MOV EDX,EAX
MOV EBP,ECX
ADD RCX,0x1
CMP EBX,0x9
JG 0x00101212
LAB_00101243:
ADD R8D,0x1
CMP R9D,R8D
JZ 0x00101256
LAB_0010124c:
TEST EBP,EBP
JG 0x001011c5
JMP 0x00101243
LAB_00101256:
TEST EBP,EBP
JLE 0x00101290
MOV EAX,0x0
MOV EDX,0x0
LAB_00101264:
ADD EDX,dword ptr [RSP + RAX*0x4]
ADD RAX,0x1
CMP EBP,EAX
JG 0x00101264
LAB_0010126f:
MOV RAX,qword ptr [RSP + 0xfa8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010129c
MOV EAX,EDX
ADD RSP,0xfb0
POP RBX
POP RBP
POP R12
RET
LAB_00101290:
MOV EDX,0x0
JMP 0x0010126f
LAB_00101297:
MOV EDX,dword ptr [RSP]
JMP 0x0010126f
LAB_0010129c:
CALL 0x00101060 | int func0(int param_1,int param_2)
{
long lVar1;
int iVar2;
int iVar3;
ulong uVar4;
int *piVar5;
int iVar6;
long in_FS_OFFSET;
int8 uStack_fd0;
int local_fc8 [1002];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_fc8[0] = 1;
if (param_2 < 1) {
iVar6 = 1;
}
else {
iVar6 = 0;
iVar2 = 1;
do {
if (0 < iVar2) {
uVar4 = 0;
piVar5 = local_fc8;
do {
lVar1 = (long)*piVar5 * (long)param_1 + (long)(int)uVar4;
uVar4 = lVar1 / 10;
*piVar5 = (int)lVar1 + (int)uVar4 * -10;
piVar5 = piVar5 + 1;
} while (piVar5 != local_fc8 + (ulong)(iVar2 - 1) + 1);
if (0 < (int)uVar4) {
lVar1 = (long)(iVar2 + 1);
do {
iVar3 = (int)uVar4;
*(int *)((long)&uStack_fd0 + lVar1 * 4 + 4) = iVar3 % 10;
uVar4 = (ulong)(uint)(iVar3 / 10);
iVar2 = (int)lVar1;
lVar1 = lVar1 + 1;
} while (9 < iVar3);
}
}
iVar6 = iVar6 + 1;
} while (param_2 != iVar6);
if (iVar2 < 1) {
iVar6 = 0;
}
else {
lVar1 = 0;
iVar6 = 0;
do {
iVar6 = iVar6 + local_fc8[lVar1];
lVar1 = lVar1 + 1;
} while ((int)lVar1 < iVar2);
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
uStack_fd0 = main;
__stack_chk_fail();
}
return iVar6;
} |
6,790 | func0 |
#include <assert.h>
| int func0(int base, int power) {
int digits[1000];
int size = 1;
digits[0] = 1;
for (int p = 0; p < power; p++) {
int carry = 0;
for (int i = 0; i < size; i++) {
long temp = (long)digits[i] * base + carry;
digits[i] = temp % 10;
carry = temp / 10;
}
while (carry > 0) {
digits[size] = carry % 10;
carry /= 10;
size++;
}
}
int sum = 0;
for (int i = 0; i < size; i++) {
sum += digits[i];
}
return sum;
}
| int main() {
assert(func0(2, 100) == 115);
assert(func0(8, 10) == 37);
assert(func0(8, 15) == 62);
return 0;
}
| O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xfb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
movl $0x1,(%rsp)
test %esi,%esi
jle 1360 <func0+0x140>
mov %esi,%ebp
movslq %edi,%r9
mov $0x1,%ecx
xor %ebx,%ebx
mov $0x1,%r12d
mov %rsp,%r8
lea 0x4(%rsp),%rsi
xor %r14d,%r14d
movabs $0x6666666666666667,%r11
mov $0xcccccccd,%r10d
nopw 0x0(%rax,%rax,1)
mov %r14d,%eax
mov %r8,%rdi
xor %edx,%edx
lea (%rsi,%rax,4),%r13
jmp 12a3 <func0+0x83>
nopw %cs:0x0(%rax,%rax,1)
movslq (%rdi),%rcx
imul %r9,%rcx
movslq %edx,%rdx
add $0x4,%rdi
add %rdx,%rcx
mov %rcx,%rax
imul %r11
mov %rcx,%rax
sar $0x3f,%rax
sar $0x2,%rdx
sub %rax,%rdx
lea (%rdx,%rdx,4),%rax
add %rax,%rax
sub %rax,%rcx
mov %ecx,-0x4(%rdi)
cmp %rdi,%r13
jne 12a0 <func0+0x80>
test %edx,%edx
jle 1317 <func0+0xf7>
add $0x1,%r12d
movslq %r12d,%rdi
nopw 0x0(%rax,%rax,1)
mov %edx,%eax
mov %edx,%r14d
mov %edi,%r12d
imul %r10,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%r14d
mov %edx,%ecx
mov %eax,%edx
mov %r14d,-0x4(%r8,%rdi,4)
add $0x1,%rdi
cmp $0x9,%ecx
jg 12e8 <func0+0xc8>
lea -0x1(%r12),%r14d
add $0x1,%ebx
movslq (%rsp),%rcx
cmp %ebx,%ebp
jne 1288 <func0+0x68>
lea (%rsi,%r14,4),%rdx
xor %eax,%eax
jmp 1336 <func0+0x116>
xchg %ax,%ax
mov (%rsi),%ecx
add $0x4,%rsi
add %ecx,%eax
cmp %rsi,%rdx
jne 1330 <func0+0x110>
mov 0xfa8(%rsp),%rbx
xor %fs:0x28,%rbx
jne 1367 <func0+0x147>
add $0xfb0,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0x1,%eax
jmp 133d <func0+0x11d>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0FB8h
mov rax, fs:28h
mov [rsp+0FE8h+var_40], rax
xor eax, eax
mov [rsp+0FE8h+var_FE8], 1
test esi, esi
jle loc_1360
mov r13d, esi
movsxd r9, edi
mov r15d, 1
xor ebp, ebp
mov edi, 1
mov rsi, rsp
lea r14, [rsp+0FE8h+var_FE4]
xor r12d, r12d
mov r11, 6666666666666667h
mov r10d, 0CCCCCCCDh
nop dword ptr [rax]
loc_1288:
mov eax, r12d
mov rbx, rsi
mov rcx, rsi
xor edx, edx
lea r8, [r14+rax*4]
jmp short loc_12A3
loc_12A0:
movsxd r15, dword ptr [rcx]
loc_12A3:
imul r15, r9
movsxd rdx, edx
add rcx, 4
add r15, rdx
mov rax, r15
imul r11
mov rax, r15
sar rax, 3Fh
sar rdx, 2
sub rdx, rax
lea rax, [rdx+rdx*4]
add rax, rax
sub r15, rax
mov [rcx-4], r15d
cmp rcx, r8
jnz short loc_12A0
test edx, edx
jle short loc_1317
lea ecx, [rdi+1]
movsxd rcx, ecx
nop word ptr [rax+rax+00h]
loc_12E8:
mov eax, edx
mov r8d, edx
imul rax, r10
shr rax, 23h
lea edi, [rax+rax*4]
add edi, edi
sub r8d, edi
mov edi, ecx
mov [rsi+rcx*4-4], r8d
mov r8d, edx
add rcx, 1
mov edx, eax
cmp r8d, 9
jg short loc_12E8
lea r12d, [rdi-1]
loc_1317:
add ebp, 1
movsxd r15, [rsp+0FE8h+var_FE8]
cmp r13d, ebp
jnz loc_1288
lea rdx, [r14+r12*4]
xor eax, eax
nop dword ptr [rax]
loc_1330:
add eax, [rbx]
add rbx, 4
cmp rdx, rbx
jnz short loc_1330
loc_133B:
mov rdx, [rsp+0FE8h+var_40]
sub rdx, fs:28h
jnz short loc_1367
add rsp, 0FB8h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1360:
mov eax, 1
jmp short loc_133B
loc_1367:
call ___stack_chk_fail | long long func0(int a1, int a2)
{
long long v2; // r9
long long v3; // r15
int v4; // ebp
int v5; // edi
long long v6; // r12
_DWORD *v7; // rbx
_DWORD *v8; // rcx
long long v9; // rdx
long long v10; // r15
long long v11; // rcx
int v12; // r8d
long long result; // rax
_DWORD v14[1002]; // [rsp+0h] [rbp-FE8h] BYREF
unsigned long long v15; // [rsp+FA8h] [rbp-40h]
v15 = __readfsqword(0x28u);
v14[0] = 1;
if ( a2 <= 0 )
return 1LL;
v2 = a1;
v3 = 1LL;
v4 = 0;
v5 = 1;
v6 = 0LL;
do
{
v7 = v14;
v8 = v14;
LODWORD(v9) = 0;
while ( 1 )
{
++v8;
v10 = (int)v9 + v2 * v3;
v9 = v10 / 10;
*(v8 - 1) = v10 % 10;
if ( v8 == &v14[(unsigned int)v6 + 1] )
break;
v3 = (int)*v8;
}
if ( (int)v9 > 0 )
{
v11 = v5 + 1;
do
{
v5 = v11;
v14[v11 - 1] = (unsigned int)v9 % 0xA;
v12 = v9;
++v11;
LODWORD(v9) = (unsigned int)v9 / 0xA;
}
while ( v12 > 9 );
v6 = (unsigned int)(v5 - 1);
}
++v4;
v3 = v14[0];
}
while ( a2 != v4 );
LODWORD(result) = 0;
do
result = (unsigned int)(*v7++ + result);
while ( &v14[v6 + 1] != v7 );
return result;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xfb8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x1
TEST ESI,ESI
JLE 0x00101360
MOV R13D,ESI
MOVSXD R9,EDI
MOV R15D,0x1
XOR EBP,EBP
MOV EDI,0x1
MOV RSI,RSP
LEA R14,[RSP + 0x4]
XOR R12D,R12D
MOV R11,0x6666666666666667
MOV R10D,0xcccccccd
NOP dword ptr [RAX]
LAB_00101288:
MOV EAX,R12D
MOV RBX,RSI
MOV RCX,RSI
XOR EDX,EDX
LEA R8,[R14 + RAX*0x4]
JMP 0x001012a3
LAB_001012a0:
MOVSXD R15,dword ptr [RCX]
LAB_001012a3:
IMUL R15,R9
MOVSXD RDX,EDX
ADD RCX,0x4
ADD R15,RDX
MOV RAX,R15
IMUL R11
MOV RAX,R15
SAR RAX,0x3f
SAR RDX,0x2
SUB RDX,RAX
LEA RAX,[RDX + RDX*0x4]
ADD RAX,RAX
SUB R15,RAX
MOV dword ptr [RCX + -0x4],R15D
CMP RCX,R8
JNZ 0x001012a0
TEST EDX,EDX
JLE 0x00101317
LEA ECX,[RDI + 0x1]
MOVSXD RCX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_001012e8:
MOV EAX,EDX
MOV R8D,EDX
IMUL RAX,R10
SHR RAX,0x23
LEA EDI,[RAX + RAX*0x4]
ADD EDI,EDI
SUB R8D,EDI
MOV EDI,ECX
MOV dword ptr [RSI + RCX*0x4 + -0x4],R8D
MOV R8D,EDX
ADD RCX,0x1
MOV EDX,EAX
CMP R8D,0x9
JG 0x001012e8
LEA R12D,[RDI + -0x1]
LAB_00101317:
ADD EBP,0x1
MOVSXD R15,dword ptr [RSP]
CMP R13D,EBP
JNZ 0x00101288
LEA RDX,[R14 + R12*0x4]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101330:
ADD EAX,dword ptr [RBX]
ADD RBX,0x4
CMP RDX,RBX
JNZ 0x00101330
LAB_0010133b:
MOV RDX,qword ptr [RSP + 0xfa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101367
ADD RSP,0xfb8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101360:
MOV EAX,0x1
JMP 0x0010133b
LAB_00101367:
CALL 0x00101060 | int func0(int param_1,int param_2)
{
int *piVar1;
int *piVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
int *piVar6;
int iVar7;
ulong uVar8;
ulong uVar9;
long lVar10;
long in_FS_OFFSET;
int8 uStack_ff0;
int local_fe8 [1002];
long local_40;
piVar6 = local_fe8;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_fe8[0] = 1;
if (param_2 < 1) {
iVar7 = 1;
}
else {
lVar10 = 1;
iVar7 = 0;
uVar8 = 1;
uVar9 = 0;
do {
uVar5 = 0;
piVar1 = local_fe8;
while( true ) {
piVar2 = piVar1 + 1;
lVar10 = lVar10 * param_1 + (long)(int)uVar5;
uVar5 = lVar10 / 10;
*piVar1 = (int)lVar10 + (int)uVar5 * -10;
if (piVar2 == local_fe8 + uVar9 + 1) break;
lVar10 = (long)*piVar2;
piVar1 = piVar2;
}
if (0 < (int)uVar5) {
uVar9 = (long)((int)uVar8 + 1);
do {
uVar3 = uVar9;
iVar4 = (int)uVar5;
uVar8 = uVar3 & 0xffffffff;
*(int *)((long)&uStack_ff0 + uVar3 * 4 + 4) =
iVar4 + (int)((uVar5 & 0xffffffff) / 10) * -10;
uVar5 = (uVar5 & 0xffffffff) / 10;
uVar9 = uVar3 + 1;
} while (9 < iVar4);
uVar9 = (ulong)((int)uVar3 - 1);
}
iVar7 = iVar7 + 1;
lVar10 = (long)local_fe8[0];
} while (param_2 != iVar7);
iVar7 = 0;
do {
iVar7 = iVar7 + *piVar6;
piVar6 = piVar6 + 1;
} while (local_fe8 + uVar9 + 1 != piVar6);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar7;
}
/* WARNING: Subroutine does not return */
uStack_ff0 = _fini;
__stack_chk_fail();
} |
6,791 | func0 |
#include <assert.h>
| int func0(int base, int power) {
int digits[1000];
int size = 1;
digits[0] = 1;
for (int p = 0; p < power; p++) {
int carry = 0;
for (int i = 0; i < size; i++) {
long temp = (long)digits[i] * base + carry;
digits[i] = temp % 10;
carry = temp / 10;
}
while (carry > 0) {
digits[size] = carry % 10;
carry /= 10;
size++;
}
}
int sum = 0;
for (int i = 0; i < size; i++) {
sum += digits[i];
}
return sum;
}
| int main() {
assert(func0(2, 100) == 115);
assert(func0(8, 10) == 37);
assert(func0(8, 15) == 62);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xfb8,%rsp
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
movl $0x1,(%rsp)
test %esi,%esi
jle 13c4 <func0+0x1a4>
mov %esi,%r13d
movslq %edi,%r10
xor %ebp,%ebp
mov $0x1,%r8d
mov %rsp,%rdi
xor %r12d,%r12d
lea 0x4(%rsp),%r14
movabs $0x6666666666666667,%rsi
mov $0xcccccccd,%r11d
mov %r12d,%eax
mov %rdi,%rbx
mov %rdi,%rcx
xor %edx,%edx
lea (%r14,%rax,4),%r9
movslq (%rcx),%r15
movslq %edx,%rdx
add $0x4,%rcx
imul %r10,%r15
add %rdx,%r15
mov %r15,%rax
imul %rsi
mov %r15,%rax
sar $0x3f,%rax
sar $0x2,%rdx
sub %rax,%rdx
lea (%rdx,%rdx,4),%rax
add %rax,%rax
sub %rax,%r15
mov %r15d,-0x4(%rcx)
cmp %r9,%rcx
jne 1290 <func0+0x70>
test %edx,%edx
jle 130a <func0+0xea>
add $0x1,%r8d
movslq %r8d,%rcx
nopl 0x0(%rax,%rax,1)
mov %edx,%eax
mov %edx,%r9d
imul %r11,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%r8d
add %r8d,%r8d
sub %r8d,%r9d
mov %ecx,%r8d
mov %r9d,-0x4(%rdi,%rcx,4)
mov %edx,%r9d
add $0x1,%rcx
mov %eax,%edx
cmp $0x9,%r9d
jg 12d8 <func0+0xb8>
lea -0x1(%r8),%r12d
add $0x1,%ebp
cmp %ebp,%r13d
jne 1280 <func0+0x60>
cmp $0x3,%r12d
jbe 13cb <func0+0x1ab>
mov %r8d,%eax
pxor %xmm0,%xmm0
shr $0x2,%eax
shl $0x4,%rax
add %rax,%rdi
nopl 0x0(%rax)
paddd (%rbx),%xmm0
add $0x10,%rbx
cmp %rdi,%rbx
jne 1338 <func0+0x118>
movdqa %xmm0,%xmm1
mov %r8d,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
test $0x3,%r8b
je 139f <func0+0x17f>
movslq %edx,%rcx
add (%rsp,%rcx,4),%eax
lea 0x1(%rdx),%ecx
cmp %ecx,%r8d
jle 139f <func0+0x17f>
movslq %ecx,%rcx
add (%rsp,%rcx,4),%eax
lea 0x2(%rdx),%ecx
cmp %ecx,%r8d
jle 139f <func0+0x17f>
movslq %ecx,%rcx
add $0x3,%edx
add (%rsp,%rcx,4),%eax
cmp %r8d,%edx
jge 139f <func0+0x17f>
movslq %edx,%rdx
add (%rsp,%rdx,4),%eax
mov 0xfa8(%rsp),%rbx
xor %fs:0x28,%rbx
jne 13d1 <func0+0x1b1>
add $0xfb8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x1,%eax
jmp 139f <func0+0x17f>
xor %edx,%edx
xor %eax,%eax
jmp 136f <func0+0x14f>
callq 1060 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0FB0h
mov rax, fs:28h
mov [rsp+0FD8h+var_30], rax
xor eax, eax
mov [rsp+0FD8h+var_FD8], 1
mov eax, 1
test esi, esi
jle loc_13BB
movsxd r8, edi
mov ebx, esi
xor r11d, r11d
mov ebp, 1
mov rdi, rsp
mov r13d, 1
mov r10, 6666666666666667h
mov r9d, 0CCCCCCCDh
loc_1280:
mov rsi, rdi
lea r12, [rdi+r13*4]
xor r14d, r14d
nop word ptr [rax+rax+00h]
loc_1290:
movsxd rcx, dword ptr [rsi]
add rsi, 4
imul rcx, r8
add rcx, r14
mov rax, rcx
imul r10
mov rax, rcx
sar rax, 3Fh
sar rdx, 2
sub rdx, rax
lea rax, [rdx+rdx*4]
movsxd r14, edx
add rax, rax
sub rcx, rax
mov [rsi-4], ecx
cmp rsi, r12
jnz short loc_1290
test edx, edx
jle loc_13F2
add ebp, 1
movsxd rbp, ebp
nop dword ptr [rax]
loc_12D8:
mov eax, r14d
mov ecx, r14d
imul rax, r9
shr rax, 23h
lea edx, [rax+rax*4]
add edx, edx
sub ecx, edx
mov edx, r14d
mov r14d, eax
mov rax, rbp
mov [rdi+rbp*4-4], ecx
add rbp, 1
cmp edx, 9
jg short loc_12D8
lea edx, [r11+1]
mov ebp, eax
cmp ebx, edx
jz short loc_1330
test eax, eax
jle short loc_1320
movsxd r13, eax
loc_1314:
mov r11d, edx
jmp loc_1280
loc_1320:
add r11d, 2
cmp ebx, r11d
jz loc_1403
nop dword ptr [rax]
loc_1330:
test ebp, ebp
jle loc_1403
cmp ebp, 3
jle loc_1407
mov eax, ebp
pxor xmm0, xmm0
shr eax, 2
shl rax, 4
lea rdx, [rdi+rax]
test al, 10h
jnz loc_13DE
nop word ptr [rax+rax+00h]
loc_1360:
paddd xmm0, xmmword ptr [rdi]
add rdi, 20h ; ' '
paddd xmm0, xmmword ptr [rdi-10h]
cmp rdi, rdx
jnz short loc_1360
loc_1372:
movdqa xmm1, xmm0
mov edx, ebp
psrldq xmm1, 8
and edx, 0FFFFFFFCh
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test bpl, 3
jz short loc_13BB
loc_139B:
movsxd rcx, edx
add eax, [rsp+rcx*4+0FD8h+var_FD8]
lea ecx, [rdx+1]
cmp ecx, ebp
jge short loc_13BB
movsxd rcx, ecx
add edx, 2
add eax, [rsp+rcx*4+0FD8h+var_FD8]
cmp ebp, edx
jle short loc_13BB
movsxd rdx, edx
add eax, [rsp+rdx*4+0FD8h+var_FD8]
loc_13BB:
mov rdx, [rsp+0FD8h+var_30]
sub rdx, fs:28h
jnz short loc_140D
add rsp, 0FB0h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_13DE:
movdqa xmm0, xmmword ptr [rdi]
lea rdi, [rsp+0FD8h+var_FC8]
cmp rdi, rdx
jnz loc_1360
jmp short loc_1372
loc_13F2:
lea edx, [r11+1]
cmp ebx, edx
jnz loc_1314
jmp loc_1330
loc_1403:
xor eax, eax
jmp short loc_13BB
loc_1407:
xor edx, edx
xor eax, eax
jmp short loc_139B
loc_140D:
call ___stack_chk_fail | long long func0(int a1, int a2)
{
long long result; // rax
long long v3; // r8
int v5; // r11d
int v6; // ebp
__m128i *v7; // rdi
long long v8; // r13
__m128i *v9; // rsi
long long v10; // r14
long long v11; // rcx
long long v12; // rcx
long long v13; // rbp
unsigned int v14; // ecx
int v15; // edx
int v16; // eax
int v17; // edx
__m128i v18; // xmm0
long long v19; // rax
__m128i *v20; // rdx
__m128i v21; // xmm0
int v22; // edx
__m128i v23; // xmm0
int v24; // ecx
int v25; // edx
__m128i v26; // [rsp+0h] [rbp-FD8h] BYREF
_BYTE v27[3992]; // [rsp+10h] [rbp-FC8h] BYREF
unsigned long long v28; // [rsp+FA8h] [rbp-30h]
v28 = __readfsqword(0x28u);
v26.m128i_i32[0] = 1;
result = 1LL;
if ( a2 <= 0 )
return result;
v3 = a1;
v5 = 0;
v6 = 1;
v7 = &v26;
v8 = 1LL;
while ( 1 )
{
v9 = &v26;
v10 = 0LL;
do
{
v11 = v9->m128i_i32[0];
v9 = (__m128i *)((char *)v9 + 4);
v12 = v10 + v3 * v11;
v10 = (int)(v12 / 10);
v9[-1].m128i_i32[3] = v12 % 10;
}
while ( v9 != (__m128i *)((char *)&v26 + 4 * v8) );
if ( (int)(v12 / 10) > 0 )
break;
v17 = v5 + 1;
if ( a2 == v5 + 1 )
goto LABEL_13;
LABEL_11:
v5 = v17;
}
v13 = v6 + 1;
do
{
v14 = (unsigned int)v10 % 0xA;
v15 = v10;
LODWORD(v10) = (unsigned int)v10 / 0xA;
v16 = v13;
v26.m128i_i32[v13++ - 1] = v14;
}
while ( v15 > 9 );
v17 = v5 + 1;
v6 = v16;
if ( a2 == v5 + 1 )
goto LABEL_13;
if ( v16 > 0 )
{
v8 = v16;
goto LABEL_11;
}
if ( a2 == v5 + 2 )
return 0LL;
LABEL_13:
if ( v6 <= 0 )
return 0LL;
if ( v6 <= 3 )
{
v22 = 0;
LODWORD(result) = 0;
goto LABEL_18;
}
v18 = 0LL;
v19 = 16LL * ((unsigned int)v6 >> 2);
v20 = (__m128i *)((char *)&v26 + v19);
if ( (v19 & 0x10) == 0 || (v18 = _mm_load_si128(&v26), v7 = (__m128i *)v27, v27 != (_BYTE *)v20) )
{
do
{
v21 = _mm_add_epi32(v18, *v7);
v7 += 2;
v18 = _mm_add_epi32(v21, v7[-1]);
}
while ( v7 != v20 );
}
v22 = v6 & 0x7FFFFFFC;
v23 = _mm_add_epi32(v18, _mm_srli_si128(v18, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v23, _mm_srli_si128(v23, 4)));
if ( (v6 & 3) != 0 )
{
LABEL_18:
result = (unsigned int)(v26.m128i_i32[v22] + result);
v24 = v22 + 1;
if ( v22 + 1 < v6 )
{
v25 = v22 + 2;
result = (unsigned int)(v26.m128i_i32[v24] + result);
if ( v6 > v25 )
return (unsigned int)(v26.m128i_i32[v25] + result);
}
}
return result;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xfb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x1
MOV EAX,0x1
TEST ESI,ESI
JLE 0x001013bb
MOVSXD R8,EDI
MOV EBX,ESI
XOR R11D,R11D
MOV EBP,0x1
MOV RDI,RSP
MOV R13D,0x1
MOV R10,0x6666666666666667
MOV R9D,0xcccccccd
LAB_00101280:
MOV RSI,RDI
LEA R12,[RDI + R13*0x4]
XOR R14D,R14D
NOP word ptr [RAX + RAX*0x1]
LAB_00101290:
MOVSXD RCX,dword ptr [RSI]
ADD RSI,0x4
IMUL RCX,R8
ADD RCX,R14
MOV RAX,RCX
IMUL R10
MOV RAX,RCX
SAR RAX,0x3f
SAR RDX,0x2
SUB RDX,RAX
LEA RAX,[RDX + RDX*0x4]
MOVSXD R14,EDX
ADD RAX,RAX
SUB RCX,RAX
MOV dword ptr [RSI + -0x4],ECX
CMP RSI,R12
JNZ 0x00101290
TEST EDX,EDX
JLE 0x001013f2
ADD EBP,0x1
MOVSXD RBP,EBP
NOP dword ptr [RAX]
LAB_001012d8:
MOV EAX,R14D
MOV ECX,R14D
IMUL RAX,R9
SHR RAX,0x23
LEA EDX,[RAX + RAX*0x4]
ADD EDX,EDX
SUB ECX,EDX
MOV EDX,R14D
MOV R14D,EAX
MOV RAX,RBP
MOV dword ptr [RDI + RBP*0x4 + -0x4],ECX
ADD RBP,0x1
CMP EDX,0x9
JG 0x001012d8
LEA EDX,[R11 + 0x1]
MOV EBP,EAX
CMP EBX,EDX
JZ 0x00101330
TEST EAX,EAX
JLE 0x00101320
MOVSXD R13,EAX
LAB_00101314:
MOV R11D,EDX
JMP 0x00101280
LAB_00101320:
ADD R11D,0x2
CMP EBX,R11D
JZ 0x00101403
NOP dword ptr [RAX]
LAB_00101330:
TEST EBP,EBP
JLE 0x00101403
CMP EBP,0x3
JLE 0x00101407
MOV EAX,EBP
PXOR XMM0,XMM0
SHR EAX,0x2
SHL RAX,0x4
LEA RDX,[RDI + RAX*0x1]
TEST AL,0x10
JNZ 0x001013de
NOP word ptr [RAX + RAX*0x1]
LAB_00101360:
PADDD XMM0,xmmword ptr [RDI]
ADD RDI,0x20
PADDD XMM0,xmmword ptr [RDI + -0x10]
CMP RDI,RDX
JNZ 0x00101360
LAB_00101372:
MOVDQA XMM1,XMM0
MOV EDX,EBP
PSRLDQ XMM1,0x8
AND EDX,0xfffffffc
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST BPL,0x3
JZ 0x001013bb
LAB_0010139b:
MOVSXD RCX,EDX
ADD EAX,dword ptr [RSP + RCX*0x4]
LEA ECX,[RDX + 0x1]
CMP ECX,EBP
JGE 0x001013bb
MOVSXD RCX,ECX
ADD EDX,0x2
ADD EAX,dword ptr [RSP + RCX*0x4]
CMP EBP,EDX
JLE 0x001013bb
MOVSXD RDX,EDX
ADD EAX,dword ptr [RSP + RDX*0x4]
LAB_001013bb:
MOV RDX,qword ptr [RSP + 0xfa8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010140d
ADD RSP,0xfb0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001013de:
MOVDQA XMM0,xmmword ptr [RDI]
LEA RDI,[RSP + 0x10]
CMP RDI,RDX
JNZ 0x00101360
JMP 0x00101372
LAB_001013f2:
LEA EDX,[R11 + 0x1]
CMP EBX,EDX
JNZ 0x00101314
JMP 0x00101330
LAB_00101403:
XOR EAX,EAX
JMP 0x001013bb
LAB_00101407:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x0010139b
LAB_0010140d:
CALL 0x00101060 | int func0(int param_1,int param_2)
{
uint uVar1;
ulong uVar2;
long lVar3;
uint uVar4;
int *piVar5;
int *piVar6;
int *piVar7;
long lVar8;
ulong uVar9;
long in_FS_OFFSET;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int local_fd8 [1002];
long local_30;
piVar7 = local_fd8;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_fd8[0] = 1;
iVar10 = 1;
if (param_2 < 1) goto LAB_001013bb;
iVar10 = 0;
uVar1 = 1;
lVar8 = 1;
LAB_00101280:
uVar9 = 0;
piVar5 = local_fd8;
do {
piVar6 = piVar5 + 1;
lVar3 = (long)*piVar5 * (long)param_1 + uVar9;
iVar11 = (int)(lVar3 / 10);
uVar9 = (ulong)iVar11;
*piVar5 = (int)lVar3 + iVar11 * -10;
piVar5 = piVar6;
} while (piVar6 != local_fd8 + lVar8);
if (iVar11 < 1) {
if (param_2 == iVar10 + 1) goto LAB_00101330;
}
else {
lVar8 = (long)(int)(uVar1 + 1);
do {
lVar3 = lVar8;
iVar11 = (int)uVar9;
uVar2 = uVar9 & 0xffffffff;
uVar9 = uVar2 / 10;
local_fd8[lVar3 + -1] = iVar11 + (int)(uVar2 / 10) * -10;
lVar8 = lVar3 + 1;
} while (9 < iVar11);
uVar1 = (uint)lVar3;
if (param_2 == iVar10 + 1) goto LAB_00101330;
if ((int)uVar1 < 1) {
if (param_2 == iVar10 + 2) goto LAB_00101403;
LAB_00101330:
if ((int)uVar1 < 1) {
LAB_00101403:
iVar10 = 0;
}
else {
if ((int)uVar1 < 4) {
uVar4 = 0;
iVar10 = 0;
}
else {
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
iVar13 = 0;
if (((ulong)(uVar1 >> 2) * 0x10 & 0x10) == 0) goto LAB_00101360;
iVar10 = local_fd8[0];
iVar11 = local_fd8[1];
iVar12 = local_fd8[2];
iVar13 = local_fd8[3];
for (piVar7 = local_fd8 + 4; piVar7 != local_fd8 + (ulong)(uVar1 >> 2) * 4;
piVar7 = piVar7 + 8) {
LAB_00101360:
iVar10 = iVar10 + *piVar7 + piVar7[4];
iVar11 = iVar11 + piVar7[1] + piVar7[5];
iVar12 = iVar12 + piVar7[2] + piVar7[6];
iVar13 = iVar13 + piVar7[3] + piVar7[7];
}
uVar4 = uVar1 & 0xfffffffc;
iVar10 = iVar10 + iVar12 + iVar11 + iVar13;
if ((uVar1 & 3) == 0) goto LAB_001013bb;
}
iVar10 = iVar10 + local_fd8[(int)uVar4];
if ((int)(uVar4 + 1) < (int)uVar1) {
iVar10 = iVar10 + local_fd8[(int)(uVar4 + 1)];
if ((int)(uVar4 + 2) < (int)uVar1) {
iVar10 = iVar10 + local_fd8[(int)(uVar4 + 2)];
}
}
}
LAB_001013bb:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar10;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
lVar8 = (long)(int)uVar1;
}
iVar10 = iVar10 + 1;
goto LAB_00101280;
} |
6,792 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char** func0(const char* text1, int* count) {
char **result = malloc(10 * sizeof(char*));
*count = 0;
int result_index = 0;
const char *start = text1;
const char *end = text1;
while (*start) {
if (*start == '"') {
end = ++start;
while (*end && *end != '"') ++end;
int len = end - start;
char *quoted_text = malloc((len + 1) * sizeof(char));
strncpy(quoted_text, start, len);
quoted_text[len] = '\0';
result[result_index++] = quoted_text;
(*count)++;
if (*end == '"') start = end + 1;
else break;
}
else {
start++;
}
}
return result;
}
| int main() {
int count;
char **result;
result = func0("Cortex \"A53\" Based \"multi\" tasking \"Processor\"", &count);
assert(count == 3);
assert(strcmp(result[0], "A53") == 0);
assert(strcmp(result[1], "multi") == 0);
assert(strcmp(result[2], "Processor") == 0);
result = func0("Cast your \"favorite\" entertainment \"apps\"", &count);
assert(count == 2);
assert(strcmp(result[0], "favorite") == 0);
assert(strcmp(result[1], "apps") == 0);
result = func0("Watch content \"4k Ultra HD\" resolution with \"HDR 10\" Support", &count);
assert(count == 2);
assert(strcmp(result[0], "4k Ultra HD") == 0);
assert(strcmp(result[1], "HDR 10") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov $0x50,%edi
callq 10d0 <malloc@plt>
mov %rax,-0x10(%rbp)
mov -0x40(%rbp),%rax
movl $0x0,(%rax)
movl $0x0,-0x28(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x20(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x18(%rbp)
jmpq 12e0 <func0+0x117>
mov -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp $0x22,%al
jne 12db <func0+0x112>
addq $0x1,-0x20(%rbp)
mov -0x20(%rbp),%rax
mov %rax,-0x18(%rbp)
jmp 1234 <func0+0x6b>
addq $0x1,-0x18(%rbp)
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
je 124a <func0+0x81>
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp $0x22,%al
jne 122f <func0+0x66>
mov -0x18(%rbp),%rax
sub -0x20(%rbp),%rax
mov %eax,-0x24(%rbp)
mov -0x24(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rcx
mov -0x8(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 1090 <strncpy@plt>
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x28(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x28(%rbp)
cltq
lea 0x0(,%rax,8),%rdx
mov -0x10(%rbp),%rax
add %rax,%rdx
mov -0x8(%rbp),%rax
mov %rax,(%rdx)
mov -0x40(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x40(%rbp),%rax
mov %edx,(%rax)
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp $0x22,%al
jne 12f1 <func0+0x128>
mov -0x18(%rbp),%rax
add $0x1,%rax
mov %rax,-0x20(%rbp)
jmp 12e0 <func0+0x117>
addq $0x1,-0x20(%rbp)
mov -0x20(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
jne 1211 <func0+0x48>
jmp 12f2 <func0+0x129>
mov -0x10(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov edi, 50h ; 'P'; size
call _malloc
mov [rbp+var_10], rax
mov rax, [rbp+var_40]
mov dword ptr [rax], 0
mov [rbp+var_28], 0
mov rax, [rbp+var_38]
mov [rbp+src], rax
mov rax, [rbp+var_38]
mov [rbp+var_18], rax
jmp loc_12E0
loc_1211:
mov rax, [rbp+src]
movzx eax, byte ptr [rax]
cmp al, 22h ; '"'
jnz loc_12DB
add [rbp+src], 1
mov rax, [rbp+src]
mov [rbp+var_18], rax
jmp short loc_1234
loc_122F:
add [rbp+var_18], 1
loc_1234:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
test al, al
jz short loc_124A
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp al, 22h ; '"'
jnz short loc_122F
loc_124A:
mov rax, [rbp+var_18]
sub rax, [rbp+src]
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+dest], rax
mov eax, [rbp+var_24]
movsxd rdx, eax; n
mov rcx, [rbp+src]
mov rax, [rbp+dest]
mov rsi, rcx; src
mov rdi, rax; dest
call _strncpy
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, [rbp+dest]
add rax, rdx
mov byte ptr [rax], 0
mov eax, [rbp+var_28]
lea edx, [rax+1]
mov [rbp+var_28], edx
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_10]
add rdx, rax
mov rax, [rbp+dest]
mov [rdx], rax
mov rax, [rbp+var_40]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_40]
mov [rax], edx
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp al, 22h ; '"'
jnz short loc_12F1
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+src], rax
jmp short loc_12E0
loc_12DB:
add [rbp+src], 1
loc_12E0:
mov rax, [rbp+src]
movzx eax, byte ptr [rax]
test al, al
jnz loc_1211
jmp short loc_12F2
loc_12F1:
nop
loc_12F2:
mov rax, [rbp+var_10]
leave
retn | _QWORD * func0(_BYTE *a1, _DWORD *a2)
{
int v2; // eax
int v4; // [rsp+18h] [rbp-28h]
char *srca; // [rsp+20h] [rbp-20h]
char *i; // [rsp+28h] [rbp-18h]
_QWORD *v8; // [rsp+30h] [rbp-10h]
char *dest; // [rsp+38h] [rbp-8h]
v8 = malloc(0x50uLL);
*a2 = 0;
v4 = 0;
while ( *a1 )
{
if ( *a1 == 34 )
{
srca = a1 + 1;
for ( i = srca; *i && *i != 34; ++i )
;
dest = (char *)malloc((int)i - (int)srca + 1);
strncpy(dest, srca, (int)i - (int)srca);
dest[(int)i - (int)srca] = 0;
v2 = v4++;
v8[v2] = dest;
++*a2;
if ( *i != 34 )
return v8;
a1 = i + 1;
}
else
{
++a1;
}
}
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV EDI,0x50
CALL 0x001010d0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX],0x0
MOV dword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001012e0
LAB_00101211:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x22
JNZ 0x001012db
ADD qword ptr [RBP + -0x20],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00101234
LAB_0010122f:
ADD qword ptr [RBP + -0x18],0x1
LAB_00101234:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JZ 0x0010124a
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x22
JNZ 0x0010122f
LAB_0010124a:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101090
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x28]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x28],EDX
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x10]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RDX],RAX
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 RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x22
JNZ 0x001012f1
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001012e0
LAB_001012db:
ADD qword ptr [RBP + -0x20],0x1
LAB_001012e0:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101211
JMP 0x001012f2
LAB_001012f1:
NOP
LAB_001012f2:
MOV RAX,qword ptr [RBP + -0x10]
LEAVE
RET | void * func0(char *param_1,int *param_2)
{
int iVar1;
void *pvVar2;
char *__dest;
int local_30;
char *local_28;
char *local_20;
pvVar2 = malloc(0x50);
*param_2 = 0;
local_30 = 0;
local_28 = param_1;
while( true ) {
while( true ) {
if (*local_28 == '\0') {
return pvVar2;
}
if (*local_28 == '\"') break;
local_28 = local_28 + 1;
}
local_28 = local_28 + 1;
for (local_20 = local_28; (*local_20 != '\0' && (*local_20 != '\"')); local_20 = local_20 + 1) {
}
iVar1 = (int)local_20 - (int)local_28;
__dest = (char *)malloc((long)(iVar1 + 1));
strncpy(__dest,local_28,(long)iVar1);
__dest[iVar1] = '\0';
*(char **)((long)local_30 * 8 + (long)pvVar2) = __dest;
*param_2 = *param_2 + 1;
if (*local_20 != '\"') break;
local_28 = local_20 + 1;
local_30 = local_30 + 1;
}
return pvVar2;
} |
6,793 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char** func0(const char* text1, int* count) {
char **result = malloc(10 * sizeof(char*));
*count = 0;
int result_index = 0;
const char *start = text1;
const char *end = text1;
while (*start) {
if (*start == '"') {
end = ++start;
while (*end && *end != '"') ++end;
int len = end - start;
char *quoted_text = malloc((len + 1) * sizeof(char));
strncpy(quoted_text, start, len);
quoted_text[len] = '\0';
result[result_index++] = quoted_text;
(*count)++;
if (*end == '"') start = end + 1;
else break;
}
else {
start++;
}
}
return result;
}
| int main() {
int count;
char **result;
result = func0("Cortex \"A53\" Based \"multi\" tasking \"Processor\"", &count);
assert(count == 3);
assert(strcmp(result[0], "A53") == 0);
assert(strcmp(result[1], "multi") == 0);
assert(strcmp(result[2], "Processor") == 0);
result = func0("Cast your \"favorite\" entertainment \"apps\"", &count);
assert(count == 2);
assert(strcmp(result[0], "favorite") == 0);
assert(strcmp(result[1], "apps") == 0);
result = func0("Watch content \"4k Ultra HD\" resolution with \"HDR 10\" Support", &count);
assert(count == 2);
assert(strcmp(result[0], "4k Ultra HD") == 0);
assert(strcmp(result[1], "HDR 10") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %rsi,%r15
mov $0x50,%edi
callq 10b0 <malloc@plt>
mov %rax,0x8(%rsp)
movl $0x0,(%r15)
movzbl (%rbx),%eax
test %al,%al
je 126f <func0+0xc6>
mov $0x0,%r13d
jmp 1260 <func0+0xb7>
lea 0x1(%rbx),%r14
movzbl 0x1(%rbx),%eax
test %al,%al
je 126a <func0+0xc1>
cmp $0x22,%al
je 126a <func0+0xc1>
mov %r14,%rbx
add $0x1,%rbx
movzbl (%rbx),%eax
test %al,%al
je 120c <func0+0x63>
cmp $0x22,%al
jne 11fd <func0+0x54>
mov %rbx,%r12
sub %r14,%r12
lea 0x1(%r12),%edi
movslq %edi,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rbp
movslq %r12d,%r12
mov %r12,%rdx
mov %r14,%rsi
mov %rax,%rdi
callq 1080 <strncpy@plt>
movb $0x0,0x0(%rbp,%r12,1)
lea 0x1(%r13),%eax
movslq %r13d,%r13
mov 0x8(%rsp),%rcx
mov %rbp,(%rcx,%r13,8)
addl $0x1,(%r15)
cmpb $0x22,(%rbx)
jne 126f <func0+0xc6>
add $0x1,%rbx
mov %eax,%r13d
movzbl (%rbx),%eax
test %al,%al
je 126f <func0+0xc6>
cmp $0x22,%al
je 11ea <func0+0x41>
add $0x1,%rbx
jmp 1259 <func0+0xb0>
mov %r14,%rbx
jmp 120c <func0+0x63>
mov 0x8(%rsp),%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 rbx, rdi
mov r15, rsi
mov edi, 50h ; 'P'
call _malloc
mov [rsp+48h+var_40], rax
mov dword ptr [r15], 0
movzx eax, byte ptr [rbx]
test al, al
jz loc_128F
mov r13d, 0
jmp short loc_121A
loc_120A:
mov rbx, r14
jmp short loc_1240
loc_120F:
add rbx, 1
loc_1213:
movzx eax, byte ptr [rbx]
test al, al
jz short loc_128F
loc_121A:
cmp al, 22h ; '"'
jnz short loc_120F
lea r14, [rbx+1]
movzx eax, byte ptr [rbx+1]
test al, al
jz short loc_120A
cmp al, 22h ; '"'
jz short loc_120A
mov rbx, r14
loc_1231:
add rbx, 1
movzx eax, byte ptr [rbx]
test al, al
jz short loc_1240
cmp al, 22h ; '"'
jnz short loc_1231
loc_1240:
mov r12, rbx
sub r12, r14
lea edi, [r12+1]
movsxd rdi, edi
call _malloc
mov rbp, rax
movsxd r12, r12d
mov rdx, r12
mov rsi, r14
mov rdi, rax
call _strncpy
mov byte ptr [rbp+r12+0], 0
lea eax, [r13+1]
movsxd r13, r13d
mov rcx, [rsp+48h+var_40]
mov [rcx+r13*8], rbp
add dword ptr [r15], 1
cmp byte ptr [rbx], 22h ; '"'
jnz short loc_128F
add rbx, 1
mov r13d, eax
jmp short loc_1213
loc_128F:
mov rax, [rsp+48h+var_40]
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(char *a1, _DWORD *a2)
{
char *v2; // rbx
char v3; // al
int v4; // r13d
_BYTE *v5; // rbx
_BYTE *v6; // r14
char v7; // al
long long v8; // rbp
long long v10; // [rsp+8h] [rbp-40h]
v2 = a1;
v10 = malloc(80LL);
*a2 = 0;
v3 = *a1;
if ( *a1 )
{
v4 = 0;
do
{
if ( v3 == 34 )
{
v6 = v2 + 1;
v7 = v2[1];
if ( !v7 || v7 == 34 )
{
v5 = v2 + 1;
}
else
{
v5 = v2 + 1;
do
++v5;
while ( *v5 && *v5 != 34 );
}
v8 = malloc((int)v5 - (int)v6 + 1);
strncpy(v8, v6, (int)v5 - (int)v6);
*(_BYTE *)(v8 + (int)v5 - (int)v6) = 0;
*(_QWORD *)(v10 + 8LL * v4) = v8;
++*a2;
if ( *v5 != 34 )
return v10;
v2 = v5 + 1;
++v4;
}
else
{
++v2;
}
v3 = *v2;
}
while ( *v2 );
}
return v10;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R15,RSI
MOV EDI,0x50
CALL 0x001010d0
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [R15],0x0
MOVZX EAX,byte ptr [RBX]
TEST AL,AL
JZ 0x0010128f
MOV R13D,0x0
JMP 0x0010121a
LAB_0010120a:
MOV RBX,R14
JMP 0x00101240
LAB_0010120f:
ADD RBX,0x1
LAB_00101213:
MOVZX EAX,byte ptr [RBX]
TEST AL,AL
JZ 0x0010128f
LAB_0010121a:
CMP AL,0x22
JNZ 0x0010120f
LEA R14,[RBX + 0x1]
MOVZX EAX,byte ptr [RBX + 0x1]
TEST AL,AL
JZ 0x0010120a
CMP AL,0x22
JZ 0x0010120a
MOV RBX,R14
LAB_00101231:
ADD RBX,0x1
MOVZX EAX,byte ptr [RBX]
TEST AL,AL
JZ 0x00101240
CMP AL,0x22
JNZ 0x00101231
LAB_00101240:
MOV R12,RBX
SUB R12,R14
LEA EDI,[R12 + 0x1]
MOVSXD RDI,EDI
CALL 0x001010d0
MOV RBP,RAX
MOVSXD R12,R12D
MOV RDX,R12
MOV RSI,R14
MOV RDI,RAX
CALL 0x00101090
MOV byte ptr [RBP + R12*0x1],0x0
LEA EAX,[R13 + 0x1]
MOVSXD R13,R13D
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RCX + R13*0x8],RBP
ADD dword ptr [R15],0x1
CMP byte ptr [RBX],0x22
JNZ 0x0010128f
ADD RBX,0x1
MOV R13D,EAX
JMP 0x00101213
LAB_0010128f:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | void * func0(char *param_1,int *param_2)
{
char *__src;
int iVar1;
char cVar2;
void *pvVar3;
char *__dest;
int iVar4;
pvVar3 = malloc(0x50);
*param_2 = 0;
cVar2 = *param_1;
if (cVar2 != '\0') {
iVar4 = 0;
do {
if (cVar2 == '\"') {
__src = param_1 + 1;
cVar2 = param_1[1];
param_1 = __src;
while ((cVar2 != '\0' && (cVar2 != '\"'))) {
param_1 = param_1 + 1;
cVar2 = *param_1;
}
iVar1 = (int)param_1 - (int)__src;
__dest = (char *)malloc((long)(iVar1 + 1));
strncpy(__dest,__src,(long)iVar1);
__dest[iVar1] = '\0';
*(char **)((long)pvVar3 + (long)iVar4 * 8) = __dest;
*param_2 = *param_2 + 1;
iVar4 = iVar4 + 1;
if (*param_1 != '\"') {
return pvVar3;
}
}
param_1 = param_1 + 1;
cVar2 = *param_1;
} while (cVar2 != '\0');
}
return pvVar3;
} |
6,794 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char** func0(const char* text1, int* count) {
char **result = malloc(10 * sizeof(char*));
*count = 0;
int result_index = 0;
const char *start = text1;
const char *end = text1;
while (*start) {
if (*start == '"') {
end = ++start;
while (*end && *end != '"') ++end;
int len = end - start;
char *quoted_text = malloc((len + 1) * sizeof(char));
strncpy(quoted_text, start, len);
quoted_text[len] = '\0';
result[result_index++] = quoted_text;
(*count)++;
if (*end == '"') start = end + 1;
else break;
}
else {
start++;
}
}
return result;
}
| int main() {
int count;
char **result;
result = func0("Cortex \"A53\" Based \"multi\" tasking \"Processor\"", &count);
assert(count == 3);
assert(strcmp(result[0], "A53") == 0);
assert(strcmp(result[1], "multi") == 0);
assert(strcmp(result[2], "Processor") == 0);
result = func0("Cast your \"favorite\" entertainment \"apps\"", &count);
assert(count == 2);
assert(strcmp(result[0], "favorite") == 0);
assert(strcmp(result[1], "apps") == 0);
result = func0("Watch content \"4k Ultra HD\" resolution with \"HDR 10\" Support", &count);
assert(count == 2);
assert(strcmp(result[0], "4k Ultra HD") == 0);
assert(strcmp(result[1], "HDR 10") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
mov %rsi,%r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
mov $0x50,%edi
push %rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
movl $0x0,(%r15)
mov %rax,%r14
movzbl 0x0(%rbp),%eax
test %al,%al
je 150e <func0+0xbe>
xor %r13d,%r13d
jmp 1499 <func0+0x49>
nopl (%rax)
mov %edx,%eax
mov %r12,%rbp
test %al,%al
je 150e <func0+0xbe>
movzbl 0x1(%rbp),%edx
lea 0x1(%rbp),%r12
cmp $0x22,%al
jne 1490 <func0+0x40>
mov %r12,%rbx
test %dl,%dl
je 1520 <func0+0xd0>
cmp $0x22,%dl
je 1520 <func0+0xd0>
nopl 0x0(%rax)
movzbl 0x1(%rbx),%eax
add $0x1,%rbx
test %al,%al
je 14c8 <func0+0x78>
cmp $0x22,%al
jne 14b8 <func0+0x68>
mov %rbx,%rbp
sub %r12,%rbp
lea 0x1(%rbp),%edi
movslq %ebp,%rbp
movslq %edi,%rdi
callq 10b0 <malloc@plt>
mov %rbp,%rdx
mov %r12,%rsi
mov %rax,%rdi
callq 1080 <strncpy@plt>
addl $0x1,(%r15)
cmpb $0x22,(%rbx)
lea 0x1(%r13),%edx
movb $0x0,(%rax,%rbp,1)
mov %rax,(%r14,%r13,8)
jne 150e <func0+0xbe>
movzbl 0x1(%rbx),%eax
lea 0x1(%rbx),%rbp
movslq %edx,%r13
test %al,%al
jne 1499 <func0+0x49>
add $0x8,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xor %ebp,%ebp
mov $0x1,%edi
jmp 14d7 <func0+0x87>
nopl 0x0(%rax)
| func0:
endbr64
push r15
mov r15, rsi
push r14
push r13
push r12
push rbp
mov rbp, rdi
mov edi, 50h ; 'P'
push rbx
sub rsp, 8
call _malloc
mov dword ptr [r15], 0
mov r14, rax
movzx eax, byte ptr [rbp+0]
test al, al
jz loc_1501
xor r13d, r13d
jmp short loc_148B
loc_1480:
mov rbp, r12
movzx eax, byte ptr [rbp+0]
test al, al
jz short loc_1501
loc_148B:
movzx edx, byte ptr [rbp+1]
lea r12, [rbp+1]
cmp al, 22h ; '"'
jnz short loc_1480
mov rbx, r12
test dl, dl
jz short loc_1518
cmp dl, 22h ; '"'
jz short loc_1518
nop dword ptr [rax+rax+00h]
loc_14A8:
mov rdx, rbx
movzx eax, byte ptr [rbx+1]
add rbx, 1
test al, al
jz short loc_14BB
cmp al, 22h ; '"'
jnz short loc_14A8
loc_14BB:
sub rdx, rbp
lea edi, [rdx+1]
movsxd rbp, edx
movsxd rdi, edi
loc_14C7:
call _malloc
mov rdx, rbp
mov rsi, r12
mov rdi, rax
call _strncpy
add dword ptr [r15], 1
cmp byte ptr [rbx], 22h ; '"'
mov rcx, rax
mov byte ptr [rax+rbp], 0
lea eax, [r13+1]
mov [r14+r13*8], rcx
jnz short loc_1501
lea rbp, [rbx+1]
movsxd r13, eax
movzx eax, byte ptr [rbp+0]
test al, al
jnz short loc_148B
loc_1501:
add rsp, 8
mov rax, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1518:
xor ebp, ebp
mov edi, 1
jmp short loc_14C7 | long long func0(_BYTE *a1, _DWORD *a2)
{
_BYTE *v2; // rbp
long long v3; // rax
long long v4; // r14
char v5; // al
long long v6; // r13
char v7; // dl
char *v8; // r12
_BYTE *v9; // rbx
int v10; // edx
char v11; // al
int v12; // edx
long long v13; // rbp
long long v14; // rdi
long long v15; // rax
long long v16; // rax
bool v17; // zf
v2 = a1;
v3 = malloc(80LL);
*a2 = 0;
v4 = v3;
v5 = *a1;
if ( *a1 )
{
v6 = 0LL;
do
{
while ( 1 )
{
v7 = v2[1];
v8 = v2 + 1;
if ( v5 == 34 )
break;
++v2;
v5 = *v8;
if ( !*v8 )
return v4;
}
v9 = v2 + 1;
if ( !v7 || v7 == 34 )
{
v13 = 0LL;
v14 = 1LL;
}
else
{
do
{
v10 = (int)v9;
v11 = *++v9;
}
while ( v11 && v11 != 34 );
v12 = v10 - (_DWORD)v2;
v13 = v12;
v14 = v12 + 1;
}
v15 = malloc(v14);
v16 = strncpy(v15, v8, v13);
++*a2;
v17 = *v9 == 34;
*(_BYTE *)(v16 + v13) = 0;
*(_QWORD *)(v4 + 8 * v6) = v16;
if ( !v17 )
break;
v2 = v9 + 1;
v6 = (int)v6 + 1;
v5 = v9[1];
}
while ( v5 );
}
return v4;
} | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
MOV EDI,0x50
PUSH RBX
SUB RSP,0x8
CALL 0x001010d0
MOV dword ptr [R15],0x0
MOV R14,RAX
MOVZX EAX,byte ptr [RBP]
TEST AL,AL
JZ 0x00101501
XOR R13D,R13D
JMP 0x0010148b
LAB_00101480:
MOV RBP,R12
MOVZX EAX,byte ptr [RBP]
TEST AL,AL
JZ 0x00101501
LAB_0010148b:
MOVZX EDX,byte ptr [RBP + 0x1]
LEA R12,[RBP + 0x1]
CMP AL,0x22
JNZ 0x00101480
MOV RBX,R12
TEST DL,DL
JZ 0x00101518
CMP DL,0x22
JZ 0x00101518
NOP dword ptr [RAX + RAX*0x1]
LAB_001014a8:
MOV RDX,RBX
MOVZX EAX,byte ptr [RBX + 0x1]
ADD RBX,0x1
TEST AL,AL
JZ 0x001014bb
CMP AL,0x22
JNZ 0x001014a8
LAB_001014bb:
SUB RDX,RBP
LEA EDI,[RDX + 0x1]
MOVSXD RBP,EDX
MOVSXD RDI,EDI
LAB_001014c7:
CALL 0x001010d0
MOV RDX,RBP
MOV RSI,R12
MOV RDI,RAX
CALL 0x00101090
ADD dword ptr [R15],0x1
CMP byte ptr [RBX],0x22
MOV RCX,RAX
MOV byte ptr [RAX + RBP*0x1],0x0
LEA EAX,[R13 + 0x1]
MOV qword ptr [R14 + R13*0x8],RCX
JNZ 0x00101501
LEA RBP,[RBX + 0x1]
MOVSXD R13,EAX
MOVZX EAX,byte ptr [RBP]
TEST AL,AL
JNZ 0x0010148b
LAB_00101501:
ADD RSP,0x8
MOV RAX,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101518:
XOR EBP,EBP
MOV EDI,0x1
JMP 0x001014c7 | void * func0(char *param_1,int *param_2)
{
int iVar1;
char cVar2;
void *pvVar3;
char *pcVar4;
char *pcVar5;
char *pcVar6;
size_t __n;
size_t __size;
long lVar7;
pvVar3 = malloc(0x50);
*param_2 = 0;
cVar2 = *param_1;
if (cVar2 != '\0') {
lVar7 = 0;
do {
while( true ) {
pcVar5 = param_1 + 1;
if (cVar2 != '\"') break;
if ((param_1[1] == '\0') || (pcVar6 = pcVar5, param_1[1] == '\"')) {
__n = 0;
__size = 1;
pcVar6 = pcVar5;
}
else {
do {
pcVar4 = pcVar6;
if (pcVar4[1] == '\0') break;
pcVar6 = pcVar4 + 1;
} while (pcVar4[1] != '\"');
iVar1 = (int)pcVar4 - (int)param_1;
__n = (size_t)iVar1;
__size = (size_t)(iVar1 + 1);
pcVar6 = pcVar4 + 1;
}
pcVar4 = (char *)malloc(__size);
pcVar5 = strncpy(pcVar4,pcVar5,__n);
*param_2 = *param_2 + 1;
cVar2 = *pcVar6;
pcVar5[__n] = '\0';
*(char **)((long)pvVar3 + lVar7 * 8) = pcVar5;
if (cVar2 != '\"') {
return pvVar3;
}
lVar7 = (long)((int)lVar7 + 1);
cVar2 = pcVar6[1];
param_1 = pcVar6 + 1;
if (cVar2 == '\0') {
return pvVar3;
}
}
cVar2 = *pcVar5;
param_1 = pcVar5;
} while (cVar2 != '\0');
}
return pvVar3;
} |
6,795 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char** func0(const char* text1, int* count) {
char **result = malloc(10 * sizeof(char*));
*count = 0;
int result_index = 0;
const char *start = text1;
const char *end = text1;
while (*start) {
if (*start == '"') {
end = ++start;
while (*end && *end != '"') ++end;
int len = end - start;
char *quoted_text = malloc((len + 1) * sizeof(char));
strncpy(quoted_text, start, len);
quoted_text[len] = '\0';
result[result_index++] = quoted_text;
(*count)++;
if (*end == '"') start = end + 1;
else break;
}
else {
start++;
}
}
return result;
}
| int main() {
int count;
char **result;
result = func0("Cortex \"A53\" Based \"multi\" tasking \"Processor\"", &count);
assert(count == 3);
assert(strcmp(result[0], "A53") == 0);
assert(strcmp(result[1], "multi") == 0);
assert(strcmp(result[2], "Processor") == 0);
result = func0("Cast your \"favorite\" entertainment \"apps\"", &count);
assert(count == 2);
assert(strcmp(result[0], "favorite") == 0);
assert(strcmp(result[1], "apps") == 0);
result = func0("Watch content \"4k Ultra HD\" resolution with \"HDR 10\" Support", &count);
assert(count == 2);
assert(strcmp(result[0], "4k Ultra HD") == 0);
assert(strcmp(result[1], "HDR 10") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
mov %rsi,%r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
mov $0x50,%edi
push %rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
movl $0x0,(%r15)
mov %rax,%r14
movzbl 0x0(%rbp),%eax
test %al,%al
je 150e <func0+0xbe>
xor %r13d,%r13d
jmp 1499 <func0+0x49>
nopl (%rax)
mov %edx,%eax
mov %r12,%rbp
test %al,%al
je 150e <func0+0xbe>
movzbl 0x1(%rbp),%edx
lea 0x1(%rbp),%r12
cmp $0x22,%al
jne 1490 <func0+0x40>
mov %r12,%rbx
test %dl,%dl
je 1520 <func0+0xd0>
cmp $0x22,%dl
je 1520 <func0+0xd0>
nopl 0x0(%rax)
movzbl 0x1(%rbx),%eax
add $0x1,%rbx
test %al,%al
je 14c8 <func0+0x78>
cmp $0x22,%al
jne 14b8 <func0+0x68>
mov %rbx,%rbp
sub %r12,%rbp
lea 0x1(%rbp),%edi
movslq %ebp,%rbp
movslq %edi,%rdi
callq 10b0 <malloc@plt>
mov %rbp,%rdx
mov %r12,%rsi
mov %rax,%rdi
callq 1080 <strncpy@plt>
addl $0x1,(%r15)
cmpb $0x22,(%rbx)
lea 0x1(%r13),%edx
movb $0x0,(%rax,%rbp,1)
mov %rax,(%r14,%r13,8)
jne 150e <func0+0xbe>
movzbl 0x1(%rbx),%eax
lea 0x1(%rbx),%rbp
movslq %edx,%r13
test %al,%al
jne 1499 <func0+0x49>
add $0x8,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xor %ebp,%ebp
mov $0x1,%edi
jmp 14d7 <func0+0x87>
nopl 0x0(%rax)
| func0:
endbr64
push r15
push r14
mov r14, rsi
push r13
push r12
push rbp
mov rbp, rdi
mov edi, 50h ; 'P'; size
push rbx
sub rsp, 18h
call _malloc
mov dword ptr [r14], 0
mov r12, rax
movzx eax, byte ptr [rbp+0]
test al, al
jz loc_151A
xor r13d, r13d
jmp short loc_148F
loc_1480:
mov rbp, r15
movzx eax, byte ptr [rbp+0]
test al, al
jz loc_151A
loc_148F:
movzx edx, byte ptr [rbp+1]
lea r15, [rbp+1]
cmp al, 22h ; '"'
jnz short loc_1480
mov rbx, r15
test dl, dl
jz loc_1530
cmp dl, 22h ; '"'
jz loc_1530
nop
loc_14B0:
mov rdx, rbx
movzx eax, byte ptr [rbx+1]
add rbx, 1
test al, al
jz short loc_14C3
cmp al, 22h ; '"'
jnz short loc_14B0
loc_14C3:
sub rdx, rbp
lea ecx, [rdx+1]
movsxd rbp, edx
movsxd rcx, ecx
loc_14CF:
mov rdi, rcx; size
mov [rsp+48h+var_40], rcx
call _malloc
mov rcx, [rsp+48h+var_40]
mov rdx, rbp
mov rsi, r15
mov rdi, rax
call ___strncpy_chk
add dword ptr [r14], 1
cmp byte ptr [rbx], 22h ; '"'
mov rdi, rax
mov byte ptr [rax+rbp], 0
lea eax, [r13+1]
mov [r12+r13*8], rdi
jnz short loc_151A
lea rbp, [rbx+1]
movsxd r13, eax
movzx eax, byte ptr [rbp+0]
test al, al
jnz loc_148F
loc_151A:
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1530:
xor ebp, ebp
mov ecx, 1
jmp short loc_14CF | _QWORD * func0(_BYTE *a1, _DWORD *a2)
{
_BYTE *v2; // rbp
_QWORD *v3; // rax
_QWORD *v4; // r12
char v5; // al
long long v6; // r13
char v7; // dl
char *v8; // r15
_BYTE *v9; // rbx
int v10; // edx
char v11; // al
int v12; // edx
long long v13; // rbp
size_t v14; // rcx
void *v15; // rax
long long v16; // rax
bool v17; // zf
size_t v19; // [rsp+8h] [rbp-40h]
v2 = a1;
v3 = malloc(0x50uLL);
*a2 = 0;
v4 = v3;
v5 = *a1;
if ( *a1 )
{
v6 = 0LL;
do
{
while ( 1 )
{
v7 = v2[1];
v8 = v2 + 1;
if ( v5 == 34 )
break;
++v2;
v5 = *v8;
if ( !*v8 )
return v4;
}
v9 = v2 + 1;
if ( !v7 || v7 == 34 )
{
v13 = 0LL;
v14 = 1LL;
}
else
{
do
{
v10 = (int)v9;
v11 = *++v9;
}
while ( v11 && v11 != 34 );
v12 = v10 - (_DWORD)v2;
v13 = v12;
v14 = v12 + 1;
}
v19 = v14;
v15 = malloc(v14);
v16 = __strncpy_chk(v15, v8, v13, v19);
++*a2;
v17 = *v9 == 34;
*(_BYTE *)(v16 + v13) = 0;
v4[v6] = v16;
if ( !v17 )
break;
v2 = v9 + 1;
v6 = (int)v6 + 1;
v5 = v9[1];
}
while ( v5 );
}
return v4;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
MOV EDI,0x50
PUSH RBX
SUB RSP,0x18
CALL 0x001010c0
MOV dword ptr [R14],0x0
MOV R12,RAX
MOVZX EAX,byte ptr [RBP]
TEST AL,AL
JZ 0x0010151a
XOR R13D,R13D
JMP 0x0010148f
LAB_00101480:
MOV RBP,R15
MOVZX EAX,byte ptr [RBP]
TEST AL,AL
JZ 0x0010151a
LAB_0010148f:
MOVZX EDX,byte ptr [RBP + 0x1]
LEA R15,[RBP + 0x1]
CMP AL,0x22
JNZ 0x00101480
MOV RBX,R15
TEST DL,DL
JZ 0x00101530
CMP DL,0x22
JZ 0x00101530
NOP
LAB_001014b0:
MOV RDX,RBX
MOVZX EAX,byte ptr [RBX + 0x1]
ADD RBX,0x1
TEST AL,AL
JZ 0x001014c3
CMP AL,0x22
JNZ 0x001014b0
LAB_001014c3:
SUB RDX,RBP
LEA ECX,[RDX + 0x1]
MOVSXD RBP,EDX
MOVSXD RCX,ECX
LAB_001014cf:
MOV RDI,RCX
MOV qword ptr [RSP + 0x8],RCX
CALL 0x001010c0
MOV RCX,qword ptr [RSP + 0x8]
MOV RDX,RBP
MOV RSI,R15
MOV RDI,RAX
CALL 0x001010d0
ADD dword ptr [R14],0x1
CMP byte ptr [RBX],0x22
MOV RDI,RAX
MOV byte ptr [RAX + RBP*0x1],0x0
LEA EAX,[R13 + 0x1]
MOV qword ptr [R12 + R13*0x8],RDI
JNZ 0x0010151a
LEA RBP,[RBX + 0x1]
MOVSXD R13,EAX
MOVZX EAX,byte ptr [RBP]
TEST AL,AL
JNZ 0x0010148f
LAB_0010151a:
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101530:
XOR EBP,EBP
MOV ECX,0x1
JMP 0x001014cf | void * func0(char *param_1,int *param_2)
{
char *pcVar1;
int iVar2;
char cVar3;
void *pvVar4;
void *pvVar5;
long lVar6;
size_t __size;
char *pcVar7;
char *pcVar8;
long lVar9;
long lVar10;
pvVar4 = malloc(0x50);
*param_2 = 0;
cVar3 = *param_1;
if (cVar3 != '\0') {
lVar10 = 0;
do {
while( true ) {
pcVar1 = param_1 + 1;
if (cVar3 != '\"') break;
if ((param_1[1] == '\0') || (pcVar8 = pcVar1, param_1[1] == '\"')) {
lVar9 = 0;
__size = 1;
pcVar8 = pcVar1;
}
else {
do {
pcVar7 = pcVar8;
if (pcVar7[1] == '\0') break;
pcVar8 = pcVar7 + 1;
} while (pcVar7[1] != '\"');
iVar2 = (int)pcVar7 - (int)param_1;
lVar9 = (long)iVar2;
__size = (size_t)(iVar2 + 1);
pcVar8 = pcVar7 + 1;
}
pvVar5 = malloc(__size);
lVar6 = __strncpy_chk(pvVar5,pcVar1,lVar9,__size);
*param_2 = *param_2 + 1;
cVar3 = *pcVar8;
*(int *)(lVar6 + lVar9) = 0;
*(long *)((long)pvVar4 + lVar10 * 8) = lVar6;
if (cVar3 != '\"') {
return pvVar4;
}
lVar10 = (long)((int)lVar10 + 1);
cVar3 = pcVar8[1];
param_1 = pcVar8 + 1;
if (cVar3 == '\0') {
return pvVar4;
}
}
cVar3 = *pcVar1;
param_1 = pcVar1;
} while (cVar3 != '\0');
}
return pvVar4;
} |
6,796 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(const int* test_tup, int size, int* result_size) {
static int res[100]; // Assume max size of tuple to process won't exceed 100 elements
*result_size = size - 1;
for (int i = 0; i < *result_size; i++) {
res[i] = test_tup[i] * test_tup[i + 1];
}
return res;
}
| int main() {
int result_size;
int* result;
int expected1[] = {5, 35, 56, 80};
int expected2[] = {8, 20, 30, 42};
int expected3[] = {156, 182, 126, 135};
int test1[] = {1, 5, 7, 8, 10};
int test2[] = {2, 4, 5, 6, 7};
int test3[] = {12, 13, 14, 9, 15};
result = func0(test1, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected1[i]);
}
result = func0(test2, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected2[i]);
}
result = func0(test3, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected3[i]);
}
printf("All tests passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov -0x1c(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x28(%rbp),%rax
mov %edx,(%rax)
movl $0x0,-0x4(%rbp)
jmp 1200 <func0+0x77>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
imul %edx,%eax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
lea 0x2e47(%rip),%rdx
mov %eax,(%rcx,%rdx,1)
addl $0x1,-0x4(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%eax
cmp %eax,-0x4(%rbp)
jl 11b1 <func0+0x28>
lea 0x2e2e(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov eax, [rbp+var_1C]
lea edx, [rax-1]
mov rax, [rbp+var_28]
mov [rax], edx
mov [rbp+var_4], 0
jmp short loc_1200
loc_11B1:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
imul eax, edx
mov edx, [rbp+var_4]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
lea rdx, res_1
mov [rcx+rdx], eax
add [rbp+var_4], 1
loc_1200:
mov rax, [rbp+var_28]
mov eax, [rax]
cmp [rbp+var_4], eax
jl short loc_11B1
lea rax, res_1
pop rbp
retn | _DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int i; // [rsp+24h] [rbp-4h]
*a3 = a2 - 1;
for ( i = 0; i < *a3; ++i )
res_1[i] = *(_DWORD *)(4LL * i + a1) * *(_DWORD *)(4 * (i + 1LL) + a1);
return res_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV EAX,dword ptr [RBP + -0x1c]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],EDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101200
LAB_001011b1:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
IMUL EAX,EDX
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
LEA RDX,[0x104040]
MOV dword ptr [RCX + RDX*0x1],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_00101200:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x4],EAX
JL 0x001011b1
LEA RAX,[0x104040]
POP RBP
RET | int1 * func0(long param_1,int param_2,int *param_3)
{
int local_c;
*param_3 = param_2 + -1;
for (local_c = 0; local_c < *param_3; local_c = local_c + 1) {
*(int *)(res_1 + (long)local_c * 4) =
*(int *)(param_1 + ((long)local_c + 1) * 4) * *(int *)(param_1 + (long)local_c * 4);
}
return res_1;
} |
6,797 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(const int* test_tup, int size, int* result_size) {
static int res[100]; // Assume max size of tuple to process won't exceed 100 elements
*result_size = size - 1;
for (int i = 0; i < *result_size; i++) {
res[i] = test_tup[i] * test_tup[i + 1];
}
return res;
}
| int main() {
int result_size;
int* result;
int expected1[] = {5, 35, 56, 80};
int expected2[] = {8, 20, 30, 42};
int expected3[] = {156, 182, 126, 135};
int test1[] = {1, 5, 7, 8, 10};
int test2[] = {2, 4, 5, 6, 7};
int test3[] = {12, 13, 14, 9, 15};
result = func0(test1, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected1[i]);
}
result = func0(test2, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected2[i]);
}
result = func0(test3, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected3[i]);
}
printf("All tests passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1,%esi
mov %esi,(%rdx)
test %esi,%esi
jle 11b5 <func0+0x2c>
mov $0x0,%eax
lea 0x2e9e(%rip),%rsi
mov (%rdi,%rax,4),%ecx
imul 0x4(%rdi,%rax,4),%ecx
mov %ecx,(%rsi,%rax,4)
add $0x1,%rax
cmp %eax,(%rdx)
jg 11a2 <func0+0x19>
lea 0x2e84(%rip),%rax
retq
| func0:
endbr64
sub esi, 1
mov [rdx], esi
test esi, esi
jle short loc_11B5
mov eax, 0
lea rsi, res_1
loc_11A2:
mov ecx, [rdi+rax*4]
imul ecx, [rdi+rax*4+4]
mov [rsi+rax*4], ecx
add rax, 1
cmp [rdx], eax
jg short loc_11A2
loc_11B5:
lea rax, res_1
retn | _DWORD * func0(long long a1, int a2, int *a3)
{
int v3; // esi
long long v4; // rax
v3 = a2 - 1;
*a3 = v3;
if ( v3 > 0 )
{
v4 = 0LL;
do
{
res_1[v4] = *(_DWORD *)(a1 + 4 * v4 + 4) * *(_DWORD *)(a1 + 4 * v4);
++v4;
}
while ( *a3 > (int)v4 );
}
return res_1;
} | func0:
ENDBR64
SUB ESI,0x1
MOV dword ptr [RDX],ESI
TEST ESI,ESI
JLE 0x001011b5
MOV EAX,0x0
LEA RSI,[0x104040]
LAB_001011a2:
MOV ECX,dword ptr [RDI + RAX*0x4]
IMUL ECX,dword ptr [RDI + RAX*0x4 + 0x4]
MOV dword ptr [RSI + RAX*0x4],ECX
ADD RAX,0x1
CMP dword ptr [RDX],EAX
JG 0x001011a2
LAB_001011b5:
LEA RAX,[0x104040]
RET | int4 * func0(long param_1,int param_2,int *param_3)
{
long lVar1;
*param_3 = param_2 + -1;
if (0 < param_2 + -1) {
lVar1 = 0;
do {
(&res_1)[lVar1] = *(int *)(param_1 + lVar1 * 4) * *(int *)(param_1 + 4 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while ((int)lVar1 < *param_3);
}
return &res_1;
} |
6,798 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(const int* test_tup, int size, int* result_size) {
static int res[100]; // Assume max size of tuple to process won't exceed 100 elements
*result_size = size - 1;
for (int i = 0; i < *result_size; i++) {
res[i] = test_tup[i] * test_tup[i + 1];
}
return res;
}
| int main() {
int result_size;
int* result;
int expected1[] = {5, 35, 56, 80};
int expected2[] = {8, 20, 30, 42};
int expected3[] = {156, 182, 126, 135};
int test1[] = {1, 5, 7, 8, 10};
int test2[] = {2, 4, 5, 6, 7};
int test3[] = {12, 13, 14, 9, 15};
result = func0(test1, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected1[i]);
}
result = func0(test2, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected2[i]);
}
result = func0(test3, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected3[i]);
}
printf("All tests passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
sub $0x1,%esi
mov %esi,(%rdx)
test %esi,%esi
jle 11c3 <func0+0x33>
xor %eax,%eax
lea 0x2e9a(%rip),%rsi
nopw %cs:0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%ecx
imul 0x4(%rdi,%rax,4),%ecx
mov %ecx,(%rsi,%rax,4)
add $0x1,%rax
cmp %eax,(%rdx)
jg 11b0 <func0+0x20>
lea 0x2e76(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
sub esi, 1
lea r8, res_1
mov [rdx], esi
test esi, esi
jle short loc_13F4
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_13E0:
mov ecx, [rdi+rax*4]
imul ecx, [rdi+rax*4+4]
mov [r8+rax*4], ecx
add rax, 1
cmp [rdx], eax
jg short loc_13E0
loc_13F4:
mov rax, r8
retn | _DWORD * func0(long long a1, int a2, int *a3)
{
int v3; // esi
long long v4; // rax
v3 = a2 - 1;
*a3 = v3;
if ( v3 > 0 )
{
v4 = 0LL;
do
{
res_1[v4] = *(_DWORD *)(a1 + 4 * v4 + 4) * *(_DWORD *)(a1 + 4 * v4);
++v4;
}
while ( *a3 > (int)v4 );
}
return res_1;
} | func0:
ENDBR64
SUB ESI,0x1
LEA R8,[0x104040]
MOV dword ptr [RDX],ESI
TEST ESI,ESI
JLE 0x001013f4
XOR EAX,EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001013e0:
MOV ECX,dword ptr [RDI + RAX*0x4]
IMUL ECX,dword ptr [RDI + RAX*0x4 + 0x4]
MOV dword ptr [R8 + RAX*0x4],ECX
ADD RAX,0x1
CMP dword ptr [RDX],EAX
JG 0x001013e0
LAB_001013f4:
MOV RAX,R8
RET | int4 * func0(long param_1,int param_2,int *param_3)
{
long lVar1;
*param_3 = param_2 + -1;
if (0 < param_2 + -1) {
lVar1 = 0;
do {
(&res_1)[lVar1] = *(int *)(param_1 + lVar1 * 4) * *(int *)(param_1 + 4 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while ((int)lVar1 < *param_3);
}
return &res_1;
} |
6,799 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(const int* test_tup, int size, int* result_size) {
static int res[100]; // Assume max size of tuple to process won't exceed 100 elements
*result_size = size - 1;
for (int i = 0; i < *result_size; i++) {
res[i] = test_tup[i] * test_tup[i + 1];
}
return res;
}
| int main() {
int result_size;
int* result;
int expected1[] = {5, 35, 56, 80};
int expected2[] = {8, 20, 30, 42};
int expected3[] = {156, 182, 126, 135};
int test1[] = {1, 5, 7, 8, 10};
int test2[] = {2, 4, 5, 6, 7};
int test3[] = {12, 13, 14, 9, 15};
result = func0(test1, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected1[i]);
}
result = func0(test2, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected2[i]);
}
result = func0(test3, 5, &result_size);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected3[i]);
}
printf("All tests passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
sub $0x1,%esi
mov %esi,(%rdx)
test %esi,%esi
jle 11b3 <func0+0x33>
xor %eax,%eax
lea 0x2eaa(%rip),%rsi
nopw %cs:0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%ecx
imul 0x4(%rdi,%rax,4),%ecx
mov %ecx,(%rsi,%rax,4)
add $0x1,%rax
cmp %eax,(%rdx)
jg 11a0 <func0+0x20>
lea 0x2e86(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
sub esi, 1
lea r8, res_1
mov [rdx], esi
test esi, esi
jle short loc_11B4
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_11A0:
mov ecx, [rdi+rax*4]
imul ecx, [rdi+rax*4+4]
mov [r8+rax*4], ecx
add rax, 1
cmp [rdx], eax
jg short loc_11A0
loc_11B4:
mov rax, r8
retn | __int128 * func0(long long a1, int a2, int *a3)
{
int v3; // esi
long long v4; // rax
v3 = a2 - 1;
*a3 = v3;
if ( v3 > 0 )
{
v4 = 0LL;
do
{
*((_DWORD *)&res_1 + v4) = *(_DWORD *)(a1 + 4 * v4 + 4) * *(_DWORD *)(a1 + 4 * v4);
++v4;
}
while ( *a3 > (int)v4 );
}
return &res_1;
} | func0:
ENDBR64
SUB ESI,0x1
LEA R8,[0x104040]
MOV dword ptr [RDX],ESI
TEST ESI,ESI
JLE 0x001011b4
XOR EAX,EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001011a0:
MOV ECX,dword ptr [RDI + RAX*0x4]
IMUL ECX,dword ptr [RDI + RAX*0x4 + 0x4]
MOV dword ptr [R8 + RAX*0x4],ECX
ADD RAX,0x1
CMP dword ptr [RDX],EAX
JG 0x001011a0
LAB_001011b4:
MOV RAX,R8
RET | int4 * func0(long param_1,int param_2,int *param_3)
{
long lVar1;
*param_3 = param_2 + -1;
if (0 < param_2 + -1) {
lVar1 = 0;
do {
(&res_1)[lVar1] = *(int *)(param_1 + lVar1 * 4) * *(int *)(param_1 + 4 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while ((int)lVar1 < *param_3);
}
return &res_1;
} |
6,800 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* S) {
static char result[100];
int j = 0;
for (int i = 0; i < strlen(S); i++) {
if (isalnum(S[i])) {
result[j++] = S[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("123abcjw:, .@! eiw"), "123abcjweiw") == 0);
assert(strcmp(func0("Hello1234:, ! Howare33u"), "Hello1234Howare33u") == 0);
assert(strcmp(func0("Cool543Triks@:, Make@987Trips"), "Cool543TriksMake987Trips") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 1223 <func0+0x7a>
callq 10b0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x8,%eax
test %eax,%eax
je 121f <func0+0x76>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x18(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x18(%rbp)
movzbl (%rcx),%edx
cltq
lea 0x2e24(%rip),%rcx
mov %dl,(%rax,%rcx,1)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
cmp %rax,%rbx
jb 11ca <func0+0x21>
mov -0x18(%rbp),%eax
cltq
lea 0x2dfa(%rip),%rdx
movb $0x0,(%rax,%rdx,1)
lea 0x2def(%rip),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_1223
loc_11CA:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_14]
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, 8
test eax, eax
jz short loc_121F
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
lea rcx, [rdx+rax]
mov eax, [rbp+var_18]
lea edx, [rax+1]
mov [rbp+var_18], edx
movzx edx, byte ptr [rcx]
cdqe
lea rcx, result_1
mov [rax+rcx], dl
loc_121F:
add [rbp+var_14], 1
loc_1223:
mov eax, [rbp+var_14]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_11CA
mov eax, [rbp+var_18]
cdqe
lea rdx, result_1
mov byte ptr [rax+rdx], 0
lea rax, result_1
mov rbx, [rbp+var_8]
leave
retn | _BYTE * func0(const char *a1)
{
int v1; // eax
int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v3 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( ((*__ctype_b_loc())[a1[i]] & 8) != 0 )
{
v1 = v3++;
result_1[v1] = a1[i];
}
}
result_1[v3] = 0;
return result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101223
LAB_001011ca:
CALL 0x001010b0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x28]
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,0x8
TEST EAX,EAX
JZ 0x0010121f
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x18],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
LEA RCX,[0x104040]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_0010121f:
ADD dword ptr [RBP + -0x14],0x1
LAB_00101223:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101080
CMP RBX,RAX
JC 0x001011ca
MOV EAX,dword ptr [RBP + -0x18]
CDQE
LEA RDX,[0x104040]
MOV byte ptr [RAX + RDX*0x1],0x0
LEA RAX,[0x104040]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | int1 * func0(char *param_1)
{
ushort **ppuVar1;
size_t sVar2;
int local_20;
int local_1c;
local_20 = 0;
local_1c = 0;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 <= (ulong)(long)local_1c) break;
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[param_1[local_1c]] & 8) != 0) {
result_1[local_20] = param_1[local_1c];
local_20 = local_20 + 1;
}
local_1c = local_1c + 1;
}
result_1[local_20] = 0;
return result_1;
} |
6,801 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* S) {
static char result[100];
int j = 0;
for (int i = 0; i < strlen(S); i++) {
if (isalnum(S[i])) {
result[j++] = S[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("123abcjw:, .@! eiw"), "123abcjweiw") == 0);
assert(strcmp(func0("Hello1234:, ! Howare33u"), "Hello1234Howare33u") == 0);
assert(strcmp(func0("Cool543Triks@:, Make@987Trips"), "Cool543TriksMake987Trips") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov $0x0,%ebx
mov $0x0,%r12d
mov $0xffffffffffffffff,%r14
mov $0x0,%r13d
lea 0x2ea3(%rip),%r15
jmp 11a3 <func0+0x3a>
add $0x1,%rbx
mov %r14,%rcx
mov %rbp,%rdi
mov %r13d,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp %rbx,%rcx
jbe 11e2 <func0+0x79>
callq 1070 <__ctype_b_loc@plt>
mov %rax,%rdx
movzbl 0x0(%rbp,%rbx,1),%eax
movsbq %al,%rcx
mov (%rdx),%rdx
testb $0x8,(%rdx,%rcx,2)
je 119f <func0+0x36>
movslq %r12d,%rdx
mov %al,(%r15,%rdx,1)
lea 0x1(%r12),%r12d
jmp 119f <func0+0x36>
lea 0x2e57(%rip),%rax
movslq %r12d,%r12
movb $0x0,(%rax,%r12,1)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, 0
mov r12d, 0
lea r13, result_1
jmp short loc_11D2
loc_11CE:
add rbx, 1
loc_11D2:
mov rdi, rbp
call _strlen
cmp rax, rbx
jbe short loc_1208
call ___ctype_b_loc
mov rdx, rax
movzx eax, byte ptr [rbp+rbx+0]
movsx rcx, al
mov rdx, [rdx]
test byte ptr [rdx+rcx*2], 8
jz short loc_11CE
movsxd rdx, r12d
mov [r13+rdx+0], al
lea r12d, [r12+1]
jmp short loc_11CE
loc_1208:
lea rax, result_1
movsxd r12, r12d
mov byte ptr [rax+r12], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(long long a1)
{
unsigned long long v1; // rbx
int v2; // r12d
_QWORD *v3; // rdx
char v4; // al
_BYTE *result; // rax
v1 = 0LL;
v2 = 0;
while ( strlen(a1) > v1 )
{
v3 = (_QWORD *)__ctype_b_loc();
v4 = *(_BYTE *)(a1 + v1);
if ( (*(_BYTE *)(*v3 + 2LL * v4) & 8) != 0 )
result_1[v2++] = v4;
++v1;
}
result = result_1;
result_1[v2] = 0;
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,0x0
MOV R12D,0x0
LEA R13,[0x104040]
JMP 0x001011d2
LAB_001011ce:
ADD RBX,0x1
LAB_001011d2:
MOV RDI,RBP
CALL 0x00101080
CMP RAX,RBX
JBE 0x00101208
CALL 0x001010b0
MOV RDX,RAX
MOVZX EAX,byte ptr [RBP + RBX*0x1]
MOVSX RCX,AL
MOV RDX,qword ptr [RDX]
TEST byte ptr [RDX + RCX*0x2],0x8
JZ 0x001011ce
MOVSXD RDX,R12D
MOV byte ptr [R13 + RDX*0x1],AL
LEA R12D,[R12 + 0x1]
JMP 0x001011ce
LAB_00101208:
LEA RAX,[0x104040]
MOVSXD R12,R12D
MOV byte ptr [RAX + R12*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void func0(char *param_1)
{
size_t sVar1;
ushort **ppuVar2;
ulong uVar3;
int iVar4;
uVar3 = 0;
iVar4 = 0;
while( true ) {
sVar1 = strlen(param_1);
if (sVar1 <= uVar3) break;
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[param_1[uVar3]] & 8) != 0) {
(&result_1)[iVar4] = param_1[uVar3];
iVar4 = iVar4 + 1;
}
uVar3 = uVar3 + 1;
}
(&result_1)[iVar4] = 0;
return;
} |
6,802 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* S) {
static char result[100];
int j = 0;
for (int i = 0; i < strlen(S); i++) {
if (isalnum(S[i])) {
result[j++] = S[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("123abcjw:, .@! eiw"), "123abcjweiw") == 0);
assert(strcmp(func0("Hello1234:, ! Howare33u"), "Hello1234Howare33u") == 0);
assert(strcmp(func0("Cool543Triks@:, Make@987Trips"), "Cool543TriksMake987Trips") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
lea 0x2dc3(%rip),%r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
xor %ebp,%ebp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %rax,%r12
jmp 12d1 <func0+0x61>
nopw 0x0(%rax,%rax,1)
callq 1090 <__ctype_b_loc@plt>
movsbq 0x0(%r13,%rbx,1),%rcx
mov %rax,%r8
mov (%r8),%rdx
testb $0x8,(%rdx,%rcx,2)
je 12cd <func0+0x5d>
mov %r13,%rdi
mov %cl,(%r15,%rbp,1)
lea 0x1(%rbp),%r14d
callq 1070 <strlen@plt>
movslq %r14d,%rbp
mov %rax,%r12
add $0x1,%rbx
cmp %r12,%rbx
jb 12a0 <func0+0x30>
movb $0x0,(%r15,%rbp,1)
add $0x8,%rsp
lea 0x2d5a(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
push r13
lea r13, result_1
push r12
xor r12d, r12d
push rbp
mov rbp, rdi
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_12C7
loc_12A0:
call ___ctype_b_loc
movsx rcx, byte ptr [rbp+rbx+0]
mov r8, rax
mov rdx, [r8]
test byte ptr [rdx+rcx*2], 8
jz short loc_12C3
movsxd rdx, r12d
add r12d, 1
mov [r13+rdx+0], cl
loc_12C3:
add rbx, 1
loc_12C7:
mov rdi, rbp
call _strlen
cmp rax, rbx
ja short loc_12A0
movsxd r12, r12d
mov rax, r13
mov byte ptr [r13+r12+0], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(long long a1)
{
int v1; // r12d
unsigned long long i; // rbx
_QWORD *v3; // rax
long long v4; // rcx
long long v5; // rdx
_BYTE *result; // rax
v1 = 0;
for ( i = 0LL; strlen(a1) > i; ++i )
{
v3 = (_QWORD *)__ctype_b_loc();
v4 = *(char *)(a1 + i);
if ( (*(_BYTE *)(*v3 + 2 * v4) & 8) != 0 )
{
v5 = v1++;
result_1[v5] = v4;
}
}
result = result_1;
result_1[v1] = 0;
return result;
} | func0:
ENDBR64
PUSH R13
LEA R13,[0x104040]
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RDI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x001012c7
LAB_001012a0:
CALL 0x001010b0
MOVSX RCX,byte ptr [RBP + RBX*0x1]
MOV R8,RAX
MOV RDX,qword ptr [R8]
TEST byte ptr [RDX + RCX*0x2],0x8
JZ 0x001012c3
MOVSXD RDX,R12D
ADD R12D,0x1
MOV byte ptr [R13 + RDX*0x1],CL
LAB_001012c3:
ADD RBX,0x1
LAB_001012c7:
MOV RDI,RBP
CALL 0x00101080
CMP RAX,RBX
JA 0x001012a0
MOVSXD R12,R12D
MOV RAX,R13
MOV byte ptr [R13 + R12*0x1],0x0
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | int1 * func0(char *param_1)
{
ushort **ppuVar1;
size_t sVar2;
long lVar3;
ulong uVar4;
int iVar5;
iVar5 = 0;
uVar4 = 0;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 <= uVar4) break;
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[param_1[uVar4]] & 8) != 0) {
lVar3 = (long)iVar5;
iVar5 = iVar5 + 1;
(&result_1)[lVar3] = param_1[uVar4];
}
uVar4 = uVar4 + 1;
}
(&result_1)[iVar5] = 0;
return &result_1;
} |
6,803 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* S) {
static char result[100];
int j = 0;
for (int i = 0; i < strlen(S); i++) {
if (isalnum(S[i])) {
result[j++] = S[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("123abcjw:, .@! eiw"), "123abcjweiw") == 0);
assert(strcmp(func0("Hello1234:, ! Howare33u"), "Hello1234Howare33u") == 0);
assert(strcmp(func0("Cool543Triks@:, Make@987Trips"), "Cool543TriksMake987Trips") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
test %rax,%rax
je 1318 <func0+0xa8>
mov %rax,%rbp
xor %ebx,%ebx
lea 0x2da1(%rip),%r13
callq 1090 <__ctype_b_loc@plt>
mov %rax,%r12
xor %eax,%eax
mov (%r12),%rsi
nopl (%rax)
movsbq (%r14,%rbx,1),%rcx
testb $0x8,(%rsi,%rcx,2)
je 12ea <func0+0x7a>
mov %r14,%rdi
mov %cl,0x0(%r13,%rax,1)
lea 0x1(%rax),%r15d
add $0x1,%rbx
callq 1070 <strlen@plt>
mov %rax,%rbp
cmp %rax,%rbx
jae 12f6 <func0+0x86>
mov (%r12),%rsi
movsbq (%r14,%rbx,1),%rcx
movslq %r15d,%rax
testb $0x8,(%rsi,%rcx,2)
jne 12bb <func0+0x4b>
add $0x1,%rbx
cmp %rbp,%rbx
jb 12b0 <func0+0x40>
mov %eax,%r15d
movslq %r15d,%r15
lea 0x2d40(%rip),%rax
movb $0x0,0x0(%r13,%r15,1)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
xor %r15d,%r15d
lea 0x2d1e(%rip),%r13
jmp 12f6 <func0+0x86>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r13
lea r13, result_1
push r12
xor r12d, r12d
push rbp
mov rbp, rdi
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_12C7
loc_12A0:
call ___ctype_b_loc
movsx rcx, byte ptr [rbp+rbx+0]
mov rdx, rax
mov rdx, [rdx]
test byte ptr [rdx+rcx*2], 8
jz short loc_12C3
movsxd rdx, r12d
add r12d, 1
mov [r13+rdx+0], cl
loc_12C3:
add rbx, 1
loc_12C7:
mov rdi, rbp; s
call _strlen
cmp rbx, rax
jb short loc_12A0
movsxd r12, r12d
mov rax, r13
mov byte ptr [r13+r12+0], 0
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _BYTE * func0(char *s)
{
int v1; // r12d
size_t i; // rbx
const unsigned __int16 **v3; // rax
long long v4; // rcx
long long v5; // rdx
_BYTE *result; // rax
v1 = 0;
for ( i = 0LL; i < strlen(s); ++i )
{
v3 = __ctype_b_loc();
v4 = s[i];
if ( ((*v3)[v4] & 8) != 0 )
{
v5 = v1++;
result_1[v5] = v4;
}
}
result = result_1;
result_1[v1] = 0;
return result;
} | ||
6,804 | func0 |
#include <assert.h>
| void func0(int *lst1, int *lst2, int *res_list, int size) {
for (int i = 0; i < size; i++) {
res_list[i] = lst1[i] + lst2[i];
}
}
| int main() {
int lst1_1[] = {10, 20, 30};
int lst2_1[] = {15, 25, 35};
int res_list_1[3];
func0(lst1_1, lst2_1, res_list_1, 3);
assert(res_list_1[0] == 25);
assert(res_list_1[1] == 45);
assert(res_list_1[2] == 65);
int lst1_2[] = {1, 2, 3};
int lst2_2[] = {5, 6, 7};
int res_list_2[3];
func0(lst1_2, lst2_2, res_list_2, 3);
assert(res_list_2[0] == 6);
assert(res_list_2[1] == 8);
assert(res_list_2[2] == 10);
int lst1_3[] = {15, 20, 30};
int lst2_3[] = {15, 45, 75};
int res_list_3[3];
func0(lst1_3, lst2_3, res_list_3, 3);
assert(res_list_3[0] == 30);
assert(res_list_3[1] == 65);
assert(res_list_3[2] == 105);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d1 <func0+0x68>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rsi
mov -0x28(%rbp),%rax
add %rsi,%rax
add %ecx,%edx
mov %edx,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1189 <func0+0x20>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_4], 0
jmp short loc_11D1
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rsi, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rsi
add edx, ecx
mov [rax], edx
add [rbp+var_4], 1
loc_11D1:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_2C]
jl short loc_1189
nop
nop
pop rbp
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
unsigned int i; // [rsp+28h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a4 )
break;
*(_DWORD *)(4LL * (int)i + a3) = *(_DWORD *)(4LL * (int)i + a1) + *(_DWORD *)(4LL * (int)i + a2);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d1
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RSI,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RSI
ADD EDX,ECX
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101189
NOP
NOP
POP RBP
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
*(int *)(param_3 + (long)local_c * 4) =
*(int *)(param_2 + (long)local_c * 4) + *(int *)(param_1 + (long)local_c * 4);
}
return;
} |
6,805 | func0 |
#include <assert.h>
| void func0(int *lst1, int *lst2, int *res_list, int size) {
for (int i = 0; i < size; i++) {
res_list[i] = lst1[i] + lst2[i];
}
}
| int main() {
int lst1_1[] = {10, 20, 30};
int lst2_1[] = {15, 25, 35};
int res_list_1[3];
func0(lst1_1, lst2_1, res_list_1, 3);
assert(res_list_1[0] == 25);
assert(res_list_1[1] == 45);
assert(res_list_1[2] == 65);
int lst1_2[] = {1, 2, 3};
int lst2_2[] = {5, 6, 7};
int res_list_2[3];
func0(lst1_2, lst2_2, res_list_2, 3);
assert(res_list_2[0] == 6);
assert(res_list_2[1] == 8);
assert(res_list_2[2] == 10);
int lst1_3[] = {15, 20, 30};
int lst2_3[] = {15, 45, 75};
int res_list_3[3];
func0(lst1_3, lst2_3, res_list_3, 3);
assert(res_list_3[0] == 30);
assert(res_list_3[1] == 65);
assert(res_list_3[2] == 105);
return 0;
}
| O1 | c | func0:
endbr64
test %ecx,%ecx
jle 118f <func0+0x26>
lea -0x1(%rcx),%r8d
mov $0x0,%eax
mov (%rsi,%rax,4),%ecx
add (%rdi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 117a <func0+0x11>
retq
| func0:
endbr64
test ecx, ecx
jle short locret_118D
mov ecx, ecx
mov eax, 0
loc_1178:
mov r8d, [rsi+rax*4]
add r8d, [rdi+rax*4]
mov [rdx+rax*4], r8d
add rax, 1
cmp rax, rcx
jnz short loc_1178
locret_118D:
retn | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i) + *(_DWORD *)(a2 + 4 * i);
}
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x0010118d
MOV ECX,ECX
MOV EAX,0x0
LAB_00101178:
MOV R8D,dword ptr [RSI + RAX*0x4]
ADD R8D,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RDX + RAX*0x4],R8D
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101178
LAB_0010118d:
RET | void func0(long param_1,long param_2,long param_3,uint param_4)
{
ulong uVar1;
if (0 < (int)param_4) {
uVar1 = 0;
do {
*(int *)(param_3 + uVar1 * 4) = *(int *)(param_2 + uVar1 * 4) + *(int *)(param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
}
return;
} |
6,806 | func0 |
#include <assert.h>
| void func0(int *lst1, int *lst2, int *res_list, int size) {
for (int i = 0; i < size; i++) {
res_list[i] = lst1[i] + lst2[i];
}
}
| int main() {
int lst1_1[] = {10, 20, 30};
int lst2_1[] = {15, 25, 35};
int res_list_1[3];
func0(lst1_1, lst2_1, res_list_1, 3);
assert(res_list_1[0] == 25);
assert(res_list_1[1] == 45);
assert(res_list_1[2] == 65);
int lst1_2[] = {1, 2, 3};
int lst2_2[] = {5, 6, 7};
int res_list_2[3];
func0(lst1_2, lst2_2, res_list_2, 3);
assert(res_list_2[0] == 6);
assert(res_list_2[1] == 8);
assert(res_list_2[2] == 10);
int lst1_3[] = {15, 20, 30};
int lst2_3[] = {15, 45, 75};
int res_list_3[3];
func0(lst1_3, lst2_3, res_list_3, 3);
assert(res_list_3[0] == 30);
assert(res_list_3[1] == 65);
assert(res_list_3[2] == 105);
return 0;
}
| O2 | c | func0:
endbr64
test %ecx,%ecx
jle 1165 <func0+0x25>
lea -0x1(%rcx),%r8d
xor %eax,%eax
xchg %ax,%ax
mov (%rsi,%rax,4),%ecx
add (%rdi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 1150 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test ecx, ecx
jle short locret_1165
movsxd rcx, ecx
xor eax, eax
nop dword ptr [rax]
loc_1150:
mov r8d, [rsi+rax*4]
add r8d, [rdi+rax*4]
mov [rdx+rax*4], r8d
add rax, 1
cmp rcx, rax
jnz short loc_1150
locret_1165:
retn | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i) + *(_DWORD *)(a2 + 4 * i);
}
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101165
MOVSXD RCX,ECX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101150:
MOV R8D,dword ptr [RSI + RAX*0x4]
ADD R8D,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RDX + RAX*0x4],R8D
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x00101150
LAB_00101165:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(int *)(param_3 + lVar1 * 4) = *(int *)(param_2 + lVar1 * 4) + *(int *)(param_1 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_4 != lVar1);
}
return;
} |
6,807 | func0 |
#include <assert.h>
| void func0(int *lst1, int *lst2, int *res_list, int size) {
for (int i = 0; i < size; i++) {
res_list[i] = lst1[i] + lst2[i];
}
}
| int main() {
int lst1_1[] = {10, 20, 30};
int lst2_1[] = {15, 25, 35};
int res_list_1[3];
func0(lst1_1, lst2_1, res_list_1, 3);
assert(res_list_1[0] == 25);
assert(res_list_1[1] == 45);
assert(res_list_1[2] == 65);
int lst1_2[] = {1, 2, 3};
int lst2_2[] = {5, 6, 7};
int res_list_2[3];
func0(lst1_2, lst2_2, res_list_2, 3);
assert(res_list_2[0] == 6);
assert(res_list_2[1] == 8);
assert(res_list_2[2] == 10);
int lst1_3[] = {15, 20, 30};
int lst2_3[] = {15, 45, 75};
int res_list_3[3];
func0(lst1_3, lst2_3, res_list_3, 3);
assert(res_list_3[0] == 30);
assert(res_list_3[1] == 65);
assert(res_list_3[2] == 105);
return 0;
}
| O3 | c | func0:
endbr64
test %ecx,%ecx
jle 120d <func0+0xcd>
lea 0xf(%rdi),%r8
lea -0x1(%rcx),%eax
sub %rdx,%r8
cmp $0x1e,%r8
seta %r9b
cmp $0x2,%eax
seta %r8b
test %r8b,%r9b
je 11f0 <func0+0xb0>
lea 0xf(%rsi),%r8
sub %rdx,%r8
cmp $0x1e,%r8
jbe 11f0 <func0+0xb0>
mov %ecx,%r8d
xor %eax,%eax
shr $0x2,%r8d
shl $0x4,%r8
nopl 0x0(%rax,%rax,1)
movdqu (%rdi,%rax,1),%xmm0
movdqu (%rsi,%rax,1),%xmm1
paddd %xmm1,%xmm0
movups %xmm0,(%rdx,%rax,1)
add $0x10,%rax
cmp %r8,%rax
jne 1190 <func0+0x50>
mov %ecx,%eax
and $0xfffffffc,%eax
test $0x3,%cl
je 120d <func0+0xcd>
mov %eax,%r8d
mov (%rsi,%r8,4),%r9d
add (%rdi,%r8,4),%r9d
mov %r9d,(%rdx,%r8,4)
lea 0x1(%rax),%r8d
cmp %r8d,%ecx
jle 120d <func0+0xcd>
movslq %r8d,%r8
add $0x2,%eax
mov (%rsi,%r8,4),%r9d
add (%rdi,%r8,4),%r9d
mov %r9d,(%rdx,%r8,4)
cmp %eax,%ecx
jle 120d <func0+0xcd>
cltq
mov (%rsi,%rax,4),%ecx
add (%rdi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
retq
mov %eax,%r8d
xor %eax,%eax
nopl (%rax)
mov (%rsi,%rax,4),%ecx
add (%rdi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 11f8 <func0+0xb8>
retq
xchg %ax,%ax
| func0:
endbr64
movsxd rax, ecx
mov r8, rsi
mov rsi, rdx
test eax, eax
jle locret_122B
cmp eax, 1
jz loc_1208
lea rcx, [rdi+4]
sub rdx, rcx
cmp rdx, 8
jbe loc_1208
lea rcx, [r8+4]
mov rdx, rsi
sub rdx, rcx
cmp rdx, 8
jbe loc_1208
lea edx, [rax-1]
mov r9d, eax
cmp edx, 2
jbe loc_122C
mov ecx, eax
xor edx, edx
shr ecx, 2
shl rcx, 4
nop dword ptr [rax]
loc_11A0:
movdqu xmm0, xmmword ptr [rdi+rdx]
movdqu xmm2, xmmword ptr [r8+rdx]
paddd xmm0, xmm2
movups xmmword ptr [rsi+rdx], xmm0
add rdx, 10h
cmp rcx, rdx
jnz short loc_11A0
mov edx, eax
and edx, 0FFFFFFFCh
mov ecx, edx
cmp eax, edx
jz short locret_122B
sub eax, edx
mov r9d, eax
cmp eax, 1
jz short loc_11F4
loc_11D1:
mov eax, ecx
movq xmm0, qword ptr [rdi+rax*4]
movq xmm1, qword ptr [r8+rax*4]
paddd xmm0, xmm1
movq qword ptr [rsi+rax*4], xmm0
test r9b, 1
jz short locret_122B
and r9d, 0FFFFFFFEh
add edx, r9d
loc_11F4:
movsxd rax, edx
mov edx, [r8+rax*4]
add edx, [rdi+rax*4]
mov [rsi+rax*4], edx
retn
loc_1208:
lea rcx, ds:0[rax*4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1218:
mov edx, [r8+rax]
add edx, [rdi+rax]
mov [rsi+rax], edx
add rax, 4
cmp rax, rcx
jnz short loc_1218
locret_122B:
retn
loc_122C:
xor ecx, ecx
xor edx, edx
jmp short loc_11D1 | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
int v7; // r9d
long long v8; // rdx
int v9; // edx
unsigned int v10; // ecx
long long v11; // rcx
result = a4;
if ( a4 > 0 )
{
if ( a4 == 1 || (unsigned long long)(a3 - (a1 + 4)) <= 8 || (unsigned long long)(a3 - (a2 + 4)) <= 8 )
{
v11 = 4LL * a4;
result = 0LL;
do
{
*(_DWORD *)(a3 + result) = *(_DWORD *)(a1 + result) + *(_DWORD *)(a2 + result);
result += 4LL;
}
while ( result != v11 );
}
else
{
v7 = a4;
if ( (unsigned int)(a4 - 1) <= 2 )
{
v10 = 0;
v9 = 0;
}
else
{
v8 = 0LL;
do
{
*(__m128i *)(a3 + v8) = _mm_add_epi32(
_mm_loadu_si128((const __m128i *)(a1 + v8)),
_mm_loadu_si128((const __m128i *)(a2 + v8)));
v8 += 16LL;
}
while ( 16LL * ((unsigned int)a4 >> 2) != v8 );
v9 = a4 & 0x7FFFFFFC;
v10 = a4 & 0xFFFFFFFC;
if ( (_DWORD)result == (result & 0xFFFFFFFC) )
return result;
v7 = result - v9;
if ( (_DWORD)result - v9 == 1 )
{
LABEL_12:
result = v9;
*(_DWORD *)(a3 + 4LL * v9) = *(_DWORD *)(a1 + 4LL * v9) + *(_DWORD *)(a2 + 4LL * v9);
return result;
}
}
result = v10;
*(_QWORD *)(a3 + 4LL * v10) = _mm_add_epi32(
_mm_loadl_epi64((const __m128i *)(a1 + 4LL * v10)),
_mm_loadl_epi64((const __m128i *)(a2 + 4LL * v10))).m128i_u64[0];
if ( (v7 & 1) != 0 )
{
v9 += v7 & 0xFFFFFFFE;
goto LABEL_12;
}
}
}
return result;
} | func0:
ENDBR64
MOVSXD RAX,ECX
MOV R8,RSI
MOV RSI,RDX
TEST EAX,EAX
JLE 0x0010122b
CMP EAX,0x1
JZ 0x00101208
LEA RCX,[RDI + 0x4]
SUB RDX,RCX
CMP RDX,0x8
JBE 0x00101208
LEA RCX,[R8 + 0x4]
MOV RDX,RSI
SUB RDX,RCX
CMP RDX,0x8
JBE 0x00101208
LEA EDX,[RAX + -0x1]
MOV R9D,EAX
CMP EDX,0x2
JBE 0x0010122c
MOV ECX,EAX
XOR EDX,EDX
SHR ECX,0x2
SHL RCX,0x4
NOP dword ptr [RAX]
LAB_001011a0:
MOVDQU XMM0,xmmword ptr [RDI + RDX*0x1]
MOVDQU XMM2,xmmword ptr [R8 + RDX*0x1]
PADDD XMM0,XMM2
MOVUPS xmmword ptr [RSI + RDX*0x1],XMM0
ADD RDX,0x10
CMP RCX,RDX
JNZ 0x001011a0
MOV EDX,EAX
AND EDX,0xfffffffc
MOV ECX,EDX
CMP EAX,EDX
JZ 0x0010122b
SUB EAX,EDX
MOV R9D,EAX
CMP EAX,0x1
JZ 0x001011f4
LAB_001011d1:
MOV EAX,ECX
MOVQ XMM0,qword ptr [RDI + RAX*0x4]
MOVQ XMM1,qword ptr [R8 + RAX*0x4]
PADDD XMM0,XMM1
MOVQ qword ptr [RSI + RAX*0x4],XMM0
TEST R9B,0x1
JZ 0x0010122b
AND R9D,0xfffffffe
ADD EDX,R9D
LAB_001011f4:
MOVSXD RAX,EDX
MOV EDX,dword ptr [R8 + RAX*0x4]
ADD EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RSI + RAX*0x4],EDX
RET
LAB_00101208:
LEA RCX,[RAX*0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101218:
MOV EDX,dword ptr [R8 + RAX*0x1]
ADD EDX,dword ptr [RDI + RAX*0x1]
MOV dword ptr [RSI + RAX*0x1],EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101218
LAB_0010122b:
RET
LAB_0010122c:
XOR ECX,ECX
XOR EDX,EDX
JMP 0x001011d1 | void func0(long param_1,long param_2,long param_3,uint param_4)
{
int *piVar1;
int *piVar2;
int *piVar3;
int8 uVar4;
int8 uVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
ulong uVar12;
uint uVar13;
long lVar14;
if (0 < (int)param_4) {
if (((param_4 == 1) || ((ulong)(param_3 - (param_1 + 4)) < 9)) ||
((ulong)(param_3 - (param_2 + 4)) < 9)) {
lVar14 = 0;
do {
*(int *)(param_3 + lVar14) = *(int *)(param_2 + lVar14) + *(int *)(param_1 + lVar14);
lVar14 = lVar14 + 4;
} while (lVar14 != (long)(int)param_4 * 4);
return;
}
if (param_4 - 1 < 3) {
uVar13 = 0;
}
else {
lVar14 = 0;
do {
piVar1 = (int *)(param_1 + lVar14);
iVar6 = piVar1[1];
iVar7 = piVar1[2];
iVar8 = piVar1[3];
piVar2 = (int *)(param_2 + lVar14);
iVar9 = piVar2[1];
iVar10 = piVar2[2];
iVar11 = piVar2[3];
piVar3 = (int *)(param_3 + lVar14);
*piVar3 = *piVar1 + *piVar2;
piVar3[1] = iVar6 + iVar9;
piVar3[2] = iVar7 + iVar10;
piVar3[3] = iVar8 + iVar11;
lVar14 = lVar14 + 0x10;
} while ((ulong)(param_4 >> 2) << 4 != lVar14);
uVar13 = param_4 & 0xfffffffc;
if (param_4 == uVar13) {
return;
}
param_4 = param_4 - uVar13;
if (param_4 == 1) goto LAB_001011f4;
}
uVar12 = (ulong)uVar13;
uVar4 = *(int8 *)(param_1 + uVar12 * 4);
uVar5 = *(int8 *)(param_2 + uVar12 * 4);
*(ulong *)(param_3 + uVar12 * 4) =
CONCAT44((int)((ulong)uVar4 >> 0x20) + (int)((ulong)uVar5 >> 0x20),(int)uVar4 + (int)uVar5)
;
if ((param_4 & 1) != 0) {
uVar13 = uVar13 + (param_4 & 0xfffffffe);
LAB_001011f4:
lVar14 = (long)(int)uVar13;
*(int *)(param_3 + lVar14 * 4) =
*(int *)(param_2 + lVar14 * 4) + *(int *)(param_1 + lVar14 * 4);
return;
}
}
return;
} |
6,808 | func0 |
#include <assert.h>
#include <stdlib.h>
| void func0(int nums1[], int nums2[], int result[], int size) {
for (int i = 0; i < size; i++) {
result[i] = nums1[i] + nums2[i];
}
}
| int main() {
int nums1_1[] = {1, 2, 3}, nums2_1[] = {4, 5, 6}, result_1[3], expected_1[] = {5, 7, 9};
int nums1_2[] = {1, 2}, nums2_2[] = {3, 4}, result_2[2], expected_2[] = {4, 6};
int nums1_3[] = {10, 20}, nums2_3[] = {50, 70}, result_3[2], expected_3[] = {60, 90};
func0(nums1_1, nums2_1, result_1, 3);
func0(nums1_2, nums2_2, result_2, 2);
func0(nums1_3, nums2_3, result_3, 2);
for (int i = 0; i < 3; i++) {
assert(result_1[i] == expected_1[i]);
}
for (int i = 0; i < 2; i++) {
assert(result_2[i] == expected_2[i]);
}
for (int i = 0; i < 2; i++) {
assert(result_3[i] == expected_3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x2c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d1 <func0+0x68>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rsi
mov -0x28(%rbp),%rax
add %rsi,%rax
add %ecx,%edx
mov %edx,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1189 <func0+0x20>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_4], 0
jmp short loc_11D1
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
lea rsi, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rsi
add edx, ecx
mov [rax], edx
add [rbp+var_4], 1
loc_11D1:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_2C]
jl short loc_1189
nop
nop
pop rbp
retn | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
unsigned int i; // [rsp+28h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a4 )
break;
*(_DWORD *)(4LL * (int)i + a3) = *(_DWORD *)(4LL * (int)i + a1) + *(_DWORD *)(4LL * (int)i + a2);
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d1
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV ECX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RSI,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RSI
ADD EDX,ECX
MOV dword ptr [RAX],EDX
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101189
NOP
NOP
POP RBP
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
*(int *)(param_3 + (long)local_c * 4) =
*(int *)(param_2 + (long)local_c * 4) + *(int *)(param_1 + (long)local_c * 4);
}
return;
} |
6,809 | func0 |
#include <assert.h>
#include <stdlib.h>
| void func0(int nums1[], int nums2[], int result[], int size) {
for (int i = 0; i < size; i++) {
result[i] = nums1[i] + nums2[i];
}
}
| int main() {
int nums1_1[] = {1, 2, 3}, nums2_1[] = {4, 5, 6}, result_1[3], expected_1[] = {5, 7, 9};
int nums1_2[] = {1, 2}, nums2_2[] = {3, 4}, result_2[2], expected_2[] = {4, 6};
int nums1_3[] = {10, 20}, nums2_3[] = {50, 70}, result_3[2], expected_3[] = {60, 90};
func0(nums1_1, nums2_1, result_1, 3);
func0(nums1_2, nums2_2, result_2, 2);
func0(nums1_3, nums2_3, result_3, 2);
for (int i = 0; i < 3; i++) {
assert(result_1[i] == expected_1[i]);
}
for (int i = 0; i < 2; i++) {
assert(result_2[i] == expected_2[i]);
}
for (int i = 0; i < 2; i++) {
assert(result_3[i] == expected_3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
test %ecx,%ecx
jle 118f <func0+0x26>
lea -0x1(%rcx),%r8d
mov $0x0,%eax
mov (%rsi,%rax,4),%ecx
add (%rdi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 117a <func0+0x11>
retq
| func0:
endbr64
test ecx, ecx
jle short locret_118D
mov ecx, ecx
mov eax, 0
loc_1178:
mov r8d, [rsi+rax*4]
add r8d, [rdi+rax*4]
mov [rdx+rax*4], r8d
add rax, 1
cmp rax, rcx
jnz short loc_1178
locret_118D:
retn | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i) + *(_DWORD *)(a2 + 4 * i);
}
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x0010118d
MOV ECX,ECX
MOV EAX,0x0
LAB_00101178:
MOV R8D,dword ptr [RSI + RAX*0x4]
ADD R8D,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RDX + RAX*0x4],R8D
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101178
LAB_0010118d:
RET | void func0(long param_1,long param_2,long param_3,uint param_4)
{
ulong uVar1;
if (0 < (int)param_4) {
uVar1 = 0;
do {
*(int *)(param_3 + uVar1 * 4) = *(int *)(param_2 + uVar1 * 4) + *(int *)(param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
}
return;
} |
6,810 | func0 |
#include <assert.h>
#include <stdlib.h>
| void func0(int nums1[], int nums2[], int result[], int size) {
for (int i = 0; i < size; i++) {
result[i] = nums1[i] + nums2[i];
}
}
| int main() {
int nums1_1[] = {1, 2, 3}, nums2_1[] = {4, 5, 6}, result_1[3], expected_1[] = {5, 7, 9};
int nums1_2[] = {1, 2}, nums2_2[] = {3, 4}, result_2[2], expected_2[] = {4, 6};
int nums1_3[] = {10, 20}, nums2_3[] = {50, 70}, result_3[2], expected_3[] = {60, 90};
func0(nums1_1, nums2_1, result_1, 3);
func0(nums1_2, nums2_2, result_2, 2);
func0(nums1_3, nums2_3, result_3, 2);
for (int i = 0; i < 3; i++) {
assert(result_1[i] == expected_1[i]);
}
for (int i = 0; i < 2; i++) {
assert(result_2[i] == expected_2[i]);
}
for (int i = 0; i < 2; i++) {
assert(result_3[i] == expected_3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
test %ecx,%ecx
jle 1165 <func0+0x25>
lea -0x1(%rcx),%r8d
xor %eax,%eax
xchg %ax,%ax
mov (%rsi,%rax,4),%ecx
add (%rdi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 1150 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test ecx, ecx
jle short locret_1165
movsxd rcx, ecx
xor eax, eax
nop dword ptr [rax]
loc_1150:
mov r8d, [rsi+rax*4]
add r8d, [rdi+rax*4]
mov [rdx+rax*4], r8d
add rax, 1
cmp rcx, rax
jnz short loc_1150
locret_1165:
retn | void func0(long long a1, long long a2, long long a3, int a4)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*(_DWORD *)(a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i) + *(_DWORD *)(a2 + 4 * i);
}
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101165
MOVSXD RCX,ECX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101150:
MOV R8D,dword ptr [RSI + RAX*0x4]
ADD R8D,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RDX + RAX*0x4],R8D
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x00101150
LAB_00101165:
RET | void func0(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(int *)(param_3 + lVar1 * 4) = *(int *)(param_2 + lVar1 * 4) + *(int *)(param_1 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_4 != lVar1);
}
return;
} |
6,811 | func0 |
#include <assert.h>
#include <stdlib.h>
| void func0(int nums1[], int nums2[], int result[], int size) {
for (int i = 0; i < size; i++) {
result[i] = nums1[i] + nums2[i];
}
}
| int main() {
int nums1_1[] = {1, 2, 3}, nums2_1[] = {4, 5, 6}, result_1[3], expected_1[] = {5, 7, 9};
int nums1_2[] = {1, 2}, nums2_2[] = {3, 4}, result_2[2], expected_2[] = {4, 6};
int nums1_3[] = {10, 20}, nums2_3[] = {50, 70}, result_3[2], expected_3[] = {60, 90};
func0(nums1_1, nums2_1, result_1, 3);
func0(nums1_2, nums2_2, result_2, 2);
func0(nums1_3, nums2_3, result_3, 2);
for (int i = 0; i < 3; i++) {
assert(result_1[i] == expected_1[i]);
}
for (int i = 0; i < 2; i++) {
assert(result_2[i] == expected_2[i]);
}
for (int i = 0; i < 2; i++) {
assert(result_3[i] == expected_3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
test %ecx,%ecx
jle 120d <func0+0xcd>
lea 0xf(%rdi),%r8
lea -0x1(%rcx),%eax
sub %rdx,%r8
cmp $0x1e,%r8
seta %r9b
cmp $0x2,%eax
seta %r8b
test %r8b,%r9b
je 11f0 <func0+0xb0>
lea 0xf(%rsi),%r8
sub %rdx,%r8
cmp $0x1e,%r8
jbe 11f0 <func0+0xb0>
mov %ecx,%r8d
xor %eax,%eax
shr $0x2,%r8d
shl $0x4,%r8
nopl 0x0(%rax,%rax,1)
movdqu (%rdi,%rax,1),%xmm0
movdqu (%rsi,%rax,1),%xmm1
paddd %xmm1,%xmm0
movups %xmm0,(%rdx,%rax,1)
add $0x10,%rax
cmp %r8,%rax
jne 1190 <func0+0x50>
mov %ecx,%eax
and $0xfffffffc,%eax
test $0x3,%cl
je 120d <func0+0xcd>
mov %eax,%r8d
mov (%rsi,%r8,4),%r9d
add (%rdi,%r8,4),%r9d
mov %r9d,(%rdx,%r8,4)
lea 0x1(%rax),%r8d
cmp %r8d,%ecx
jle 120d <func0+0xcd>
movslq %r8d,%r8
add $0x2,%eax
mov (%rsi,%r8,4),%r9d
add (%rdi,%r8,4),%r9d
mov %r9d,(%rdx,%r8,4)
cmp %eax,%ecx
jle 120d <func0+0xcd>
cltq
mov (%rsi,%rax,4),%ecx
add (%rdi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
retq
mov %eax,%r8d
xor %eax,%eax
nopl (%rax)
mov (%rsi,%rax,4),%ecx
add (%rdi,%rax,4),%ecx
mov %ecx,(%rdx,%rax,4)
mov %rax,%rcx
add $0x1,%rax
cmp %r8,%rcx
jne 11f8 <func0+0xb8>
retq
xchg %ax,%ax
| func0:
endbr64
movsxd rax, ecx
mov r8, rsi
mov rsi, rdx
test eax, eax
jle locret_122B
cmp eax, 1
jz loc_1208
lea rcx, [rdi+4]
sub rdx, rcx
cmp rdx, 8
jbe loc_1208
lea rcx, [r8+4]
mov rdx, rsi
sub rdx, rcx
cmp rdx, 8
jbe loc_1208
lea edx, [rax-1]
mov r9d, eax
cmp edx, 2
jbe loc_122C
mov ecx, eax
xor edx, edx
shr ecx, 2
shl rcx, 4
nop dword ptr [rax]
loc_11A0:
movdqu xmm0, xmmword ptr [rdi+rdx]
movdqu xmm2, xmmword ptr [r8+rdx]
paddd xmm0, xmm2
movups xmmword ptr [rsi+rdx], xmm0
add rdx, 10h
cmp rcx, rdx
jnz short loc_11A0
mov edx, eax
and edx, 0FFFFFFFCh
mov ecx, edx
cmp eax, edx
jz short locret_122B
sub eax, edx
mov r9d, eax
cmp eax, 1
jz short loc_11F4
loc_11D1:
mov eax, ecx
movq xmm0, qword ptr [rdi+rax*4]
movq xmm1, qword ptr [r8+rax*4]
paddd xmm0, xmm1
movq qword ptr [rsi+rax*4], xmm0
test r9b, 1
jz short locret_122B
and r9d, 0FFFFFFFEh
add edx, r9d
loc_11F4:
movsxd rax, edx
mov edx, [r8+rax*4]
add edx, [rdi+rax*4]
mov [rsi+rax*4], edx
retn
loc_1208:
lea rcx, ds:0[rax*4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1218:
mov edx, [r8+rax]
add edx, [rdi+rax]
mov [rsi+rax], edx
add rax, 4
cmp rax, rcx
jnz short loc_1218
locret_122B:
retn
loc_122C:
xor ecx, ecx
xor edx, edx
jmp short loc_11D1 | long long func0(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
int v7; // r9d
long long v8; // rdx
int v9; // edx
unsigned int v10; // ecx
long long v11; // rcx
result = a4;
if ( a4 > 0 )
{
if ( a4 == 1 || (unsigned long long)(a3 - (a1 + 4)) <= 8 || (unsigned long long)(a3 - (a2 + 4)) <= 8 )
{
v11 = 4LL * a4;
result = 0LL;
do
{
*(_DWORD *)(a3 + result) = *(_DWORD *)(a1 + result) + *(_DWORD *)(a2 + result);
result += 4LL;
}
while ( result != v11 );
}
else
{
v7 = a4;
if ( (unsigned int)(a4 - 1) <= 2 )
{
v10 = 0;
v9 = 0;
}
else
{
v8 = 0LL;
do
{
*(__m128i *)(a3 + v8) = _mm_add_epi32(
_mm_loadu_si128((const __m128i *)(a1 + v8)),
_mm_loadu_si128((const __m128i *)(a2 + v8)));
v8 += 16LL;
}
while ( 16LL * ((unsigned int)a4 >> 2) != v8 );
v9 = a4 & 0x7FFFFFFC;
v10 = a4 & 0xFFFFFFFC;
if ( (_DWORD)result == (result & 0xFFFFFFFC) )
return result;
v7 = result - v9;
if ( (_DWORD)result - v9 == 1 )
{
LABEL_12:
result = v9;
*(_DWORD *)(a3 + 4LL * v9) = *(_DWORD *)(a1 + 4LL * v9) + *(_DWORD *)(a2 + 4LL * v9);
return result;
}
}
result = v10;
*(_QWORD *)(a3 + 4LL * v10) = _mm_add_epi32(
_mm_loadl_epi64((const __m128i *)(a1 + 4LL * v10)),
_mm_loadl_epi64((const __m128i *)(a2 + 4LL * v10))).m128i_u64[0];
if ( (v7 & 1) != 0 )
{
v9 += v7 & 0xFFFFFFFE;
goto LABEL_12;
}
}
}
return result;
} | func0:
ENDBR64
MOVSXD RAX,ECX
MOV R8,RSI
MOV RSI,RDX
TEST EAX,EAX
JLE 0x0010122b
CMP EAX,0x1
JZ 0x00101208
LEA RCX,[RDI + 0x4]
SUB RDX,RCX
CMP RDX,0x8
JBE 0x00101208
LEA RCX,[R8 + 0x4]
MOV RDX,RSI
SUB RDX,RCX
CMP RDX,0x8
JBE 0x00101208
LEA EDX,[RAX + -0x1]
MOV R9D,EAX
CMP EDX,0x2
JBE 0x0010122c
MOV ECX,EAX
XOR EDX,EDX
SHR ECX,0x2
SHL RCX,0x4
NOP dword ptr [RAX]
LAB_001011a0:
MOVDQU XMM0,xmmword ptr [RDI + RDX*0x1]
MOVDQU XMM2,xmmword ptr [R8 + RDX*0x1]
PADDD XMM0,XMM2
MOVUPS xmmword ptr [RSI + RDX*0x1],XMM0
ADD RDX,0x10
CMP RCX,RDX
JNZ 0x001011a0
MOV EDX,EAX
AND EDX,0xfffffffc
MOV ECX,EDX
CMP EAX,EDX
JZ 0x0010122b
SUB EAX,EDX
MOV R9D,EAX
CMP EAX,0x1
JZ 0x001011f4
LAB_001011d1:
MOV EAX,ECX
MOVQ XMM0,qword ptr [RDI + RAX*0x4]
MOVQ XMM1,qword ptr [R8 + RAX*0x4]
PADDD XMM0,XMM1
MOVQ qword ptr [RSI + RAX*0x4],XMM0
TEST R9B,0x1
JZ 0x0010122b
AND R9D,0xfffffffe
ADD EDX,R9D
LAB_001011f4:
MOVSXD RAX,EDX
MOV EDX,dword ptr [R8 + RAX*0x4]
ADD EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RSI + RAX*0x4],EDX
RET
LAB_00101208:
LEA RCX,[RAX*0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101218:
MOV EDX,dword ptr [R8 + RAX*0x1]
ADD EDX,dword ptr [RDI + RAX*0x1]
MOV dword ptr [RSI + RAX*0x1],EDX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101218
LAB_0010122b:
RET
LAB_0010122c:
XOR ECX,ECX
XOR EDX,EDX
JMP 0x001011d1 | void func0(long param_1,long param_2,long param_3,uint param_4)
{
int *piVar1;
int *piVar2;
int *piVar3;
int8 uVar4;
int8 uVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
ulong uVar12;
uint uVar13;
long lVar14;
if (0 < (int)param_4) {
if (((param_4 == 1) || ((ulong)(param_3 - (param_1 + 4)) < 9)) ||
((ulong)(param_3 - (param_2 + 4)) < 9)) {
lVar14 = 0;
do {
*(int *)(param_3 + lVar14) = *(int *)(param_2 + lVar14) + *(int *)(param_1 + lVar14);
lVar14 = lVar14 + 4;
} while (lVar14 != (long)(int)param_4 * 4);
return;
}
if (param_4 - 1 < 3) {
uVar13 = 0;
}
else {
lVar14 = 0;
do {
piVar1 = (int *)(param_1 + lVar14);
iVar6 = piVar1[1];
iVar7 = piVar1[2];
iVar8 = piVar1[3];
piVar2 = (int *)(param_2 + lVar14);
iVar9 = piVar2[1];
iVar10 = piVar2[2];
iVar11 = piVar2[3];
piVar3 = (int *)(param_3 + lVar14);
*piVar3 = *piVar1 + *piVar2;
piVar3[1] = iVar6 + iVar9;
piVar3[2] = iVar7 + iVar10;
piVar3[3] = iVar8 + iVar11;
lVar14 = lVar14 + 0x10;
} while ((ulong)(param_4 >> 2) << 4 != lVar14);
uVar13 = param_4 & 0xfffffffc;
if (param_4 == uVar13) {
return;
}
param_4 = param_4 - uVar13;
if (param_4 == 1) goto LAB_001011f4;
}
uVar12 = (ulong)uVar13;
uVar4 = *(int8 *)(param_1 + uVar12 * 4);
uVar5 = *(int8 *)(param_2 + uVar12 * 4);
*(ulong *)(param_3 + uVar12 * 4) =
CONCAT44((int)((ulong)uVar4 >> 0x20) + (int)((ulong)uVar5 >> 0x20),(int)uVar4 + (int)uVar5)
;
if ((param_4 & 1) != 0) {
uVar13 = uVar13 + (param_4 & 0xfffffffe);
LAB_001011f4:
lVar14 = (long)(int)uVar13;
*(int *)(param_3 + lVar14 * 4) =
*(int *)(param_2 + lVar14 * 4) + *(int *)(param_1 + lVar14 * 4);
return;
}
}
return;
} |
6,812 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int length, int *out_length) {
int *result = malloc(sizeof(int) * length);
int current_key = nums[0];
result[0] = current_key;
int j = 1;
for (int i = 1; i < length; i++) {
if (nums[i] != current_key) {
current_key = nums[i];
result[j++] = current_key;
}
}
*out_length = j;
return result;
}
| int main() {
int a1[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
int len1;
int *result1 = func0(a1, 16, &len1);
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4};
for (int i = 0; i < len1; i++) {
assert(result1[i] == expected1[i]);
}
int a2[] = {10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10};
int len2;
int *result2 = func0(a2, 12, &len2);
int expected2[] = {10, 15, 19, 18, 17, 26, 17, 18, 10};
for (int i = 0; i < len2; i++) {
assert(result2[i] == expected2[i]);
}
int a3[] = {'a', 'a', 'b', 'c', 'd', 'd'};
int len3;
int *result3 = func0(a3, 6, &len3);
int expected3[] = {'a', 'b', 'c', 'd'};
for (int i = 0; i < len3; i++) {
assert(result3[i] == expected3[i]);
}
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x14(%rbp)
mov -0x8(%rbp),%rax
mov -0x14(%rbp),%edx
mov %edx,(%rax)
movl $0x1,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 126e <func0+0xa5>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x14(%rbp)
je 126a <func0+0xa1>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x14(%rbp)
mov -0x10(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x10(%rbp)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0x14(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1217 <func0+0x4e>
mov -0x38(%rbp),%rax
mov -0x10(%rbp),%edx
mov %edx,(%rax)
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_14], eax
mov rax, [rbp+var_8]
mov edx, [rbp+var_14]
mov [rax], edx
mov [rbp+var_10], 1
mov [rbp+var_C], 1
jmp short loc_126E
loc_1217:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_14], eax
jz short loc_126A
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_14], eax
mov eax, [rbp+var_10]
lea edx, [rax+1]
mov [rbp+var_10], edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_14]
mov [rdx], eax
loc_126A:
add [rbp+var_C], 1
loc_126E:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_2C]
jl short loc_1217
mov rax, [rbp+var_38]
mov edx, [rbp+var_10]
mov [rax], edx
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(int *a1, int a2, int *a3)
{
int v3; // eax
int v6; // [rsp+2Ch] [rbp-14h]
int v7; // [rsp+30h] [rbp-10h]
int i; // [rsp+34h] [rbp-Ch]
_DWORD *v9; // [rsp+38h] [rbp-8h]
v9 = malloc(4LL * a2);
v6 = *a1;
*v9 = *a1;
v7 = 1;
for ( i = 1; i < a2; ++i )
{
if ( v6 != a1[i] )
{
v6 = a1[i];
v3 = v7++;
v9[v3] = v6;
}
}
*a3 = v7;
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0x14]
MOV dword ptr [RAX],EDX
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0xc],0x1
JMP 0x0010126e
LAB_00101217:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x14],EAX
JZ 0x0010126a
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x10]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x10],EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RDX],EAX
LAB_0010126a:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010126e:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101217
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x10]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | int * func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int local_1c;
int local_18;
int local_14;
piVar1 = (int *)malloc((long)param_2 << 2);
local_1c = *param_1;
*piVar1 = local_1c;
local_18 = 1;
for (local_14 = 1; local_14 < param_2; local_14 = local_14 + 1) {
if (local_1c != param_1[local_14]) {
local_1c = param_1[local_14];
piVar1[local_18] = local_1c;
local_18 = local_18 + 1;
}
}
*param_3 = local_18;
return piVar1;
} |
6,813 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int length, int *out_length) {
int *result = malloc(sizeof(int) * length);
int current_key = nums[0];
result[0] = current_key;
int j = 1;
for (int i = 1; i < length; i++) {
if (nums[i] != current_key) {
current_key = nums[i];
result[j++] = current_key;
}
}
*out_length = j;
return result;
}
| int main() {
int a1[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
int len1;
int *result1 = func0(a1, 16, &len1);
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4};
for (int i = 0; i < len1; i++) {
assert(result1[i] == expected1[i]);
}
int a2[] = {10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10};
int len2;
int *result2 = func0(a2, 12, &len2);
int expected2[] = {10, 15, 19, 18, 17, 26, 17, 18, 10};
for (int i = 0; i < len2; i++) {
assert(result2[i] == expected2[i]);
}
int a3[] = {'a', 'a', 'b', 'c', 'd', 'd'};
int len3;
int *result3 = func0(a3, 6, &len3);
int expected3[] = {'a', 'b', 'c', 'd'};
for (int i = 0; i < len3; i++) {
assert(result3[i] == expected3[i]);
}
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %esi,%ebp
mov %rdx,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov (%r12),%ecx
mov %ecx,(%rax)
cmp $0x1,%ebp
jle 1220 <func0+0x57>
lea 0x4(%r12),%rdx
lea -0x2(%rbp),%esi
lea 0x8(%r12,%rsi,4),%r8
mov $0x1,%esi
jmp 1216 <func0+0x4d>
movslq %esi,%rdi
mov %ecx,(%rax,%rdi,4)
lea 0x1(%rsi),%esi
add $0x4,%rdx
cmp %r8,%rdx
je 1225 <func0+0x5c>
mov %ecx,%edi
mov (%rdx),%ecx
cmp %edi,%ecx
jne 1204 <func0+0x3b>
jmp 120d <func0+0x44>
mov $0x1,%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, 2
call _malloc
mov ecx, [r12]
mov [rax], ecx
cmp ebp, 1
jle short loc_1220
lea rdx, [r12+4]
lea esi, [rbp-2]
lea r8, [r12+rsi*4+8]
mov esi, 1
jmp short loc_120D
loc_1204:
add rdx, 4
cmp rdx, r8
jz short loc_1225
loc_120D:
mov edi, ecx
mov ecx, [rdx]
cmp ecx, edi
jz short loc_1204
movsxd rdi, esi
mov [rax+rdi*4], ecx
lea esi, [rsi+1]
jmp short loc_1204
loc_1220:
mov esi, 1
loc_1225:
mov [rbx], esi
pop rbx
pop rbp
pop r12
retn | int * func0(int *a1, int a2, int *a3)
{
int *result; // rax
int v7; // ecx
int *v8; // rdx
int v9; // esi
int v10; // edi
result = (int *)malloc(4LL * a2);
v7 = *a1;
*result = *a1;
if ( a2 <= 1 )
{
v9 = 1;
}
else
{
v8 = a1 + 1;
v9 = 1;
do
{
v10 = v7;
v7 = *v8;
if ( *v8 != v10 )
result[v9++] = v7;
++v8;
}
while ( v8 != &a1[a2 - 2 + 2] );
}
*a3 = v9;
return result;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV EBP,ESI
MOV RBX,RDX
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010d0
MOV ECX,dword ptr [R12]
MOV dword ptr [RAX],ECX
CMP EBP,0x1
JLE 0x00101220
LEA RDX,[R12 + 0x4]
LEA ESI,[RBP + -0x2]
LEA R8,[R12 + RSI*0x4 + 0x8]
MOV ESI,0x1
JMP 0x0010120d
LAB_00101204:
ADD RDX,0x4
CMP RDX,R8
JZ 0x00101225
LAB_0010120d:
MOV EDI,ECX
MOV ECX,dword ptr [RDX]
CMP ECX,EDI
JZ 0x00101204
MOVSXD RDI,ESI
MOV dword ptr [RAX + RDI*0x4],ECX
LEA ESI,[RSI + 0x1]
JMP 0x00101204
LAB_00101220:
MOV ESI,0x1
LAB_00101225:
MOV dword ptr [RBX],ESI
POP RBX
POP RBP
POP R12
RET | void func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
int *piVar2;
int iVar3;
int *piVar4;
int iVar5;
piVar2 = (int *)malloc((long)param_2 << 2);
iVar3 = *param_1;
*piVar2 = iVar3;
if (param_2 < 2) {
iVar5 = 1;
}
else {
piVar4 = param_1 + 1;
iVar5 = 1;
do {
iVar1 = *piVar4;
if (iVar1 != iVar3) {
piVar2[iVar5] = iVar1;
iVar5 = iVar5 + 1;
}
piVar4 = piVar4 + 1;
iVar3 = iVar1;
} while (piVar4 != param_1 + (ulong)(param_2 - 2) + 2);
}
*param_3 = iVar5;
return;
} |
6,814 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int length, int *out_length) {
int *result = malloc(sizeof(int) * length);
int current_key = nums[0];
result[0] = current_key;
int j = 1;
for (int i = 1; i < length; i++) {
if (nums[i] != current_key) {
current_key = nums[i];
result[j++] = current_key;
}
}
*out_length = j;
return result;
}
| int main() {
int a1[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
int len1;
int *result1 = func0(a1, 16, &len1);
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4};
for (int i = 0; i < len1; i++) {
assert(result1[i] == expected1[i]);
}
int a2[] = {10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10};
int len2;
int *result2 = func0(a2, 12, &len2);
int expected2[] = {10, 15, 19, 18, 17, 26, 17, 18, 10};
for (int i = 0; i < len2; i++) {
assert(result2[i] == expected2[i]);
}
int a3[] = {'a', 'a', 'b', 'c', 'd', 'd'};
int len3;
int *result3 = func0(a3, 6, &len3);
int expected3[] = {'a', 'b', 'c', 'd'};
for (int i = 0; i < len3; i++) {
assert(result3[i] == expected3[i]);
}
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov 0x0(%rbp),%edi
mov %edi,(%rax)
cmp $0x1,%ebx
jle 1580 <func0+0x70>
lea -0x2(%rbx),%edx
lea 0x4(%rbp),%rcx
mov $0x1,%esi
lea 0x8(%rbp,%rdx,4),%r9
nopl 0x0(%rax,%rax,1)
mov %edi,%r8d
mov (%rcx),%edi
cmp %r8d,%edi
je 1564 <func0+0x54>
movslq %esi,%r8
add $0x1,%esi
mov %edi,(%rax,%r8,4)
add $0x4,%rcx
cmp %r9,%rcx
jne 1550 <func0+0x40>
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0x1,%esi
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
xchg %ax,%ax
| func0:
endbr64
push r12
mov r12, rdx
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
mov rbx, rdi
shl rdi, 2
call _malloc
mov ecx, [rbp+0]
mov [rax], ecx
cmp ebx, 1
jle short loc_1578
lea esi, [rbx-2]
lea rdx, [rbp+4]
lea r8, [rbp+rsi*4+8]
mov esi, 1
nop dword ptr [rax+rax+00000000h]
loc_1550:
mov edi, ecx
mov ecx, [rdx]
cmp ecx, edi
jz short loc_1561
movsxd rdi, esi
add esi, 1
mov [rax+rdi*4], ecx
loc_1561:
add rdx, 4
cmp rdx, r8
jnz short loc_1550
pop rbx
pop rbp
mov [r12], esi
pop r12
retn
loc_1578:
mov esi, 1
pop rbx
pop rbp
mov [r12], esi
pop r12
retn | int * func0(int *a1, int a2, int *a3)
{
int *result; // rax
int v7; // ecx
int *v8; // rdx
int v9; // esi
int v10; // edi
long long v11; // rdi
result = (int *)malloc(4LL * a2);
v7 = *a1;
*result = *a1;
if ( a2 <= 1 )
{
*a3 = 1;
}
else
{
v8 = a1 + 1;
v9 = 1;
do
{
v10 = v7;
v7 = *v8;
if ( *v8 != v10 )
{
v11 = v9++;
result[v11] = v7;
}
++v8;
}
while ( v8 != &a1[a2 - 2 + 2] );
*a3 = v9;
}
return result;
} | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
CALL 0x001010d0
MOV ECX,dword ptr [RBP]
MOV dword ptr [RAX],ECX
CMP EBX,0x1
JLE 0x00101578
LEA ESI,[RBX + -0x2]
LEA RDX,[RBP + 0x4]
LEA R8,[RBP + RSI*0x4 + 0x8]
MOV ESI,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101550:
MOV EDI,ECX
MOV ECX,dword ptr [RDX]
CMP ECX,EDI
JZ 0x00101561
MOVSXD RDI,ESI
ADD ESI,0x1
MOV dword ptr [RAX + RDI*0x4],ECX
LAB_00101561:
ADD RDX,0x4
CMP RDX,R8
JNZ 0x00101550
POP RBX
POP RBP
MOV dword ptr [R12],ESI
POP R12
RET
LAB_00101578:
MOV ESI,0x1
POP RBX
POP RBP
MOV dword ptr [R12],ESI
POP R12
RET | void func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
int *piVar2;
int iVar3;
int *piVar4;
int iVar5;
long lVar6;
piVar2 = (int *)malloc((long)param_2 << 2);
iVar3 = *param_1;
*piVar2 = iVar3;
if (1 < param_2) {
piVar4 = param_1 + 1;
iVar5 = 1;
do {
iVar1 = *piVar4;
if (iVar1 != iVar3) {
lVar6 = (long)iVar5;
iVar5 = iVar5 + 1;
piVar2[lVar6] = iVar1;
}
piVar4 = piVar4 + 1;
iVar3 = iVar1;
} while (piVar4 != param_1 + (ulong)(param_2 - 2) + 2);
*param_3 = iVar5;
return;
}
*param_3 = 1;
return;
} |
6,815 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int nums[], int length, int *out_length) {
int *result = malloc(sizeof(int) * length);
int current_key = nums[0];
result[0] = current_key;
int j = 1;
for (int i = 1; i < length; i++) {
if (nums[i] != current_key) {
current_key = nums[i];
result[j++] = current_key;
}
}
*out_length = j;
return result;
}
| int main() {
int a1[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
int len1;
int *result1 = func0(a1, 16, &len1);
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4};
for (int i = 0; i < len1; i++) {
assert(result1[i] == expected1[i]);
}
int a2[] = {10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10};
int len2;
int *result2 = func0(a2, 12, &len2);
int expected2[] = {10, 15, 19, 18, 17, 26, 17, 18, 10};
for (int i = 0; i < len2; i++) {
assert(result2[i] == expected2[i]);
}
int a3[] = {'a', 'a', 'b', 'c', 'd', 'd'};
int len3;
int *result3 = func0(a3, 6, &len3);
int expected3[] = {'a', 'b', 'c', 'd'};
for (int i = 0; i < len3; i++) {
assert(result3[i] == expected3[i]);
}
free(result1);
free(result2);
free(result3);
printf("All tests passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov 0x0(%rbp),%edi
mov %edi,(%rax)
cmp $0x1,%ebx
jle 1610 <func0+0x70>
lea -0x2(%rbx),%edx
lea 0x4(%rbp),%rcx
mov $0x1,%esi
lea 0x8(%rbp,%rdx,4),%r9
nopl 0x0(%rax,%rax,1)
mov %edi,%r8d
mov (%rcx),%edi
cmp %r8d,%edi
je 15f4 <func0+0x54>
movslq %esi,%r8
add $0x1,%esi
mov %edi,(%rax,%r8,4)
add $0x4,%rcx
cmp %r9,%rcx
jne 15e0 <func0+0x40>
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0x1,%esi
pop %rbx
pop %rbp
mov %esi,(%r12)
pop %r12
retq
xchg %ax,%ax
| func0:
endbr64
push r12
mov r12, rdx
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
mov rbx, rdi
shl rdi, 2; size
call _malloc
mov ecx, [rbp+0]
mov [rax], ecx
cmp ebx, 1
jle short loc_1548
lea esi, [rbx-2]
lea rdx, [rbp+4]
lea r8, [rbp+rsi*4+8]
mov esi, 1
nop dword ptr [rax+rax+00000000h]
loc_1520:
mov edi, ecx
mov ecx, [rdx]
cmp ecx, edi
jz short loc_1531
movsxd rdi, esi
add esi, 1
mov [rax+rdi*4], ecx
loc_1531:
add rdx, 4
cmp rdx, r8
jnz short loc_1520
mov [r12], esi
pop rbx
pop rbp
pop r12
retn
loc_1548:
mov esi, 1
mov [r12], esi
pop rbx
pop rbp
pop r12
retn | _DWORD * func0(int *a1, int a2, int *a3)
{
_DWORD *result; // rax
int v7; // ecx
int *v8; // rdx
int v9; // esi
int v10; // edi
long long v11; // rdi
result = malloc(4LL * a2);
v7 = *a1;
*result = *a1;
if ( a2 <= 1 )
{
*a3 = 1;
}
else
{
v8 = a1 + 1;
v9 = 1;
do
{
v10 = v7;
v7 = *v8;
if ( *v8 != v10 )
{
v11 = v9++;
result[v11] = v7;
}
++v8;
}
while ( v8 != &a1[a2 - 2 + 2] );
*a3 = v9;
}
return result;
} | func0:
ENDBR64
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
CALL 0x001010d0
MOV ECX,dword ptr [RBP]
MOV dword ptr [RAX],ECX
CMP EBX,0x1
JLE 0x00101548
LEA ESI,[RBX + -0x2]
LEA RDX,[RBP + 0x4]
LEA R8,[RBP + RSI*0x4 + 0x8]
MOV ESI,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101520:
MOV EDI,ECX
MOV ECX,dword ptr [RDX]
CMP ECX,EDI
JZ 0x00101531
MOVSXD RDI,ESI
ADD ESI,0x1
MOV dword ptr [RAX + RDI*0x4],ECX
LAB_00101531:
ADD RDX,0x4
CMP RDX,R8
JNZ 0x00101520
MOV dword ptr [R12],ESI
POP RBX
POP RBP
POP R12
RET
LAB_00101548:
MOV ESI,0x1
MOV dword ptr [R12],ESI
POP RBX
POP RBP
POP R12
RET | void func0(int *param_1,int param_2,int *param_3)
{
int iVar1;
int *piVar2;
int iVar3;
int *piVar4;
int iVar5;
long lVar6;
piVar2 = (int *)malloc((long)param_2 << 2);
iVar3 = *param_1;
*piVar2 = iVar3;
if (1 < param_2) {
piVar4 = param_1 + 1;
iVar5 = 1;
do {
iVar1 = *piVar4;
if (iVar1 != iVar3) {
lVar6 = (long)iVar5;
iVar5 = iVar5 + 1;
piVar2[lVar6] = iVar1;
}
piVar4 = piVar4 + 1;
iVar3 = iVar1;
} while (piVar4 != param_1 + (ulong)(param_2 - 2) + 2);
*param_3 = iVar5;
return;
}
*param_3 = 1;
return;
} |
6,816 | func0 | #include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double LSA = M_PI * r * l;
return LSA;
}
| int main() {
assert(func0(5, 12) == 204.20352248333654);
assert(func0(10, 15) == 566.3586699569488);
assert(func0(19, 17) == 1521.8090132193388);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd -0x18(%rbp),%xmm0
movapd %xmm0,%xmm1
mulsd %xmm0,%xmm1
movsd -0x20(%rbp),%xmm0
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
callq 1070 <sqrt@plt>
movq %xmm0,%rax
mov %rax,-0x10(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf14(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd -0x10(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
movsd [rbp+var_18], xmm0
movsd [rbp+var_20], xmm1
movsd xmm0, [rbp+var_18]
movapd xmm1, xmm0
mulsd xmm1, xmm0
movsd xmm0, [rbp+var_20]
mulsd xmm0, xmm0
addsd xmm1, xmm0
movq rax, xmm1
movq xmm0, rax; x
call _sqrt
movq rax, xmm0
mov [rbp+var_10], rax
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_20A8
mulsd xmm0, xmm1
movsd xmm1, [rbp+var_10]
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
leave
retn | double func0(double a1, double a2)
{
return 3.141592653589793 * a1 * sqrt(a1 * a1 + a2 * a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD XMM0,qword ptr [RBP + -0x18]
MOVAPD XMM1,XMM0
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0x20]
MULSD XMM0,XMM0
ADDSD XMM1,XMM0
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101070
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x10],RAX
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x001020a8]
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [RBP + -0x10]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
LEAVE
RET | double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = sqrt(param_1 * param_1 + param_2 * param_2);
return DAT_001020a8 * param_1 * dVar1;
} |
6,817 | func0 | #include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double LSA = M_PI * r * l;
return LSA;
}
| int main() {
assert(func0(5, 12) == 204.20352248333654);
assert(func0(10, 15) == 566.3586699569488);
assert(func0(19, 17) == 1521.8090132193388);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x18,%rsp
movsd %xmm0,0x8(%rsp)
mulsd %xmm0,%xmm0
mulsd %xmm1,%xmm1
addsd %xmm1,%xmm0
movapd %xmm0,%xmm3
sqrtsd %xmm3,%xmm3
movsd %xmm3,(%rsp)
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja 1192 <func0+0x49>
movsd 0x8(%rsp),%xmm0
mulsd 0xe80(%rip),%xmm0
mulsd (%rsp),%xmm0
add $0x18,%rsp
retq
callq 1050 <sqrt@plt>
jmp 117a <func0+0x31>
| func0:
endbr64
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
mulsd xmm0, xmm0
mulsd xmm1, xmm1
addsd xmm1, xmm0
pxor xmm0, xmm0
ucomisd xmm0, xmm1
ja short loc_118C
sqrtsd xmm1, xmm1
loc_1171:
movsd xmm2, [rsp+18h+var_10]
mulsd xmm2, cs:qword_2008
mulsd xmm2, xmm1
movapd xmm0, xmm2
add rsp, 18h
retn
loc_118C:
movapd xmm0, xmm1
call _sqrt
movapd xmm1, xmm0
jmp short loc_1171 | __int128 __usercall func0@<xmm0>(double a1@<xmm0>, double a2@<xmm1>)
{
double v2; // xmm1_8
double v3; // xmm1_8
__int128 v4; // xmm2
v2 = a2 * a2 + a1 * a1;
if ( v2 < 0.0 )
v3 = sqrt(v2);
else
v3 = sqrt(v2);
v4 = *(unsigned long long *)&a1;
*(double *)&v4 = a1 * 3.141592653589793 * v3;
return v4;
} | func0:
ENDBR64
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
MULSD XMM0,XMM0
MULSD XMM1,XMM1
ADDSD XMM1,XMM0
PXOR XMM0,XMM0
UCOMISD XMM0,XMM1
JA 0x0010118c
SQRTSD XMM1,XMM1
LAB_00101171:
MOVSD XMM2,qword ptr [RSP + 0x8]
MULSD XMM2,qword ptr [0x00102008]
MULSD XMM2,XMM1
MOVAPD XMM0,XMM2
ADD RSP,0x18
RET
LAB_0010118c:
MOVAPD XMM0,XMM1
CALL 0x00101050
MOVAPD XMM1,XMM0
JMP 0x00101171 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = param_2 * param_2 + param_1 * param_1;
if (dVar1 < 0.0) {
dVar1 = sqrt(dVar1);
}
else {
dVar1 = SQRT(dVar1);
}
return param_1 * _DAT_00102008 * dVar1;
} |
6,818 | func0 | #include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double LSA = M_PI * r * l;
return LSA;
}
| int main() {
assert(func0(5, 12) == 204.20352248333654);
assert(func0(10, 15) == 566.3586699569488);
assert(func0(19, 17) == 1521.8090132193388);
return 0;
}
| O2 | c | func0:
endbr64
mulsd %xmm1,%xmm1
movapd %xmm0,%xmm2
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm3
sqrtsd %xmm3,%xmm3
ja 1197 <func0+0x37>
mulsd 0xe7a(%rip),%xmm2
movapd %xmm2,%xmm0
mulsd %xmm3,%xmm0
retq
sub $0x18,%rsp
movsd %xmm2,0x8(%rsp)
movsd %xmm3,(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm2
movsd (%rsp),%xmm3
mulsd 0xe4a(%rip),%xmm2
add $0x18,%rsp
movapd %xmm2,%xmm0
mulsd %xmm3,%xmm0
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mulsd xmm1, xmm1
movapd xmm2, xmm0
mulsd xmm0, xmm0
addsd xmm1, xmm0
pxor xmm0, xmm0
ucomisd xmm0, xmm1
ja short loc_1193
mulsd xmm2, cs:qword_2008
sqrtsd xmm1, xmm1
mulsd xmm2, xmm1
movapd xmm0, xmm2
retn
loc_1193:
sub rsp, 18h
movapd xmm0, xmm1
movsd [rsp+18h+var_10], xmm2
call _sqrt
movsd xmm2, [rsp+18h+var_10]
mulsd xmm2, cs:qword_2008
add rsp, 18h
mulsd xmm2, xmm0
movapd xmm0, xmm2
retn | __int128 __usercall func0@<xmm0>(__m128 a1@<xmm0>, double a2@<xmm1>)
{
__int128 v2; // xmm2
double v3; // xmm1_8
*((_QWORD *)&v2 + 1) = a1.m128_u64[1];
v3 = a2 * a2 + *(double *)a1.m128_u64 * *(double *)a1.m128_u64;
if ( v3 < 0.0 )
{
v2 = a1.m128_u64[0];
*(double *)&v2 = *(double *)a1.m128_u64 * 3.141592653589793 * sqrt(v3);
}
else
{
*(double *)&v2 = *(double *)a1.m128_u64 * 3.141592653589793 * sqrt(v3);
}
return v2;
} | func0:
ENDBR64
MULSD XMM1,XMM1
MOVAPD XMM2,XMM0
MULSD XMM0,XMM0
ADDSD XMM1,XMM0
PXOR XMM0,XMM0
UCOMISD XMM0,XMM1
JA 0x00101193
MULSD XMM2,qword ptr [0x00102008]
SQRTSD XMM1,XMM1
MULSD XMM2,XMM1
MOVAPD XMM0,XMM2
RET
LAB_00101193:
SUB RSP,0x18
MOVAPD XMM0,XMM1
MOVSD qword ptr [RSP + 0x8],XMM2
CALL 0x00101050
MOVSD XMM2,qword ptr [RSP + 0x8]
MULSD XMM2,qword ptr [0x00102008]
ADD RSP,0x18
MULSD XMM2,XMM0
MOVAPD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = param_2 * param_2 + param_1 * param_1;
if (0.0 <= dVar1) {
return param_1 * _DAT_00102008 * SQRT(dVar1);
}
dVar1 = sqrt(dVar1);
return param_1 * _DAT_00102008 * dVar1;
} |
6,819 | func0 | #include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double LSA = M_PI * r * l;
return LSA;
}
| int main() {
assert(func0(5, 12) == 204.20352248333654);
assert(func0(10, 15) == 566.3586699569488);
assert(func0(19, 17) == 1521.8090132193388);
return 0;
}
| O3 | c | func0:
endbr64
mulsd %xmm1,%xmm1
movapd %xmm0,%xmm2
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm3
sqrtsd %xmm3,%xmm3
ja 1197 <func0+0x37>
mulsd 0xe7a(%rip),%xmm2
movapd %xmm2,%xmm0
mulsd %xmm3,%xmm0
retq
sub $0x18,%rsp
movsd %xmm2,0x8(%rsp)
movsd %xmm3,(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm2
movsd (%rsp),%xmm3
mulsd 0xe4a(%rip),%xmm2
add $0x18,%rsp
movapd %xmm2,%xmm0
mulsd %xmm3,%xmm0
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mulsd xmm1, xmm1
movapd xmm2, xmm0
mulsd xmm2, xmm0
mulsd xmm0, cs:qword_2008
addsd xmm2, xmm1
sqrtsd xmm2, xmm2
mulsd xmm0, xmm2
retn | double func0(double a1, double a2)
{
return a1 * 3.141592653589793 * sqrt(a1 * a1 + a2 * a2);
} | func0:
ENDBR64
MULSD XMM1,XMM1
MOVAPD XMM2,XMM0
MULSD XMM2,XMM0
MULSD XMM0,qword ptr [0x00102008]
ADDSD XMM2,XMM1
SQRTSD XMM2,XMM2
MULSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
return param_1 * _DAT_00102008 * SQRT(param_1 * param_1 + param_2 * param_2);
} |
6,820 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *text){
for(int i = 0; text[i] != '\0'; i++) {
if(text[i] == ' ' || text[i] == ',' || text[i] == '.') {
text[i] = ':';
}
}
return text;
}
| int main() {
char text1[] = "Python language, Programming language.";
char text2[] = "a b c,d e f";
char text3[] = "ram reshma,ram rahim";
assert(strcmp(func0(text1), "Python:language::Programming:language:") == 0);
assert(strcmp(func0(text2), "a:b:c:d:e:f") == 0);
assert(strcmp(func0(text3), "ram:reshma:ram:rahim") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ee <func0+0x65>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 11da <func0+0x51>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2c,%al
je 11da <func0+0x51>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2e,%al
jne 11ea <func0+0x61>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movb $0x3a,(%rax)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 119e <func0+0x15>
mov -0x18(%rbp),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_4], 0
jmp short loc_11EE
loc_119E:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jz short loc_11DA
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Ch ; ','
jz short loc_11DA
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Eh ; '.'
jnz short loc_11EA
loc_11DA:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
mov byte ptr [rax], 3Ah ; ':'
loc_11EA:
add [rbp+var_4], 1
loc_11EE:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_119E
mov rax, [rbp+var_18]
pop rbp
retn | long long func0(long long a1)
{
int i; // [rsp+14h] [rbp-4h]
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( *(_BYTE *)(i + a1) == 32 || *(_BYTE *)(i + a1) == 44 || *(_BYTE *)(i + a1) == 46 )
*(_BYTE *)(i + a1) = 58;
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ee
LAB_0010119e:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JZ 0x001011da
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2c
JZ 0x001011da
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2e
JNZ 0x001011ea
LAB_001011da:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV byte ptr [RAX],0x3a
LAB_001011ea:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011ee:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x0010119e
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET | long func0(long param_1)
{
int4 local_c;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
if (((*(char *)(param_1 + local_c) == ' ') || (*(char *)(param_1 + local_c) == ',')) ||
(*(char *)(param_1 + local_c) == '.')) {
*(int *)(param_1 + local_c) = 0x3a;
}
}
return param_1;
} |
6,821 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *text){
for(int i = 0; text[i] != '\0'; i++) {
if(text[i] == ' ' || text[i] == ',' || text[i] == '.') {
text[i] = ':';
}
}
return text;
}
| int main() {
char text1[] = "Python language, Programming language.";
char text2[] = "a b c,d e f";
char text3[] = "ram reshma,ram rahim";
assert(strcmp(func0(text1), "Python:language::Programming:language:") == 0);
assert(strcmp(func0(text2), "a:b:c:d:e:f") == 0);
assert(strcmp(func0(text3), "ram:reshma:ram:rahim") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rax
movzbl (%rdi),%edx
test %dl,%dl
je 119c <func0+0x33>
mov %rdi,%rcx
jmp 118a <func0+0x21>
movb $0x3a,(%rcx)
add $0x1,%rcx
movzbl (%rcx),%edx
test %dl,%dl
je 119c <func0+0x33>
mov %edx,%esi
and $0xfffffffd,%esi
cmp $0x2c,%sil
je 117c <func0+0x13>
cmp $0x20,%dl
je 117c <func0+0x13>
jmp 117f <func0+0x16>
retq
| func0:
endbr64
mov rax, rdi
movzx edx, byte ptr [rdi]
test dl, dl
jz short locret_11C1
mov rcx, rdi
mov rsi, 500100000000h
jmp short loc_11B4
loc_11A6:
mov byte ptr [rcx], 3Ah ; ':'
loc_11A9:
add rcx, 1
movzx edx, byte ptr [rcx]
test dl, dl
jz short locret_11C1
loc_11B4:
cmp dl, 2Eh ; '.'
ja short loc_11A9
bt rsi, rdx
jnb short loc_11A9
jmp short loc_11A6
locret_11C1:
retn | unsigned __int8 * func0(unsigned __int8 *a1)
{
unsigned __int8 *result; // rax
unsigned long long v2; // rdx
_BYTE *v3; // rcx
long long v4; // rsi
result = a1;
v2 = *a1;
if ( (_BYTE)v2 )
{
v3 = a1;
v4 = 0x500100000000LL;
do
{
if ( (unsigned __int8)v2 <= 0x2Eu )
{
if ( _bittest64(&v4, v2) )
*v3 = 58;
}
v2 = (unsigned __int8)*++v3;
}
while ( (_BYTE)v2 );
}
return result;
} | func0:
ENDBR64
MOV RAX,RDI
MOVZX EDX,byte ptr [RDI]
TEST DL,DL
JZ 0x001011c1
MOV RCX,RDI
MOV RSI,0x500100000000
JMP 0x001011b4
LAB_001011a6:
MOV byte ptr [RCX],0x3a
LAB_001011a9:
ADD RCX,0x1
MOVZX EDX,byte ptr [RCX]
TEST DL,DL
JZ 0x001011c1
LAB_001011b4:
CMP DL,0x2e
JA 0x001011a9
BT RSI,RDX
JNC 0x001011a9
JMP 0x001011a6
LAB_001011c1:
RET | byte * func0(byte *param_1)
{
byte bVar1;
byte *pbVar2;
pbVar2 = param_1;
bVar1 = *param_1;
while (bVar1 != 0) {
if ((bVar1 < 0x2f) && ((0x500100000000U >> ((ulong)bVar1 & 0x3f) & 1) != 0)) {
*param_1 = 0x3a;
}
param_1 = param_1 + 1;
bVar1 = *param_1;
}
return pbVar2;
} |
6,822 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *text){
for(int i = 0; text[i] != '\0'; i++) {
if(text[i] == ' ' || text[i] == ',' || text[i] == '.') {
text[i] = ':';
}
}
return text;
}
| int main() {
char text1[] = "Python language, Programming language.";
char text2[] = "a b c,d e f";
char text3[] = "ram reshma,ram rahim";
assert(strcmp(func0(text1), "Python:language::Programming:language:") == 0);
assert(strcmp(func0(text2), "a:b:c:d:e:f") == 0);
assert(strcmp(func0(text3), "ram:reshma:ram:rahim") == 0);
return 0;
}
| O2 | c | func0:
endbr64
movzbl (%rdi),%edx
mov %rdi,%rax
test %dl,%dl
je 1387 <func0+0x37>
mov %rdi,%rcx
nopl 0x0(%rax)
mov %edx,%esi
and $0xfffffffd,%esi
cmp $0x2c,%sil
je 1378 <func0+0x28>
cmp $0x20,%dl
jne 137b <func0+0x2b>
movb $0x3a,(%rcx)
movzbl 0x1(%rcx),%edx
add $0x1,%rcx
test %dl,%dl
jne 1368 <func0+0x18>
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movzx edx, byte ptr [rdi]
mov rax, rdi
test dl, dl
jz short locret_131A
mov rsi, 500100000000h
mov rcx, rdi
nop dword ptr [rax+rax+00h]
loc_1300:
cmp dl, 2Eh ; '.'
ja short loc_130E
bt rsi, rdx
jnb short loc_130E
mov byte ptr [rcx], 3Ah ; ':'
loc_130E:
movzx edx, byte ptr [rcx+1]
add rcx, 1
test dl, dl
jnz short loc_1300
locret_131A:
retn | unsigned __int8 * func0(unsigned __int8 *a1)
{
unsigned long long v1; // rdx
unsigned __int8 *result; // rax
long long v3; // rsi
_BYTE *v4; // rcx
v1 = *a1;
result = a1;
if ( (_BYTE)v1 )
{
v3 = 0x500100000000LL;
v4 = a1;
do
{
if ( (unsigned __int8)v1 <= 0x2Eu )
{
if ( _bittest64(&v3, v1) )
*v4 = 58;
}
v1 = (unsigned __int8)*++v4;
}
while ( (_BYTE)v1 );
}
return result;
} | func0:
ENDBR64
MOVZX EDX,byte ptr [RDI]
MOV RAX,RDI
TEST DL,DL
JZ 0x0010131a
MOV RSI,0x500100000000
MOV RCX,RDI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101300:
CMP DL,0x2e
JA 0x0010130e
BT RSI,RDX
JNC 0x0010130e
MOV byte ptr [RCX],0x3a
LAB_0010130e:
MOVZX EDX,byte ptr [RCX + 0x1]
ADD RCX,0x1
TEST DL,DL
JNZ 0x00101300
LAB_0010131a:
RET | byte * func0(byte *param_1)
{
byte *pbVar1;
byte bVar2;
byte *pbVar3;
pbVar3 = param_1;
bVar2 = *param_1;
while (bVar2 != 0) {
if ((bVar2 < 0x2f) && ((0x500100000000U >> ((ulong)bVar2 & 0x3f) & 1) != 0)) {
*param_1 = 0x3a;
}
pbVar1 = param_1 + 1;
param_1 = param_1 + 1;
bVar2 = *pbVar1;
}
return pbVar3;
} |
6,823 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char *func0(char *text){
for(int i = 0; text[i] != '\0'; i++) {
if(text[i] == ' ' || text[i] == ',' || text[i] == '.') {
text[i] = ':';
}
}
return text;
}
| int main() {
char text1[] = "Python language, Programming language.";
char text2[] = "a b c,d e f";
char text3[] = "ram reshma,ram rahim";
assert(strcmp(func0(text1), "Python:language::Programming:language:") == 0);
assert(strcmp(func0(text2), "a:b:c:d:e:f") == 0);
assert(strcmp(func0(text3), "ram:reshma:ram:rahim") == 0);
return 0;
}
| O3 | c | func0:
endbr64
movzbl (%rdi),%edx
mov %rdi,%rax
test %dl,%dl
je 13e4 <func0+0x34>
mov %rdi,%rcx
nopl 0x0(%rax)
mov %edx,%esi
and $0xfffffffd,%esi
cmp $0x2c,%sil
je 13e8 <func0+0x38>
cmp $0x20,%dl
je 13e8 <func0+0x38>
movzbl 0x1(%rcx),%edx
add $0x1,%rcx
test %dl,%dl
jne 13c8 <func0+0x18>
retq
nopl (%rax)
movb $0x3a,(%rcx)
movzbl 0x1(%rcx),%edx
add $0x1,%rcx
test %dl,%dl
jne 13c8 <func0+0x18>
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movzx edx, byte ptr [rdi]
mov rax, rdi
test dl, dl
jz short locret_139A
mov rsi, 500100000000h
mov rcx, rdi
nop dword ptr [rax+rax+00h]
loc_1380:
cmp dl, 2Eh ; '.'
ja short loc_138E
bt rsi, rdx
jnb short loc_138E
mov byte ptr [rcx], 3Ah ; ':'
loc_138E:
movzx edx, byte ptr [rcx+1]
add rcx, 1
test dl, dl
jnz short loc_1380
locret_139A:
retn | unsigned __int8 * func0(unsigned __int8 *a1)
{
unsigned long long v1; // rdx
unsigned __int8 *result; // rax
long long v3; // rsi
_BYTE *v4; // rcx
v1 = *a1;
result = a1;
if ( (_BYTE)v1 )
{
v3 = 0x500100000000LL;
v4 = a1;
do
{
if ( (unsigned __int8)v1 <= 0x2Eu )
{
if ( _bittest64(&v3, v1) )
*v4 = 58;
}
v1 = (unsigned __int8)*++v4;
}
while ( (_BYTE)v1 );
}
return result;
} | func0:
ENDBR64
MOVZX EDX,byte ptr [RDI]
MOV RAX,RDI
TEST DL,DL
JZ 0x0010139a
MOV RSI,0x500100000000
MOV RCX,RDI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101380:
CMP DL,0x2e
JA 0x0010138e
BT RSI,RDX
JNC 0x0010138e
MOV byte ptr [RCX],0x3a
LAB_0010138e:
MOVZX EDX,byte ptr [RCX + 0x1]
ADD RCX,0x1
TEST DL,DL
JNZ 0x00101380
LAB_0010139a:
RET | byte * func0(byte *param_1)
{
byte *pbVar1;
byte bVar2;
byte *pbVar3;
pbVar3 = param_1;
bVar2 = *param_1;
while (bVar2 != 0) {
if ((bVar2 < 0x2f) && ((0x500100000000U >> ((ulong)bVar2 & 0x3f) & 1) != 0)) {
*param_1 = 0x3a;
}
pbVar1 = param_1 + 1;
param_1 = param_1 + 1;
bVar2 = *pbVar1;
}
return pbVar3;
} |
6,824 | func0 | #include <assert.h>
| int func0(int A[], int n, int x) {
int left = 0, right = n - 1;
int result = -1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (x == A[mid]) {
result = mid;
right = mid - 1;
} else if (x < A[mid]) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return result;
}
| int main() {
int arr1[] = {2, 5, 5, 5, 6, 6, 8, 9, 9, 9};
int arr2[] = {2, 3, 5, 5, 6, 6, 8, 9, 9, 9};
int arr3[] = {2, 4, 1, 5, 6, 6, 8, 9, 9, 9};
assert(func0(arr1, 10, 5) == 1);
assert(func0(arr2, 10, 5) == 2);
assert(func0(arr3, 10, 6) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x10(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
movl $0xffffffff,-0x8(%rbp)
jmp 1208 <func0+0x9f>
mov -0xc(%rbp),%eax
sub -0x10(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%edx
mov -0x10(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jne 11d9 <func0+0x70>
mov -0x4(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0x4(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
jmp 1208 <func0+0x9f>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jge 11ff <func0+0x96>
mov -0x4(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
jmp 1208 <func0+0x9f>
mov -0x4(%rbp),%eax
add $0x1,%eax
mov %eax,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0xc(%rbp),%eax
jle 1194 <func0+0x2b>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_10], 0
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_C], eax
mov [rbp+var_8], 0FFFFFFFFh
jmp short loc_1208
loc_1194:
mov eax, [rbp+var_C]
sub eax, [rbp+var_10]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov edx, eax
mov eax, [rbp+var_10]
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_20], eax
jnz short loc_11D9
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
mov eax, [rbp+var_4]
sub eax, 1
mov [rbp+var_C], eax
jmp short loc_1208
loc_11D9:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_20], eax
jge short loc_11FF
mov eax, [rbp+var_4]
sub eax, 1
mov [rbp+var_C], eax
jmp short loc_1208
loc_11FF:
mov eax, [rbp+var_4]
add eax, 1
mov [rbp+var_10], eax
loc_1208:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_C]
jle short loc_1194
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
int v4; // [rsp+10h] [rbp-10h]
int v5; // [rsp+14h] [rbp-Ch]
unsigned int v6; // [rsp+18h] [rbp-8h]
int v7; // [rsp+1Ch] [rbp-4h]
v4 = 0;
v5 = a2 - 1;
v6 = -1;
while ( v4 <= v5 )
{
v7 = (v5 - v4) / 2 + v4;
if ( a3 == *(_DWORD *)(4LL * v7 + a1) )
{
v6 = (v5 - v4) / 2 + v4;
v5 = v7 - 1;
}
else if ( a3 >= *(_DWORD *)(4LL * v7 + a1) )
{
v4 = v7 + 1;
}
else
{
v5 = v7 - 1;
}
}
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x10],0x0
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0xffffffff
JMP 0x00101208
LAB_00101194:
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x10]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x20],EAX
JNZ 0x001011d9
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00101208
LAB_001011d9:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x20],EAX
JGE 0x001011ff
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00101208
LAB_001011ff:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
LAB_00101208:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0xc]
JLE 0x00101194
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int4 local_18;
int4 local_14;
int4 local_10;
local_18 = 0;
local_14 = param_2 + -1;
local_10 = -1;
while (local_18 <= local_14) {
iVar1 = local_18 + (local_14 - local_18) / 2;
if (param_3 == *(int *)(param_1 + (long)iVar1 * 4)) {
local_14 = iVar1 + -1;
local_10 = iVar1;
}
else if (param_3 < *(int *)(param_1 + (long)iVar1 * 4)) {
local_14 = iVar1 + -1;
}
else {
local_18 = iVar1 + 1;
}
}
return local_10;
} |
6,825 | func0 | #include <assert.h>
| int func0(int A[], int n, int x) {
int left = 0, right = n - 1;
int result = -1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (x == A[mid]) {
result = mid;
right = mid - 1;
} else if (x < A[mid]) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return result;
}
| int main() {
int arr1[] = {2, 5, 5, 5, 6, 6, 8, 9, 9, 9};
int arr2[] = {2, 3, 5, 5, 6, 6, 8, 9, 9, 9};
int arr3[] = {2, 4, 1, 5, 6, 6, 8, 9, 9, 9};
assert(func0(arr1, 10, 5) == 1);
assert(func0(arr2, 10, 5) == 2);
assert(func0(arr3, 10, 6) == 4);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1,%esi
js 11b4 <func0+0x4b>
mov $0xffffffff,%r9d
mov $0x0,%ecx
jmp 1189 <func0+0x20>
lea -0x1(%rax),%esi
mov %eax,%r9d
cmp %esi,%ecx
jg 11ba <func0+0x51>
mov %esi,%r8d
sub %ecx,%r8d
mov %r8d,%eax
shr $0x1f,%eax
add %r8d,%eax
sar %eax
add %ecx,%eax
movslq %eax,%r8
mov (%rdi,%r8,4),%r8d
cmp %edx,%r8d
je 117f <func0+0x16>
jle 11af <func0+0x46>
lea -0x1(%rax),%esi
jmp 1185 <func0+0x1c>
lea 0x1(%rax),%ecx
jmp 1185 <func0+0x1c>
mov $0xffffffff,%r9d
mov %r9d,%eax
retq
| func0:
endbr64
mov r8, rdi
sub esi, 1
js short loc_11B2
mov r9d, 0FFFFFFFFh
mov ecx, 0
jmp short loc_118C
loc_1182:
lea esi, [rax-1]
mov r9d, eax
loc_1188:
cmp ecx, esi
jg short loc_11B8
loc_118C:
mov edi, esi
sub edi, ecx
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
add eax, ecx
movsxd rdi, eax
mov edi, [r8+rdi*4]
cmp edi, edx
jz short loc_1182
jle short loc_11AD
lea esi, [rax-1]
jmp short loc_1188
loc_11AD:
lea ecx, [rax+1]
jmp short loc_1188
loc_11B2:
mov r9d, 0FFFFFFFFh
loc_11B8:
mov eax, r9d
retn | long long func0(long long a1, int a2, int a3)
{
int v4; // esi
unsigned int v5; // r9d
int v6; // ecx
signed int v7; // eax
int v8; // edi
v4 = a2 - 1;
if ( v4 < 0 )
{
return (unsigned int)-1;
}
else
{
v5 = -1;
v6 = 0;
do
{
v7 = v6 + (v4 - v6) / 2;
v8 = *(_DWORD *)(a1 + 4LL * v7);
if ( v8 == a3 )
{
v4 = v7 - 1;
v5 = v7;
}
else if ( v8 <= a3 )
{
v6 = v7 + 1;
}
else
{
v4 = v7 - 1;
}
}
while ( v6 <= v4 );
}
return v5;
} | func0:
ENDBR64
MOV R8,RDI
SUB ESI,0x1
JS 0x001011b2
MOV R9D,0xffffffff
MOV ECX,0x0
JMP 0x0010118c
LAB_00101182:
LEA ESI,[RAX + -0x1]
MOV R9D,EAX
LAB_00101188:
CMP ECX,ESI
JG 0x001011b8
LAB_0010118c:
MOV EDI,ESI
SUB EDI,ECX
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
ADD EAX,ECX
MOVSXD RDI,EAX
MOV EDI,dword ptr [R8 + RDI*0x4]
CMP EDI,EDX
JZ 0x00101182
JLE 0x001011ad
LEA ESI,[RAX + -0x1]
JMP 0x00101188
LAB_001011ad:
LEA ECX,[RAX + 0x1]
JMP 0x00101188
LAB_001011b2:
MOV R9D,0xffffffff
LAB_001011b8:
MOV EAX,R9D
RET | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
param_2 = param_2 + -1;
if (param_2 < 0) {
iVar2 = -1;
}
else {
iVar3 = 0;
iVar4 = -1;
do {
iVar2 = (param_2 - iVar3) / 2 + iVar3;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (iVar1 == param_3) {
param_2 = iVar2 + -1;
}
else if (param_3 < iVar1) {
param_2 = iVar2 + -1;
iVar2 = iVar4;
}
else {
iVar3 = iVar2 + 1;
iVar2 = iVar4;
}
iVar4 = iVar2;
} while (iVar3 <= param_2);
}
return iVar2;
} |
6,826 | func0 | #include <assert.h>
| int func0(int A[], int n, int x) {
int left = 0, right = n - 1;
int result = -1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (x == A[mid]) {
result = mid;
right = mid - 1;
} else if (x < A[mid]) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return result;
}
| int main() {
int arr1[] = {2, 5, 5, 5, 6, 6, 8, 9, 9, 9};
int arr2[] = {2, 3, 5, 5, 6, 6, 8, 9, 9, 9};
int arr3[] = {2, 4, 1, 5, 6, 6, 8, 9, 9, 9};
assert(func0(arr1, 10, 5) == 1);
assert(func0(arr2, 10, 5) == 2);
assert(func0(arr3, 10, 6) == 4);
return 0;
}
| O2 | c | func0:
endbr64
mov $0xffffffff,%r9d
sub $0x1,%esi
js 13dc <func0+0x3c>
xor %ecx,%ecx
jmp 13c1 <func0+0x21>
nopl 0x0(%rax,%rax,1)
jle 13e0 <func0+0x40>
lea -0x1(%rax),%esi
cmp %ecx,%esi
jl 13dc <func0+0x3c>
mov %esi,%eax
sub %ecx,%eax
sar %eax
add %ecx,%eax
movslq %eax,%r8
cmp %edx,(%rdi,%r8,4)
jne 13b8 <func0+0x18>
lea -0x1(%rax),%esi
mov %eax,%r9d
cmp %ecx,%esi
jge 13c1 <func0+0x21>
mov %r9d,%eax
retq
lea 0x1(%rax),%ecx
jmp 13bd <func0+0x1d>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov r9d, 0FFFFFFFFh
sub esi, 1
js short loc_133C
xor ecx, ecx
jmp short loc_1321
loc_1318:
jle short loc_1340
lea esi, [rax-1]
loc_131D:
cmp esi, ecx
jl short loc_133C
loc_1321:
mov eax, esi
sub eax, ecx
sar eax, 1
add eax, ecx
movsxd r8, eax
cmp [rdi+r8*4], edx
jnz short loc_1318
lea esi, [rax-1]
mov r9d, eax
cmp esi, ecx
jge short loc_1321
loc_133C:
mov eax, r9d
retn
loc_1340:
lea ecx, [rax+1]
jmp short loc_131D | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r9d
int v4; // esi
int v5; // ecx
signed int v6; // eax
v3 = -1;
v4 = a2 - 1;
if ( v4 >= 0 )
{
v5 = 0;
do
{
while ( 1 )
{
v6 = v5 + ((v4 - v5) >> 1);
if ( *(_DWORD *)(a1 + 4LL * v6) != a3 )
break;
v4 = v6 - 1;
v3 = v6;
if ( v6 - 1 < v5 )
return v3;
}
if ( *(_DWORD *)(a1 + 4LL * v6) <= a3 )
v5 = v6 + 1;
else
v4 = v6 - 1;
}
while ( v4 >= v5 );
}
return v3;
} | func0:
ENDBR64
MOV R9D,0xffffffff
SUB ESI,0x1
JS 0x0010133c
XOR ECX,ECX
JMP 0x00101321
LAB_00101318:
JLE 0x00101340
LEA ESI,[RAX + -0x1]
LAB_0010131d:
CMP ESI,ECX
JL 0x0010133c
LAB_00101321:
MOV EAX,ESI
SUB EAX,ECX
SAR EAX,0x1
ADD EAX,ECX
MOVSXD R8,EAX
CMP dword ptr [RDI + R8*0x4],EDX
JNZ 0x00101318
LEA ESI,[RAX + -0x1]
MOV R9D,EAX
CMP ESI,ECX
JGE 0x00101321
LAB_0010133c:
MOV EAX,R9D
RET
LAB_00101340:
LEA ECX,[RAX + 0x1]
JMP 0x0010131d | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = -1;
param_2 = param_2 + -1;
if (-1 < param_2) {
iVar3 = 0;
do {
while( true ) {
iVar2 = (param_2 - iVar3 >> 1) + iVar3;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (iVar1 != param_3) break;
param_2 = iVar2 + -1;
iVar4 = iVar2;
if (param_2 < iVar3) {
return iVar2;
}
}
if (param_3 < iVar1) {
param_2 = iVar2 + -1;
}
else {
iVar3 = iVar2 + 1;
}
} while (iVar3 <= param_2);
}
return iVar4;
} |
6,827 | func0 | #include <assert.h>
| int func0(int A[], int n, int x) {
int left = 0, right = n - 1;
int result = -1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (x == A[mid]) {
result = mid;
right = mid - 1;
} else if (x < A[mid]) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return result;
}
| int main() {
int arr1[] = {2, 5, 5, 5, 6, 6, 8, 9, 9, 9};
int arr2[] = {2, 3, 5, 5, 6, 6, 8, 9, 9, 9};
int arr3[] = {2, 4, 1, 5, 6, 6, 8, 9, 9, 9};
assert(func0(arr1, 10, 5) == 1);
assert(func0(arr2, 10, 5) == 2);
assert(func0(arr3, 10, 6) == 4);
return 0;
}
| O3 | c | func0:
endbr64
mov $0xffffffff,%r9d
sub $0x1,%esi
js 139c <func0+0x3c>
xor %ecx,%ecx
jmp 1381 <func0+0x21>
nopl 0x0(%rax,%rax,1)
jge 13a0 <func0+0x40>
lea -0x1(%rax),%esi
cmp %esi,%ecx
jg 139c <func0+0x3c>
mov %esi,%eax
sub %ecx,%eax
sar %eax
add %ecx,%eax
movslq %eax,%r8
cmp (%rdi,%r8,4),%edx
jne 1378 <func0+0x18>
lea -0x1(%rax),%esi
mov %eax,%r9d
cmp %esi,%ecx
jle 1381 <func0+0x21>
mov %r9d,%eax
retq
lea 0x1(%rax),%ecx
jmp 137d <func0+0x1d>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov r9d, 0FFFFFFFFh
sub esi, 1
js short loc_139C
xor ecx, ecx
jmp short loc_1381
loc_1378:
jge short loc_13A0
lea esi, [rax-1]
loc_137D:
cmp ecx, esi
jg short loc_139C
loc_1381:
mov eax, esi
sub eax, ecx
sar eax, 1
add eax, ecx
movsxd r8, eax
cmp edx, [rdi+r8*4]
jnz short loc_1378
lea esi, [rax-1]
mov r9d, eax
cmp ecx, esi
jle short loc_1381
loc_139C:
mov eax, r9d
retn
loc_13A0:
lea ecx, [rax+1]
jmp short loc_137D | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r9d
int v4; // esi
int v5; // ecx
signed int v6; // eax
v3 = -1;
v4 = a2 - 1;
if ( v4 >= 0 )
{
v5 = 0;
do
{
while ( 1 )
{
v6 = v5 + ((v4 - v5) >> 1);
if ( a3 != *(_DWORD *)(a1 + 4LL * v6) )
break;
v4 = v6 - 1;
v3 = v6;
if ( v5 > v6 - 1 )
return v3;
}
if ( a3 >= *(_DWORD *)(a1 + 4LL * v6) )
v5 = v6 + 1;
else
v4 = v6 - 1;
}
while ( v5 <= v4 );
}
return v3;
} | func0:
ENDBR64
MOV R9D,0xffffffff
SUB ESI,0x1
JS 0x0010139c
XOR ECX,ECX
JMP 0x00101381
LAB_00101378:
JGE 0x001013a0
LEA ESI,[RAX + -0x1]
LAB_0010137d:
CMP ECX,ESI
JG 0x0010139c
LAB_00101381:
MOV EAX,ESI
SUB EAX,ECX
SAR EAX,0x1
ADD EAX,ECX
MOVSXD R8,EAX
CMP EDX,dword ptr [RDI + R8*0x4]
JNZ 0x00101378
LEA ESI,[RAX + -0x1]
MOV R9D,EAX
CMP ECX,ESI
JLE 0x00101381
LAB_0010139c:
MOV EAX,R9D
RET
LAB_001013a0:
LEA ECX,[RAX + 0x1]
JMP 0x0010137d | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = -1;
param_2 = param_2 + -1;
if (-1 < param_2) {
iVar3 = 0;
do {
while( true ) {
iVar2 = (param_2 - iVar3 >> 1) + iVar3;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (param_3 != iVar1) break;
param_2 = iVar2 + -1;
iVar4 = iVar2;
if (param_2 < iVar3) {
return iVar2;
}
}
if (param_3 < iVar1) {
param_2 = iVar2 + -1;
}
else {
iVar3 = iVar2 + 1;
}
} while (iVar3 <= param_2);
}
return iVar4;
} |
6,828 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int ans = 0, res = 0;
int i = n - 1;
while (i >= 0) {
int incr = arr[i] * (1 + res);
ans += incr;
res = incr;
i--;
}
return ans;
}
| int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {1, 2};
int arr3[] = {1, 2, 3, 4};
assert(func0(arr1, 3) == 20);
assert(func0(arr2, 2) == 5);
assert(func0(arr3, 4) == 84);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x8(%rbp)
jmp 11c3 <func0+0x5a>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0xc(%rbp),%edx
add $0x1,%edx
imul %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
add %eax,-0x10(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0xc(%rbp)
subl $0x1,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jns 1191 <func0+0x28>
mov -0x10(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_8], eax
jmp short loc_11C3
loc_1191:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_C]
add edx, 1
imul eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
add [rbp+var_10], eax
mov eax, [rbp+var_4]
mov [rbp+var_C], eax
sub [rbp+var_8], 1
loc_11C3:
cmp [rbp+var_8], 0
jns short loc_1191
mov eax, [rbp+var_10]
pop rbp
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+Ch] [rbp-10h]
int v4; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
v3 = 0;
v4 = 0;
for ( i = a2 - 1; i >= 0; --i )
{
v3 += (v4 + 1) * *(_DWORD *)(4LL * i + a1);
v4 = (v4 + 1) * *(_DWORD *)(4LL * i + a1);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011c3
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0xc]
ADD EDX,0x1
IMUL EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0xc],EAX
SUB dword ptr [RBP + -0x8],0x1
LAB_001011c3:
CMP dword ptr [RBP + -0x8],0x0
JNS 0x00101191
MOV EAX,dword ptr [RBP + -0x10]
POP RBP
RET | int func0(long param_1,int param_2)
{
int4 local_18;
int4 local_14;
int4 local_10;
local_18 = 0;
local_14 = 0;
for (local_10 = param_2 + -1; -1 < local_10; local_10 = local_10 + -1) {
local_14 = *(int *)(param_1 + (long)local_10 * 4) * (local_14 + 1);
local_18 = local_18 + local_14;
}
return local_18;
} |
6,829 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int ans = 0, res = 0;
int i = n - 1;
while (i >= 0) {
int incr = arr[i] * (1 + res);
ans += incr;
res = incr;
i--;
}
return ans;
}
| int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {1, 2};
int arr3[] = {1, 2, 3, 4};
assert(func0(arr1, 3) == 20);
assert(func0(arr2, 2) == 5);
assert(func0(arr3, 4) == 84);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1,%esi
js 1193 <func0+0x2a>
movslq %esi,%rsi
mov $0x0,%eax
mov $0x0,%edx
add $0x1,%eax
imul (%rdi,%rsi,4),%eax
add %eax,%edx
sub $0x1,%rsi
test %esi,%esi
jns 117f <func0+0x16>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1190 <func0+0x27>
| func0:
endbr64
sub esi, 1
js short loc_1193
movsxd rsi, esi
mov eax, 0
mov edx, 0
loc_117F:
add eax, 1
imul eax, [rdi+rsi*4]
add edx, eax
sub rsi, 1
test esi, esi
jns short loc_117F
loc_1190:
mov eax, edx
retn
loc_1193:
mov edx, 0
jmp short loc_1190 | long long func0(long long a1, int a2)
{
long long v2; // rsi
int v3; // eax
unsigned int v4; // edx
LODWORD(v2) = a2 - 1;
if ( (int)v2 < 0 )
{
return 0;
}
else
{
v2 = (int)v2;
v3 = 0;
v4 = 0;
do
{
v3 = *(_DWORD *)(a1 + 4 * v2) * (v3 + 1);
v4 += v3;
--v2;
}
while ( (int)v2 >= 0 );
}
return v4;
} | func0:
ENDBR64
SUB ESI,0x1
JS 0x00101193
MOVSXD RSI,ESI
MOV EAX,0x0
MOV EDX,0x0
LAB_0010117f:
ADD EAX,0x1
IMUL EAX,dword ptr [RDI + RSI*0x4]
ADD EDX,EAX
SUB RSI,0x1
TEST ESI,ESI
JNS 0x0010117f
LAB_00101190:
MOV EAX,EDX
RET
LAB_00101193:
MOV EDX,0x0
JMP 0x00101190 | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
if (param_2 + -1 < 0) {
iVar2 = 0;
}
else {
lVar3 = (long)(param_2 + -1);
iVar1 = 0;
iVar2 = 0;
do {
iVar1 = (iVar1 + 1) * *(int *)(param_1 + lVar3 * 4);
iVar2 = iVar2 + iVar1;
lVar3 = lVar3 + -1;
} while (-1 < (int)lVar3);
}
return iVar2;
} |
6,830 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int ans = 0, res = 0;
int i = n - 1;
while (i >= 0) {
int incr = arr[i] * (1 + res);
ans += incr;
res = incr;
i--;
}
return ans;
}
| int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {1, 2};
int arr3[] = {1, 2, 3, 4};
assert(func0(arr1, 3) == 20);
assert(func0(arr2, 2) == 5);
assert(func0(arr3, 4) == 84);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x1,%esi
js 1170 <func0+0x30>
movslq %esi,%rsi
xor %eax,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
add $0x1,%eax
imul (%rdi,%rsi,4),%eax
sub $0x1,%rsi
add %eax,%r8d
test %esi,%esi
jns 1158 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
sub esi, 1
js short loc_1240
movsxd rsi, esi
xor eax, eax
xor r8d, r8d
nop dword ptr [rax+00000000h]
loc_1228:
add eax, 1
imul eax, [rdi+rsi*4]
sub rsi, 1
add r8d, eax
test esi, esi
jns short loc_1228
mov eax, r8d
retn
loc_1240:
xor r8d, r8d
mov eax, r8d
retn | long long func0(long long a1, int a2)
{
long long v2; // rsi
int v3; // eax
unsigned int v4; // r8d
LODWORD(v2) = a2 - 1;
if ( (int)v2 < 0 )
return 0LL;
v2 = (int)v2;
v3 = 0;
v4 = 0;
do
{
v3 = *(_DWORD *)(a1 + 4 * v2--) * (v3 + 1);
v4 += v3;
}
while ( (int)v2 >= 0 );
return v4;
} | func0:
ENDBR64
SUB ESI,0x1
JS 0x00101240
MOVSXD RSI,ESI
XOR EAX,EAX
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101228:
ADD EAX,0x1
IMUL EAX,dword ptr [RDI + RSI*0x4]
SUB RSI,0x1
ADD R8D,EAX
TEST ESI,ESI
JNS 0x00101228
MOV EAX,R8D
RET
LAB_00101240:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,int param_2)
{
int iVar1;
long lVar2;
int iVar3;
if (-1 < param_2 + -1) {
lVar2 = (long)(param_2 + -1);
iVar1 = 0;
iVar3 = 0;
do {
iVar1 = (iVar1 + 1) * *(int *)(param_1 + lVar2 * 4);
lVar2 = lVar2 + -1;
iVar3 = iVar3 + iVar1;
} while (-1 < (int)lVar2);
return iVar3;
}
return 0;
} |
6,831 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int ans = 0, res = 0;
int i = n - 1;
while (i >= 0) {
int incr = arr[i] * (1 + res);
ans += incr;
res = incr;
i--;
}
return ans;
}
| int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {1, 2};
int arr3[] = {1, 2, 3, 4};
assert(func0(arr1, 3) == 20);
assert(func0(arr2, 2) == 5);
assert(func0(arr3, 4) == 84);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x1,%esi
js 1170 <func0+0x30>
movslq %esi,%rsi
xor %eax,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
add $0x1,%eax
imul (%rdi,%rsi,4),%eax
sub $0x1,%rsi
add %eax,%r8d
test %esi,%esi
jns 1158 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
sub esi, 1
js short loc_1168
movsxd rsi, esi
xor eax, eax
xor edx, edx
loc_1150:
add eax, 1
imul eax, [rdi+rsi*4]
sub rsi, 1
add edx, eax
test esi, esi
jns short loc_1150
mov eax, edx
retn
loc_1168:
xor edx, edx
mov eax, edx
retn | long long func0(long long a1, int a2)
{
long long v2; // rsi
int v3; // eax
unsigned int v4; // edx
LODWORD(v2) = a2 - 1;
if ( (int)v2 < 0 )
return 0LL;
v2 = (int)v2;
v3 = 0;
v4 = 0;
do
{
v3 = *(_DWORD *)(a1 + 4 * v2--) * (v3 + 1);
v4 += v3;
}
while ( (int)v2 >= 0 );
return v4;
} | func0:
ENDBR64
SUB ESI,0x1
JS 0x00101168
MOVSXD RSI,ESI
XOR EAX,EAX
XOR EDX,EDX
LAB_00101150:
ADD EAX,0x1
IMUL EAX,dword ptr [RDI + RSI*0x4]
SUB RSI,0x1
ADD EDX,EAX
TEST ESI,ESI
JNS 0x00101150
MOV EAX,EDX
RET
LAB_00101168:
XOR EDX,EDX
MOV EAX,EDX
RET | int func0(long param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
if (-1 < param_2 + -1) {
lVar3 = (long)(param_2 + -1);
iVar1 = 0;
iVar2 = 0;
do {
iVar1 = (iVar1 + 1) * *(int *)(param_1 + lVar3 * 4);
lVar3 = lVar3 + -1;
iVar2 = iVar2 + iVar1;
} while (-1 < (int)lVar3);
return iVar2;
}
return 0;
} |
6,832 | func0 |
#include <assert.h>
int set_middle_bits(int n) {
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return (n >> 1) ^ 1;
}
| int func0(int n) {
if (n == 1) {
return 1;
}
return n ^ set_middle_bits(n);
}
| int main() {
assert(func0(9) == 15);
assert(func0(10) == 12);
assert(func0(11) == 13);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x8,%rsp
mov %edi,-0x4(%rbp)
cmpl $0x1,-0x4(%rbp)
jne 11a6 <func0+0x1c>
mov $0x1,%eax
jmp 11b3 <func0+0x29>
mov -0x4(%rbp),%eax
mov %eax,%edi
callq 1149 <set_middle_bits>
xor -0x4(%rbp),%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 8
mov [rbp+var_4], edi
cmp [rbp+var_4], 1
jnz short loc_11A6
mov eax, 1
jmp short locret_11B3
loc_11A6:
mov eax, [rbp+var_4]
mov edi, eax
call set_middle_bits
xor eax, [rbp+var_4]
locret_11B3:
leave
retn | long long func0(unsigned int a1)
{
if ( a1 == 1 )
return 1LL;
else
return a1 ^ (unsigned int)set_middle_bits(a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x8
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x1
JNZ 0x001011a6
MOV EAX,0x1
JMP 0x001011b3
LAB_001011a6:
MOV EAX,dword ptr [RBP + -0x4]
MOV EDI,EAX
CALL 0x00101149
XOR EAX,dword ptr [RBP + -0x4]
LAB_001011b3:
LEAVE
RET | uint func0(uint param_1)
{
uint uVar1;
if (param_1 == 1) {
uVar1 = 1;
}
else {
uVar1 = set_middle_bits(param_1);
uVar1 = uVar1 ^ param_1;
}
return uVar1;
} |
6,833 | func0 |
#include <assert.h>
int set_middle_bits(int n) {
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return (n >> 1) ^ 1;
}
| int func0(int n) {
if (n == 1) {
return 1;
}
return n ^ set_middle_bits(n);
}
| int main() {
assert(func0(9) == 15);
assert(func0(10) == 12);
assert(func0(11) == 13);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
cmp $0x1,%edi
je 1189 <func0+0x34>
mov %edi,%edx
sar %edx
or %edi,%edx
mov %edx,%eax
sar $0x2,%eax
or %eax,%edx
mov %edx,%eax
sar $0x4,%eax
or %eax,%edx
mov %edx,%eax
sar $0x8,%eax
or %eax,%edx
mov %edx,%eax
sar $0x10,%eax
or %edx,%eax
sar %eax
xor %edi,%eax
xor $0x1,%eax
retq
| func0:
endbr64
mov eax, edi
cmp edi, 1
jz short locret_1189
mov edx, edi
sar edx, 1
or edx, edi
mov eax, edx
sar eax, 2
or edx, eax
mov eax, edx
sar eax, 4
or edx, eax
mov eax, edx
sar eax, 8
or edx, eax
mov eax, edx
sar eax, 10h
or eax, edx
sar eax, 1
xor eax, edi
xor eax, 1
locret_1189:
retn | long long func0(int a1)
{
long long result; // rax
result = (unsigned int)a1;
if ( a1 != 1 )
return a1 ^ ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1) | ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 16)) >> 1) ^ 1u;
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,0x1
JZ 0x00101189
MOV EDX,EDI
SAR EDX,0x1
OR EDX,EDI
MOV EAX,EDX
SAR EAX,0x2
OR EDX,EAX
MOV EAX,EDX
SAR EAX,0x4
OR EDX,EAX
MOV EAX,EDX
SAR EAX,0x8
OR EDX,EAX
MOV EAX,EDX
SAR EAX,0x10
OR EAX,EDX
SAR EAX,0x1
XOR EAX,EDI
XOR EAX,0x1
LAB_00101189:
RET | uint func0(uint param_1)
{
uint uVar1;
if (param_1 != 1) {
uVar1 = (int)param_1 >> 1 | param_1;
uVar1 = uVar1 | (int)uVar1 >> 2;
uVar1 = uVar1 | (int)uVar1 >> 4;
uVar1 = uVar1 | (int)uVar1 >> 8;
param_1 = (int)((int)uVar1 >> 0x10 | uVar1) >> 1 ^ param_1 ^ 1;
}
return param_1;
} |
6,834 | func0 |
#include <assert.h>
int set_middle_bits(int n) {
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return (n >> 1) ^ 1;
}
| int func0(int n) {
if (n == 1) {
return 1;
}
return n ^ set_middle_bits(n);
}
| int main() {
assert(func0(9) == 15);
assert(func0(10) == 12);
assert(func0(11) == 13);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%eax
cmp $0x1,%edi
je 11a7 <func0+0x37>
mov %edi,%edx
sar %edx
or %edi,%edx
mov %edx,%eax
sar $0x2,%eax
or %eax,%edx
mov %edx,%eax
sar $0x4,%eax
or %eax,%edx
mov %edx,%eax
sar $0x8,%eax
or %eax,%edx
mov %edx,%eax
sar $0x10,%eax
or %edx,%eax
sar %eax
xor %edi,%eax
xor $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, 1
cmp edi, 1
jz short locret_11A7
mov edx, edi
sar edx, 1
or edx, edi
mov eax, edx
sar eax, 2
or edx, eax
mov eax, edx
sar eax, 4
or edx, eax
mov eax, edx
sar eax, 8
or edx, eax
mov eax, edx
sar eax, 10h
or eax, edx
sar eax, 1
xor eax, edi
xor eax, 1
locret_11A7:
retn | long long func0(int a1)
{
long long result; // rax
result = 1LL;
if ( a1 != 1 )
return a1 ^ ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1) | ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 16)) >> 1) ^ 1u;
return result;
} | func0:
ENDBR64
MOV EAX,0x1
CMP EDI,0x1
JZ 0x001011a7
MOV EDX,EDI
SAR EDX,0x1
OR EDX,EDI
MOV EAX,EDX
SAR EAX,0x2
OR EDX,EAX
MOV EAX,EDX
SAR EAX,0x4
OR EDX,EAX
MOV EAX,EDX
SAR EAX,0x8
OR EDX,EAX
MOV EAX,EDX
SAR EAX,0x10
OR EAX,EDX
SAR EAX,0x1
XOR EAX,EDI
XOR EAX,0x1
LAB_001011a7:
RET | uint func0(uint param_1)
{
uint uVar1;
uVar1 = 1;
if (param_1 != 1) {
uVar1 = (int)param_1 >> 1 | param_1;
uVar1 = uVar1 | (int)uVar1 >> 2;
uVar1 = uVar1 | (int)uVar1 >> 4;
uVar1 = uVar1 | (int)uVar1 >> 8;
uVar1 = (int)((int)uVar1 >> 0x10 | uVar1) >> 1 ^ param_1 ^ 1;
}
return uVar1;
} |
6,835 | func0 |
#include <assert.h>
int set_middle_bits(int n) {
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return (n >> 1) ^ 1;
}
| int func0(int n) {
if (n == 1) {
return 1;
}
return n ^ set_middle_bits(n);
}
| int main() {
assert(func0(9) == 15);
assert(func0(10) == 12);
assert(func0(11) == 13);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%eax
cmp $0x1,%edi
je 11a7 <func0+0x37>
mov %edi,%edx
sar %edx
or %edi,%edx
mov %edx,%eax
sar $0x2,%eax
or %eax,%edx
mov %edx,%eax
sar $0x4,%eax
or %eax,%edx
mov %edx,%eax
sar $0x8,%eax
or %eax,%edx
mov %edx,%eax
sar $0x10,%eax
or %edx,%eax
sar %eax
xor %edi,%eax
xor $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, 1
cmp edi, 1
jz short locret_11A7
mov edx, edi
sar edx, 1
or edx, edi
mov eax, edx
sar eax, 2
or edx, eax
mov eax, edx
sar eax, 4
or edx, eax
mov eax, edx
sar eax, 8
or edx, eax
mov eax, edx
sar eax, 10h
or eax, edx
sar eax, 1
xor eax, edi
xor eax, 1
locret_11A7:
retn | long long func0(int a1)
{
long long result; // rax
result = 1LL;
if ( a1 != 1 )
return a1 ^ ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1) | ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 16)) >> 1) ^ 1u;
return result;
} | func0:
ENDBR64
MOV EAX,0x1
CMP EDI,0x1
JZ 0x001011a7
MOV EDX,EDI
SAR EDX,0x1
OR EDX,EDI
MOV EAX,EDX
SAR EAX,0x2
OR EDX,EAX
MOV EAX,EDX
SAR EAX,0x4
OR EDX,EAX
MOV EAX,EDX
SAR EAX,0x8
OR EDX,EAX
MOV EAX,EDX
SAR EAX,0x10
OR EAX,EDX
SAR EAX,0x1
XOR EAX,EDI
XOR EAX,0x1
LAB_001011a7:
RET | uint func0(uint param_1)
{
uint uVar1;
uVar1 = 1;
if (param_1 != 1) {
uVar1 = (int)param_1 >> 1 | param_1;
uVar1 = uVar1 | (int)uVar1 >> 2;
uVar1 = uVar1 | (int)uVar1 >> 4;
uVar1 = uVar1 | (int)uVar1 >> 8;
uVar1 = (int)((int)uVar1 >> 0x10 | uVar1) >> 1 ^ param_1 ^ 1;
}
return uVar1;
} |
6,836 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int x) {
int l = 0;
int r = n;
while (l < r) {
int mid = (l + r) / 2;
if (a[mid] < x)
l = mid + 1;
else
r = mid;
}
return l;
}
| int main() {
int arr1[] = {1, 2, 4, 5};
assert(func0(arr1, 4, 6) == 4);
assert(func0(arr1, 4, 3) == 2);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4, 7) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 11ca <func0+0x61>
mov -0xc(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jle 11c4 <func0+0x5b>
mov -0x4(%rbp),%eax
add $0x1,%eax
mov %eax,-0xc(%rbp)
jmp 11ca <func0+0x61>
mov -0x4(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0xc(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 118a <func0+0x21>
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_C], 0
mov eax, [rbp+var_1C]
mov [rbp+var_8], eax
jmp short loc_11CA
loc_118A:
mov edx, [rbp+var_C]
mov eax, [rbp+var_8]
add eax, edx
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_20], eax
jle short loc_11C4
mov eax, [rbp+var_4]
add eax, 1
mov [rbp+var_C], eax
jmp short loc_11CA
loc_11C4:
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
loc_11CA:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_8]
jl short loc_118A
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, int a2, int a3)
{
int v4; // [rsp+14h] [rbp-Ch]
v4 = 0;
while ( v4 < a2 )
{
if ( a3 <= *(_DWORD *)(4LL * ((v4 + a2) / 2) + a1) )
a2 = (v4 + a2) / 2;
else
v4 = (v4 + a2) / 2 + 1;
}
return (unsigned int)v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011ca
LAB_0010118a:
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x20],EAX
JLE 0x001011c4
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001011ca
LAB_001011c4:
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
LAB_001011ca:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x8]
JL 0x0010118a
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int local_14;
int local_10;
local_14 = 0;
iVar1 = param_2;
while (local_10 = iVar1, local_14 < local_10) {
iVar1 = (local_10 + local_14) / 2;
if (*(int *)(param_1 + (long)iVar1 * 4) < param_3) {
local_14 = iVar1 + 1;
iVar1 = local_10;
}
}
return local_14;
} |
6,837 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int x) {
int l = 0;
int r = n;
while (l < r) {
int mid = (l + r) / 2;
if (a[mid] < x)
l = mid + 1;
else
r = mid;
}
return l;
}
| int main() {
int arr1[] = {1, 2, 4, 5};
assert(func0(arr1, 4, 6) == 4);
assert(func0(arr1, 4, 3) == 2);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4, 7) == 4);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%r8d
cmp %r8d,%esi
jle 1197 <func0+0x2e>
lea (%rsi,%r8,1),%ecx
mov %ecx,%eax
shr $0x1f,%eax
add %ecx,%eax
sar %eax
movslq %eax,%rcx
cmp %edx,(%rdi,%rcx,4)
jl 1191 <func0+0x28>
mov %eax,%esi
jmp 1173 <func0+0xa>
lea 0x1(%rax),%r8d
jmp 1173 <func0+0xa>
mov %r8d,%eax
retq
| func0:
endbr64
mov r8d, 0
loc_1173:
cmp esi, r8d
jle short loc_1197
lea ecx, [rsi+r8]
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
movsxd rcx, eax
cmp [rdi+rcx*4], edx
jl short loc_1191
mov esi, eax
jmp short loc_1173
loc_1191:
lea r8d, [rax+1]
jmp short loc_1173
loc_1197:
mov eax, r8d
retn | long long func0(long long a1, int a2, int a3)
{
int v3; // r8d
int v4; // eax
v3 = 0;
while ( a2 > v3 )
{
v4 = (a2 + v3) / 2;
if ( *(_DWORD *)(a1 + 4LL * v4) < a3 )
v3 = v4 + 1;
else
a2 = (a2 + v3) / 2;
}
return (unsigned int)v3;
} | func0:
ENDBR64
MOV R8D,0x0
LAB_00101173:
CMP ESI,R8D
JLE 0x00101197
LEA ECX,[RSI + R8*0x1]
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOVSXD RCX,EAX
CMP dword ptr [RDI + RCX*0x4],EDX
JL 0x00101191
MOV ESI,EAX
JMP 0x00101173
LAB_00101191:
LEA R8D,[RAX + 0x1]
JMP 0x00101173
LAB_00101197:
MOV EAX,R8D
RET | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
iVar2 = 0;
while (iVar1 = param_2, iVar2 < iVar1) {
param_2 = (iVar1 + iVar2) / 2;
if (*(int *)(param_1 + (long)param_2 * 4) < param_3) {
iVar2 = param_2 + 1;
param_2 = iVar1;
}
}
return iVar2;
} |
6,838 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int x) {
int l = 0;
int r = n;
while (l < r) {
int mid = (l + r) / 2;
if (a[mid] < x)
l = mid + 1;
else
r = mid;
}
return l;
}
| int main() {
int arr1[] = {1, 2, 4, 5};
assert(func0(arr1, 4, 6) == 4);
assert(func0(arr1, 4, 3) == 2);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4, 7) == 4);
return 0;
}
| O2 | c | func0:
endbr64
xor %r8d,%r8d
jmp 12f0 <func0+0x20>
nopl 0x0(%rax)
lea (%rsi,%r8,1),%eax
sar %eax
movslq %eax,%rcx
cmp %edx,(%rdi,%rcx,4)
jl 1300 <func0+0x30>
mov %eax,%esi
cmp %r8d,%esi
jg 12e0 <func0+0x10>
mov %r8d,%eax
retq
nopl 0x0(%rax)
lea 0x1(%rax),%r8d
jmp 12f0 <func0+0x20>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
xor r8d, r8d
jmp short loc_12F0
loc_12E0:
lea eax, [rsi+r8]
sar eax, 1
movsxd rcx, eax
cmp [rdi+rcx*4], edx
jl short loc_1300
mov esi, eax
loc_12F0:
cmp esi, r8d
jg short loc_12E0
mov eax, r8d
retn
loc_1300:
lea r8d, [rax+1]
jmp short loc_12F0 | long long func0(long long a1, int a2, int a3)
{
int v3; // r8d
int v4; // eax
v3 = 0;
while ( a2 > v3 )
{
v4 = (a2 + v3) >> 1;
if ( *(_DWORD *)(a1 + 4LL * v4) < a3 )
v3 = v4 + 1;
else
a2 = (a2 + v3) >> 1;
}
return (unsigned int)v3;
} | func0:
ENDBR64
XOR R8D,R8D
JMP 0x001012f0
LAB_001012e0:
LEA EAX,[RSI + R8*0x1]
SAR EAX,0x1
MOVSXD RCX,EAX
CMP dword ptr [RDI + RCX*0x4],EDX
JL 0x00101300
MOV ESI,EAX
LAB_001012f0:
CMP ESI,R8D
JG 0x001012e0
MOV EAX,R8D
RET
LAB_00101300:
LEA R8D,[RAX + 0x1]
JMP 0x001012f0 | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
iVar2 = 0;
while (iVar1 = param_2, iVar2 < iVar1) {
param_2 = iVar1 + iVar2 >> 1;
if (*(int *)(param_1 + (long)param_2 * 4) < param_3) {
iVar2 = param_2 + 1;
param_2 = iVar1;
}
}
return iVar2;
} |
6,839 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int x) {
int l = 0;
int r = n;
while (l < r) {
int mid = (l + r) / 2;
if (a[mid] < x)
l = mid + 1;
else
r = mid;
}
return l;
}
| int main() {
int arr1[] = {1, 2, 4, 5};
assert(func0(arr1, 4, 6) == 4);
assert(func0(arr1, 4, 3) == 2);
int arr2[] = {1, 2, 4, 5};
assert(func0(arr2, 4, 7) == 4);
return 0;
}
| O3 | c | func0:
endbr64
xor %r8d,%r8d
jmp 12d0 <func0+0x20>
nopl 0x0(%rax)
lea (%rsi,%r8,1),%eax
sar %eax
movslq %eax,%rcx
cmp %edx,(%rdi,%rcx,4)
jl 12e0 <func0+0x30>
mov %eax,%esi
cmp %r8d,%esi
jg 12c0 <func0+0x10>
mov %r8d,%eax
retq
nopl 0x0(%rax)
lea 0x1(%rax),%r8d
jmp 12d0 <func0+0x20>
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
xor r8d, r8d
jmp short loc_12E7
loc_12D0:
lea ecx, [rsi+r8]
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
movsxd rcx, eax
cmp [rdi+rcx*4], edx
jl short loc_12F0
mov esi, eax
loc_12E7:
cmp esi, r8d
jg short loc_12D0
mov eax, r8d
retn
loc_12F0:
lea r8d, [rax+1]
jmp short loc_12E7 | long long func0(long long a1, int a2, int a3)
{
int v3; // r8d
int v4; // eax
v3 = 0;
while ( a2 > v3 )
{
v4 = (a2 + v3) / 2;
if ( *(_DWORD *)(a1 + 4LL * v4) < a3 )
v3 = v4 + 1;
else
a2 = (a2 + v3) / 2;
}
return (unsigned int)v3;
} | func0:
ENDBR64
XOR R8D,R8D
JMP 0x001012e7
LAB_001012d0:
LEA ECX,[RSI + R8*0x1]
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOVSXD RCX,EAX
CMP dword ptr [RDI + RCX*0x4],EDX
JL 0x001012f0
MOV ESI,EAX
LAB_001012e7:
CMP ESI,R8D
JG 0x001012d0
MOV EAX,R8D
RET
LAB_001012f0:
LEA R8D,[RAX + 0x1]
JMP 0x001012e7 | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
iVar2 = 0;
while (iVar1 = param_2, iVar2 < iVar1) {
param_2 = (iVar1 + iVar2) / 2;
if (*(int *)(param_1 + (long)param_2 * 4) < param_3) {
iVar2 = param_2 + 1;
param_2 = iVar1;
}
}
return iVar2;
} |
6,840 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(char* string) {
regex_t regex;
int result;
char* pattern = "^[aeiouAEIOU][A-Za-z0-9_]*";
regcomp(®ex, pattern, REG_EXTENDED | REG_NOSUB);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "Valid";
} else {
return "Invalid";
}
}
| int main() {
assert(func0("annie") == "Valid");
assert(func0("dawood") == "Invalid");
assert(func0("Else") == "Valid");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe19(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x9,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10c0 <regcomp@plt>
mov -0x68(%rbp),%rsi
lea -0x50(%rbp),%rax
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rax,%rdi
callq 10d0 <regexec@plt>
mov %eax,-0x5c(%rbp)
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 1090 <regfree@plt>
cmpl $0x0,-0x5c(%rbp)
jne 1249 <func0+0x80>
lea 0xddc(%rip),%rax
jmp 1250 <func0+0x87>
lea 0xdd9(%rip),%rax
mov -0x8(%rbp),%rdx
xor %fs:0x28,%rdx
je 1264 <func0+0x9b>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aAeiouaeiouAZaZ; "^[aeiouAEIOU][A-Za-z0-9_]*"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 9; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov rsi, [rbp+string]; string
lea rax, [rbp+preg]
mov r8d, 0; eflags
mov ecx, 0; pmatch
mov edx, 0; nmatch
mov rdi, rax; preg
call _regexec
mov [rbp+var_5C], eax
lea rax, [rbp+preg]
mov rdi, rax; preg
call _regfree
cmp [rbp+var_5C], 0
jnz short loc_1249
lea rax, aValid; "Valid"
jmp short loc_1250
loc_1249:
lea rax, aInvalid; "Invalid"
loc_1250:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1264
call ___stack_chk_fail
locret_1264:
leave
retn | const char * func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-5Ch]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
regcomp(&preg, "^[aeiouAEIOU][A-Za-z0-9_]*", 9);
v2 = regexec(&preg, a1, 0LL, 0LL, 0);
regfree(&preg);
if ( v2 )
return "Invalid";
else
return "Valid";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102004]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x9
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010c0
MOV RSI,qword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x5c],EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00101090
CMP dword ptr [RBP + -0x5c],0x0
JNZ 0x00101249
LEA RAX,[0x10201f]
JMP 0x00101250
LAB_00101249:
LEA RAX,[0x102025]
LAB_00101250:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101264
CALL 0x001010a0
LAB_00101264:
LEAVE
RET | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&local_58,"^[aeiouAEIOU][A-Za-z0-9_]*",9);
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if (iVar1 == 0) {
pcVar2 = "Valid";
}
else {
pcVar2 = "Invalid";
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pcVar2;
} |
6,841 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(char* string) {
regex_t regex;
int result;
char* pattern = "^[aeiouAEIOU][A-Za-z0-9_]*";
regcomp(®ex, pattern, REG_EXTENDED | REG_NOSUB);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "Valid";
} else {
return "Invalid";
}
}
| int main() {
assert(func0("annie") == "Valid");
assert(func0("dawood") == "Invalid");
assert(func0("Else") == "Valid");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov $0x9,%edx
lea 0xe1d(%rip),%rsi
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %eax,%ebx
mov %rbp,%rdi
callq 1090 <regfree@plt>
test %ebx,%ebx
lea 0xdd9(%rip),%rax
lea 0xdd8(%rip),%rdx
cmovne %rdx,%rax
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 124d <func0+0x84>
add $0x58,%rsp
pop %rbx
pop %rbp
retq
callq 10a0 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov edx, 9
lea rsi, aAeiouaeiouAZaZ; "^[aeiouAEIOU][A-Za-z0-9_]*"
mov rdi, rbp
call _regcomp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
mov rdi, rbp
call _regexec
mov ebx, eax
mov rdi, rbp
call _regfree
test ebx, ebx
lea rax, aValid; "Valid"
lea rdx, aInvalid; "Invalid"
cmovnz rax, rdx
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_124D
add rsp, 58h
pop rbx
pop rbp
retn
loc_124D:
call ___stack_chk_fail | const char * func0(long long a1)
{
int v1; // ebx
const char *result; // rax
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "^[aeiouAEIOU][A-Za-z0-9_]*", 9LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
result = "Valid";
if ( v1 )
return "Invalid";
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV EDX,0x9
LEA RSI,[0x102012]
MOV RDI,RBP
CALL 0x001010c0
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
MOV EBX,EAX
MOV RDI,RBP
CALL 0x00101090
TEST EBX,EBX
LEA RAX,[0x102004]
LEA RDX,[0x10200a]
CMOVNZ RAX,RDX
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010124d
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_0010124d:
CALL 0x001010a0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"^[aeiouAEIOU][A-Za-z0-9_]*",9);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Valid";
if (iVar1 != 0) {
pcVar2 = "Invalid";
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,842 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(char* string) {
regex_t regex;
int result;
char* pattern = "^[aeiouAEIOU][A-Za-z0-9_]*";
regcomp(®ex, pattern, REG_EXTENDED | REG_NOSUB);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "Valid";
} else {
return "Invalid";
}
}
| int main() {
assert(func0("annie") == "Valid");
assert(func0("dawood") == "Invalid");
assert(func0("Else") == "Valid");
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x9,%edx
mov %rdi,%r12
lea 0xd7d(%rip),%rsi
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %ecx,%ecx
xor %edx,%edx
xor %r8d,%r8d
mov %r12,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %rbp,%rdi
mov %eax,%ebx
callq 1090 <regfree@plt>
test %ebx,%ebx
lea 0xd29(%rip),%rax
lea 0xd28(%rip),%rdx
cmovne %rdx,%rax
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 12ff <func0+0x7f>
add $0x50,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push r12
mov edx, 9
mov r12, rdi
lea rsi, aAeiouaeiouAZaZ; "^[aeiouAEIOU][A-Za-z0-9_]*"
push rbp
push rbx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
xor edx, edx
xor r8d, r8d
xor ecx, ecx
mov rsi, r12
mov rdi, rbp
call _regexec
mov rdi, rbp
mov ebx, eax
call _regfree
test ebx, ebx
lea rax, aValid; "Valid"
lea rdx, aInvalid; "Invalid"
cmovnz rax, rdx
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_12FF
add rsp, 50h
pop rbx
pop rbp
pop r12
retn
loc_12FF:
call ___stack_chk_fail | const char * func0(long long a1)
{
int v1; // ebx
const char *result; // rax
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "^[aeiouAEIOU][A-Za-z0-9_]*", 9LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
result = "Valid";
if ( v1 )
return "Invalid";
return result;
} | func0:
ENDBR64
PUSH R12
MOV EDX,0x9
MOV R12,RDI
LEA RSI,[0x102012]
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010c0
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,R12
MOV RDI,RBP
CALL 0x001010d0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x00101090
TEST EBX,EBX
LEA RAX,[0x102004]
LEA RDX,[0x10200a]
CMOVNZ RAX,RDX
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012ff
ADD RSP,0x50
POP RBX
POP RBP
POP R12
RET
LAB_001012ff:
CALL 0x001010a0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"^[aeiouAEIOU][A-Za-z0-9_]*",9);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Valid";
if (iVar1 != 0) {
pcVar2 = "Invalid";
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,843 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(char* string) {
regex_t regex;
int result;
char* pattern = "^[aeiouAEIOU][A-Za-z0-9_]*";
regcomp(®ex, pattern, REG_EXTENDED | REG_NOSUB);
result = regexec(®ex, string, 0, NULL, 0);
regfree(®ex);
if (result == 0) {
return "Valid";
} else {
return "Invalid";
}
}
| int main() {
assert(func0("annie") == "Valid");
assert(func0("dawood") == "Invalid");
assert(func0("Else") == "Valid");
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x9,%edx
mov %rdi,%r12
lea 0xd7d(%rip),%rsi
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %ecx,%ecx
xor %edx,%edx
xor %r8d,%r8d
mov %r12,%rsi
mov %rbp,%rdi
callq 10d0 <regexec@plt>
mov %rbp,%rdi
mov %eax,%ebx
callq 1090 <regfree@plt>
test %ebx,%ebx
lea 0xd29(%rip),%rax
lea 0xd28(%rip),%rdx
cmovne %rdx,%rax
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rcx
jne 12ff <func0+0x7f>
add $0x50,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 10a0 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0:
endbr64
push rbp
mov edx, 9; cflags
lea rsi, pattern; "^[aeiouAEIOU][A-Za-z0-9_]*"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
xor edx, edx; nmatch
xor r8d, r8d; eflags
xor ecx, ecx; pmatch
mov rsi, rbx; string
mov rdi, rbp; preg
call _regexec
mov rdi, rbp; preg
mov ebx, eax
call _regfree
test ebx, ebx
lea rax, aInvalid; "Invalid"
lea rdx, aValid; "Valid"
cmovz rax, rdx
mov rdx, [rsp+var_s48]
sub rdx, fs:28h
jnz short loc_12FB
add rsp, 58h
pop rbx
pop rbp
retn
loc_12FB:
call ___stack_chk_fail | const char * func0(char *string)
{
int v1; // ebx
const char *result; // rax
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
regcomp(&_0, "^[aeiouAEIOU][A-Za-z0-9_]*", 9);
v1 = regexec(&_0, string, 0LL, 0LL, 0);
regfree(&_0);
result = "Invalid";
if ( !v1 )
return "Valid";
return result;
} | func0:
ENDBR64
PUSH RBP
MOV EDX,0x9
LEA RSI,[0x102012]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010c0
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x00101090
TEST EBX,EBX
LEA RAX,[0x10200a]
LEA RDX,[0x102004]
CMOVZ RAX,RDX
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x001012fb
ADD RSP,0x58
POP RBX
POP RBP
RET
LAB_001012fb:
CALL 0x001010a0 | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"^[aeiouAEIOU][A-Za-z0-9_]*",9);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Invalid";
if (iVar1 == 0) {
pcVar2 = "Valid";
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return pcVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
6,844 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int n) {
if (n < 0) {
return 0;
} else {
return 1 / pow(2, n) + func0(n - 1);
}
}
| int main() {
assert(func0(7) == 1.9921875);
assert(func0(4) == 1.9375);
assert(func0(8) == 1.99609375);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jns 1184 <func0+0x1b>
pxor %xmm0,%xmm0
jmp 11c1 <func0+0x58>
cvtsi2sdl -0x4(%rbp),%xmm0
mov 0xf00(%rip),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xef2(%rip),%xmm1
divsd %xmm0,%xmm1
movsd %xmm1,-0x10(%rbp)
mov -0x4(%rbp),%eax
sub $0x1,%eax
mov %eax,%edi
callq 1169 <func0>
addsd -0x10(%rbp),%xmm0
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
cmp [rbp+var_4], 0
jns short loc_1184
pxor xmm0, xmm0
jmp short locret_11C5
loc_1184:
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_4]
mov rax, cs:x
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movsd xmm1, cs:qword_2078
divsd xmm1, xmm0
movsd [rbp+var_10], xmm1
mov eax, [rbp+var_4]
sub eax, 1
mov edi, eax
call func0
addsd xmm0, [rbp+var_10]
locret_11C5:
leave
retn | double func0(int a1)
{
double v2; // [rsp+0h] [rbp-10h]
if ( a1 < 0 )
return 0.0;
v2 = 1.0 / pow(2.0, (double)a1);
return func0((unsigned int)(a1 - 1)) + v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x0
JNS 0x00101184
PXOR XMM0,XMM0
JMP 0x001011c5
LAB_00101184:
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [0x00102070]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
MOVSD XMM1,qword ptr [0x00102078]
DIVSD XMM1,XMM0
MOVSD qword ptr [RBP + -0x10],XMM1
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
MOV EDI,EAX
CALL 0x00101169
ADDSD XMM0,qword ptr [RBP + -0x10]
LAB_001011c5:
LEAVE
RET | double func0(int param_1)
{
double dVar1;
double dVar2;
if (param_1 < 0) {
dVar2 = 0.0;
}
else {
dVar1 = pow(DAT_00102070,(double)param_1);
dVar1 = DAT_00102078 / dVar1;
dVar2 = (double)func0(param_1 + -1);
dVar2 = dVar2 + dVar1;
}
return dVar2;
} |
6,845 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int n) {
if (n < 0) {
return 0;
} else {
return 1 / pow(2, n) + func0(n - 1);
}
}
| int main() {
assert(func0(7) == 1.9921875);
assert(func0(4) == 1.9375);
assert(func0(8) == 1.99609375);
return 0;
}
| O1 | c | func0:
endbr64
pxor %xmm0,%xmm0
test %edi,%edi
jns 1176 <func0+0xd>
retq
push %rbx
sub $0x10,%rsp
mov %edi,%ebx
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
movsd 0xf03(%rip),%xmm0
callq 1060 <pow@plt>
movsd %xmm0,0x8(%rsp)
lea -0x1(%rbx),%edi
callq 1169 <func0>
movapd %xmm0,%xmm1
movsd 0xeec(%rip),%xmm0
divsd 0x8(%rsp),%xmm0
addsd %xmm1,%xmm0
add $0x10,%rsp
pop %rbx
retq
| func0:
endbr64
pxor xmm0, xmm0
test edi, edi
jns short loc_1176
retn
loc_1176:
push r14
push rbx
sub rsp, 8
mov ebx, edi
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
movsd xmm0, cs:qword_2068
call _pow
movq r14, xmm0
lea edi, [rbx-1]
call func0
movapd xmm1, xmm0
movsd xmm0, cs:qword_2070
movq xmm2, r14
divsd xmm0, xmm2
addsd xmm0, xmm1
add rsp, 8
pop rbx
pop r14
retn | double func0(int a1)
{
double result; // xmm0_8
double v2; // r14
result = 0.0;
if ( a1 >= 0 )
{
v2 = pow(2.0, (double)a1);
return 1.0 / v2 + func0((unsigned int)(a1 - 1));
}
return result;
} | func0:
ENDBR64
PXOR XMM0,XMM0
TEST EDI,EDI
JNS 0x00101176
RET
LAB_00101176:
PUSH R14
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MOVSD XMM0,qword ptr [0x00102068]
CALL 0x00101060
MOVQ R14,XMM0
LEA EDI,[RBX + -0x1]
CALL 0x00101169
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102070]
MOVQ XMM2,R14
DIVSD XMM0,XMM2
ADDSD XMM0,XMM1
ADD RSP,0x8
POP RBX
POP R14
RET | double func0(int param_1)
{
double dVar1;
double dVar2;
if (param_1 < 0) {
return 0.0;
}
dVar1 = pow(DAT_00102068,(double)param_1);
dVar2 = (double)func0(param_1 + -1);
return DAT_00102070 / dVar1 + dVar2;
} |
6,846 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int n) {
if (n < 0) {
return 0;
} else {
return 1 / pow(2, n) + func0(n - 1);
}
}
| int main() {
assert(func0(7) == 1.9921875);
assert(func0(4) == 1.9375);
assert(func0(8) == 1.99609375);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jns 1230 <func0+0x10>
pxor %xmm0,%xmm0
retq
nopl (%rax)
jmp 1240 <func0.part.0>
data16 nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
push rbx
pxor xmm1, xmm1
mov ebx, edi
cvtsi2sd xmm1, edi
sub rsp, 20h
mov rax, cs:qword_2068
movq xmm0, rax
call _pow
movsd xmm2, cs:qword_2070
pxor xmm3, xmm3
divsd xmm2, xmm0
test ebx, ebx
jnz short loc_1268
addsd xmm2, xmm3
add rsp, 20h
pop rbx
movapd xmm0, xmm2
retn
loc_1268:
lea eax, [rbx-1]
pxor xmm1, xmm1
movsd [rsp+28h+var_18], xmm3
cvtsi2sd xmm1, eax
mov rax, cs:qword_2068
movsd [rsp+28h+var_20], xmm2
movq xmm0, rax
call _pow
movsd xmm4, cs:qword_2070
cmp ebx, 1
movsd xmm3, [rsp+28h+var_18]
movsd xmm2, [rsp+28h+var_20]
lea eax, [rbx-2]
divsd xmm4, xmm0
movapd xmm0, xmm3
jnz short loc_12D0
loc_12B4:
addsd xmm4, xmm0
add rsp, 20h
pop rbx
movapd xmm3, xmm4
addsd xmm2, xmm3
movapd xmm0, xmm2
retn
loc_12D0:
pxor xmm1, xmm1
movsd [rsp+28h+var_10], xmm4
cvtsi2sd xmm1, eax
mov rax, cs:qword_2068
movq xmm0, rax
call _pow
movsd xmm1, cs:qword_2070
cmp ebx, 2
movsd xmm3, [rsp+28h+var_18]
movsd xmm2, [rsp+28h+var_20]
movsd xmm4, [rsp+28h+var_10]
lea edi, [rbx-3]
divsd xmm1, xmm0
jz short loc_133C
movsd [rsp+28h+var_10], xmm1
movsd [rsp+28h+var_18], xmm4
call func0_part_0
movsd xmm1, [rsp+28h+var_10]
movsd xmm4, [rsp+28h+var_18]
movsd xmm2, [rsp+28h+var_20]
movapd xmm3, xmm0
loc_133C:
addsd xmm1, xmm3
movapd xmm0, xmm1
jmp loc_12B4 | __int128 __usercall func0_part_0@<xmm0>(int a1@<edi>)
{
double v1; // xmm0_8
__int128 v2; // xmm2
__int128 v4; // xmm2
double v5; // xmm4_8
double v6; // xmm0_8
double v7; // xmm0_8
double v8; // xmm3_8
double v9; // xmm1_8
double v10; // xmm0_8
double v11; // [rsp+0h] [rbp-20h]
double v12; // [rsp+8h] [rbp-18h]
double v13; // [rsp+10h] [rbp-10h]
double v14; // [rsp+10h] [rbp-10h]
v1 = pow(2.0, (double)a1);
v2 = 0x3FF0000000000000uLL;
*(double *)&v2 = 1.0 / v1;
if ( a1 )
{
v11 = 1.0 / v1;
v4 = COERCE_UNSIGNED_INT64(1.0 / v1);
v5 = 1.0 / pow(2.0, (double)(a1 - 1));
v6 = 0.0;
if ( a1 != 1 )
{
v13 = v5;
v7 = pow(2.0, (double)(a1 - 2));
v8 = 0.0;
v4 = *(unsigned long long *)&v11;
v5 = v13;
v9 = 1.0 / v7;
if ( a1 != 2 )
{
v14 = 1.0 / v7;
v12 = v5;
v10 = func0_part_0((unsigned int)(a1 - 3), v7, v9, v11, 0.0);
v9 = v14;
v5 = v12;
v4 = *(unsigned long long *)&v11;
v8 = v10;
}
v6 = v9 + v8;
}
*(double *)&v4 = *(double *)&v4 + v5 + v6;
return v4;
}
else
{
*(double *)&v2 = *(double *)&v2 + 0.0;
return v2;
}
} | func0.part.0:
PUSH RBX
PXOR XMM1,XMM1
MOV EBX,EDI
CVTSI2SD XMM1,EDI
SUB RSP,0x20
MOV RAX,qword ptr [0x00102068]
MOVQ XMM0,RAX
CALL 0x00101060
MOVSD XMM2,qword ptr [0x00102070]
PXOR XMM3,XMM3
DIVSD XMM2,XMM0
TEST EBX,EBX
JNZ 0x00101268
ADDSD XMM2,XMM3
ADD RSP,0x20
POP RBX
MOVAPD XMM0,XMM2
RET
LAB_00101268:
LEA EAX,[RBX + -0x1]
PXOR XMM1,XMM1
MOVSD qword ptr [RSP + 0x10],XMM3
CVTSI2SD XMM1,EAX
MOV RAX,qword ptr [0x00102068]
MOVSD qword ptr [RSP + 0x8],XMM2
MOVQ XMM0,RAX
CALL 0x00101060
MOVSD XMM4,qword ptr [0x00102070]
CMP EBX,0x1
MOVSD XMM3,qword ptr [RSP + 0x10]
MOVSD XMM2,qword ptr [RSP + 0x8]
LEA EAX,[RBX + -0x2]
DIVSD XMM4,XMM0
MOVAPD XMM0,XMM3
JNZ 0x001012d0
LAB_001012b4:
ADDSD XMM4,XMM0
ADD RSP,0x20
POP RBX
MOVAPD XMM3,XMM4
ADDSD XMM2,XMM3
MOVAPD XMM0,XMM2
RET
LAB_001012d0:
PXOR XMM1,XMM1
MOVSD qword ptr [RSP + 0x18],XMM4
CVTSI2SD XMM1,EAX
MOV RAX,qword ptr [0x00102068]
MOVQ XMM0,RAX
CALL 0x00101060
MOVSD XMM1,qword ptr [0x00102070]
CMP EBX,0x2
MOVSD XMM3,qword ptr [RSP + 0x10]
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVSD XMM4,qword ptr [RSP + 0x18]
LEA EDI,[RBX + -0x3]
DIVSD XMM1,XMM0
JZ 0x0010133c
MOVSD qword ptr [RSP + 0x18],XMM1
MOVSD qword ptr [RSP + 0x10],XMM4
CALL 0x00101220
MOVSD XMM1,qword ptr [RSP + 0x18]
MOVSD XMM4,qword ptr [RSP + 0x10]
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVAPD XMM3,XMM0
LAB_0010133c:
ADDSD XMM1,XMM3
MOVAPD XMM0,XMM1
JMP 0x001012b4 | double func0_part_0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
dVar1 = pow(DAT_00102068,(double)param_1);
dVar1 = DAT_00102070 / dVar1;
if (param_1 == 0) {
return dVar1 + 0.0;
}
dVar2 = pow(DAT_00102068,(double)(param_1 + -1));
dVar3 = 0.0;
dVar2 = DAT_00102070 / dVar2;
if (param_1 != 1) {
dVar3 = pow(DAT_00102068,(double)(param_1 + -2));
dVar4 = 0.0;
dVar3 = DAT_00102070 / dVar3;
if (param_1 != 2) {
dVar4 = (double)func0_part_0(param_1 + -3);
}
dVar3 = dVar3 + dVar4;
}
return dVar1 + dVar2 + dVar3;
} |
6,847 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int n) {
if (n < 0) {
return 0;
} else {
return 1 / pow(2, n) + func0(n - 1);
}
}
| int main() {
assert(func0(7) == 1.9921875);
assert(func0(4) == 1.9375);
assert(func0(8) == 1.99609375);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm2,%xmm2
test %edi,%edi
jns 1288 <func0+0x18>
movapd %xmm2,%xmm0
retq
nopl 0x0(%rax)
push %rbx
pxor %xmm1,%xmm1
mov %edi,%ebx
cvtsi2sd %edi,%xmm1
sub $0x40,%rsp
mov 0xdf2(%rip),%rax
movsd %xmm2,0x8(%rsp)
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xde2(%rip),%xmm4
movsd 0x8(%rsp),%xmm2
lea -0x1(%rbx),%eax
divsd %xmm0,%xmm4
movapd %xmm2,%xmm0
test %ebx,%ebx
jne 12e0 <func0+0x70>
addsd %xmm0,%xmm4
add $0x40,%rsp
pop %rbx
movapd %xmm4,%xmm0
retq
nopl 0x0(%rax)
pxor %xmm1,%xmm1
movsd %xmm4,0x10(%rsp)
cvtsi2sd %eax,%xmm1
mov 0xd9b(%rip),%rax
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xd91(%rip),%xmm3
cmp $0x1,%ebx
movsd 0x8(%rsp),%xmm2
movsd 0x10(%rsp),%xmm4
lea -0x2(%rbx),%eax
divsd %xmm0,%xmm3
movapd %xmm2,%xmm0
jne 1338 <func0+0xc8>
addsd %xmm3,%xmm0
add $0x40,%rsp
pop %rbx
addsd %xmm0,%xmm4
movapd %xmm4,%xmm0
retq
nopl (%rax)
pxor %xmm1,%xmm1
movsd %xmm3,0x18(%rsp)
cvtsi2sd %eax,%xmm1
mov 0xd43(%rip),%rax
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xd39(%rip),%xmm5
cmp $0x2,%ebx
movsd 0x8(%rsp),%xmm2
movsd 0x10(%rsp),%xmm4
movsd 0x18(%rsp),%xmm3
lea -0x3(%rbx),%eax
divsd %xmm0,%xmm5
movapd %xmm2,%xmm0
jne 1390 <func0+0x120>
addsd %xmm5,%xmm0
jmp 1323 <func0+0xb3>
nopw 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
movsd %xmm5,0x20(%rsp)
cvtsi2sd %eax,%xmm1
mov 0xceb(%rip),%rax
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xce1(%rip),%xmm6
cmp $0x3,%ebx
movsd 0x8(%rsp),%xmm2
movsd 0x10(%rsp),%xmm4
movsd 0x18(%rsp),%xmm3
lea -0x4(%rbx),%eax
divsd %xmm0,%xmm6
movsd 0x20(%rsp),%xmm5
movapd %xmm2,%xmm0
jne 13e8 <func0+0x178>
addsd %xmm6,%xmm0
jmp 1381 <func0+0x111>
nopl (%rax)
pxor %xmm1,%xmm1
movsd %xmm6,0x28(%rsp)
cvtsi2sd %eax,%xmm1
mov 0xc93(%rip),%rax
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xc89(%rip),%xmm7
cmp $0x4,%ebx
movsd 0x8(%rsp),%xmm2
movsd 0x10(%rsp),%xmm4
movsd 0x18(%rsp),%xmm3
lea -0x5(%rbx),%eax
divsd %xmm0,%xmm7
movsd 0x20(%rsp),%xmm5
movsd 0x28(%rsp),%xmm6
movapd %xmm2,%xmm0
jne 1443 <func0+0x1d3>
addsd %xmm7,%xmm0
jmp 13df <func0+0x16f>
pxor %xmm1,%xmm1
movsd %xmm7,0x30(%rsp)
cvtsi2sd %eax,%xmm1
mov 0xc38(%rip),%rax
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0x8(%rsp),%xmm2
cmp $0x5,%ebx
movsd 0xc24(%rip),%xmm8
movsd 0x10(%rsp),%xmm4
movsd 0x18(%rsp),%xmm3
lea -0x6(%rbx),%eax
divsd %xmm0,%xmm8
movsd 0x20(%rsp),%xmm5
movsd 0x28(%rsp),%xmm6
movapd %xmm2,%xmm0
movsd 0x30(%rsp),%xmm7
jne 14a7 <func0+0x237>
addsd %xmm8,%xmm0
jmp 143d <func0+0x1cd>
pxor %xmm1,%xmm1
movsd %xmm8,0x38(%rsp)
cvtsi2sd %eax,%xmm1
mov 0xbd3(%rip),%rax
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xbc9(%rip),%xmm1
cmp $0x6,%ebx
movsd 0x8(%rsp),%xmm2
movsd 0x10(%rsp),%xmm4
movsd 0x18(%rsp),%xmm3
lea -0x7(%rbx),%edi
divsd %xmm0,%xmm1
movsd 0x20(%rsp),%xmm5
movsd 0x28(%rsp),%xmm6
movapd %xmm2,%xmm0
movsd 0x30(%rsp),%xmm7
movsd 0x38(%rsp),%xmm8
je 1565 <func0+0x2f5>
movsd %xmm1,0x38(%rsp)
movsd %xmm8,0x30(%rsp)
movsd %xmm7,0x28(%rsp)
movsd %xmm6,0x20(%rsp)
movsd %xmm5,0x18(%rsp)
movsd %xmm3,0x10(%rsp)
movsd %xmm4,0x8(%rsp)
callq 1220 <func0.part.0>
movsd 0x38(%rsp),%xmm1
movsd 0x30(%rsp),%xmm8
movsd 0x28(%rsp),%xmm7
movsd 0x20(%rsp),%xmm6
movsd 0x18(%rsp),%xmm5
movsd 0x10(%rsp),%xmm3
movsd 0x8(%rsp),%xmm4
addsd %xmm1,%xmm0
jmpq 14a0 <func0+0x230>
xchg %ax,%ax
| func0_part_0:
push rbx
pxor xmm1, xmm1
mov ebx, edi
cvtsi2sd xmm1, edi; y
sub rsp, 20h
movsd xmm0, cs:x; x
call _pow
movsd xmm2, cs:qword_2070
divsd xmm2, xmm0
pxor xmm0, xmm0
test ebx, ebx
jnz short loc_1260
add rsp, 20h
addsd xmm0, xmm2
pop rbx
retn
loc_1260:
lea eax, [rbx-1]
pxor xmm1, xmm1
movsd xmm0, cs:x; x
movsd [rsp+28h+var_20], xmm2
cvtsi2sd xmm1, eax; y
call _pow
movsd xmm3, cs:qword_2070
cmp ebx, 1
lea eax, [rbx-2]
movsd xmm2, [rsp+28h+var_20]
divsd xmm3, xmm0
pxor xmm0, xmm0
jnz short loc_12B0
loc_129C:
addsd xmm0, xmm3
add rsp, 20h
pop rbx
addsd xmm0, xmm2
retn
loc_12B0:
pxor xmm1, xmm1
movsd xmm0, cs:x; x
movsd [rsp+28h+var_18], xmm3
cvtsi2sd xmm1, eax; y
call _pow
movsd xmm1, cs:qword_2070
cmp ebx, 2
movsd xmm2, [rsp+28h+var_20]
movsd xmm3, [rsp+28h+var_18]
lea edi, [rbx-3]
divsd xmm1, xmm0
pxor xmm0, xmm0
jz short loc_130C
movsd [rsp+28h+var_10], xmm1
call func0_part_0
movsd xmm1, [rsp+28h+var_10]
movsd xmm3, [rsp+28h+var_18]
movsd xmm2, [rsp+28h+var_20]
loc_130C:
addsd xmm0, xmm1
jmp short loc_129C | double func0_part_0(int a1)
{
double v1; // xmm2_8
double v3; // xmm3_8
double v4; // xmm0_8
double v5; // xmm1_8
v1 = 1.0 / pow(2.0, (double)a1);
if ( !a1 )
return v1 + 0.0;
v3 = 1.0 / pow(2.0, (double)(a1 - 1));
v4 = 0.0;
if ( a1 != 1 )
{
v5 = 1.0 / pow(2.0, (double)(a1 - 2));
if ( a1 != 2 )
func0_part_0((unsigned int)(a1 - 3), 0.0, v5, v1, v3);
v4 = v5 + 0.0;
}
return v4 + v3 + v1;
} | func0.part.0:
PUSH RBX
PXOR XMM1,XMM1
MOV EBX,EDI
CVTSI2SD XMM1,EDI
SUB RSP,0x20
MOVSD XMM0,qword ptr [0x00102068]
CALL 0x00101060
MOVSD XMM2,qword ptr [0x00102070]
DIVSD XMM2,XMM0
PXOR XMM0,XMM0
TEST EBX,EBX
JNZ 0x00101260
ADD RSP,0x20
ADDSD XMM0,XMM2
POP RBX
RET
LAB_00101260:
LEA EAX,[RBX + -0x1]
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102068]
MOVSD qword ptr [RSP + 0x8],XMM2
CVTSI2SD XMM1,EAX
CALL 0x00101060
MOVSD XMM3,qword ptr [0x00102070]
CMP EBX,0x1
LEA EAX,[RBX + -0x2]
MOVSD XMM2,qword ptr [RSP + 0x8]
DIVSD XMM3,XMM0
PXOR XMM0,XMM0
JNZ 0x001012b0
LAB_0010129c:
ADDSD XMM0,XMM3
ADD RSP,0x20
POP RBX
ADDSD XMM0,XMM2
RET
LAB_001012b0:
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102068]
MOVSD qword ptr [RSP + 0x10],XMM3
CVTSI2SD XMM1,EAX
CALL 0x00101060
MOVSD XMM1,qword ptr [0x00102070]
CMP EBX,0x2
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVSD XMM3,qword ptr [RSP + 0x10]
LEA EDI,[RBX + -0x3]
DIVSD XMM1,XMM0
PXOR XMM0,XMM0
JZ 0x0010130c
MOVSD qword ptr [RSP + 0x18],XMM1
CALL 0x00101220
MOVSD XMM1,qword ptr [RSP + 0x18]
MOVSD XMM3,qword ptr [RSP + 0x10]
MOVSD XMM2,qword ptr [RSP + 0x8]
LAB_0010130c:
ADDSD XMM0,XMM1
JMP 0x0010129c | double func0_part_0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
dVar1 = pow(DAT_00102068,(double)param_1);
dVar1 = DAT_00102070 / dVar1;
if (param_1 == 0) {
return dVar1 + 0.0;
}
dVar2 = pow(DAT_00102068,(double)(param_1 + -1));
dVar2 = DAT_00102070 / dVar2;
dVar4 = 0.0;
if (param_1 != 1) {
dVar3 = pow(DAT_00102068,(double)(param_1 + -2));
dVar3 = DAT_00102070 / dVar3;
dVar4 = 0.0;
if (param_1 != 2) {
dVar4 = (double)func0_part_0(param_1 + -3);
}
dVar4 = dVar4 + dVar3;
}
return dVar4 + dVar2 + dVar1;
} |
6,848 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
double x = sqrt(2 * pow(10, (n - 1)));
return (int)round(x);
}
| int main() {
assert(func0(2) == 4);
assert(func0(3) == 14);
assert(func0(4) == 45);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
sub $0x1,%eax
cvtsi2sd %eax,%xmm0
mov 0xeaf(%rip),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1090 <pow@plt>
addsd %xmm0,%xmm0
callq 10b0 <sqrt@plt>
movq %xmm0,%rax
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
movq %rax,%xmm0
callq 1080 <round@plt>
cvttsd2si %xmm0,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
sub eax, 1
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mov rax, cs:x
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
addsd xmm0, xmm0
movq rax, xmm0
movq xmm0, rax; x
call _sqrt
movq rax, xmm0
mov [rbp+x], rax
mov rax, [rbp+x]
movq xmm0, rax; x
call _round
cvttsd2si eax, xmm0
leave
retn | long long func0(int a1)
{
double v1; // xmm0_8
double v2; // xmm0_8
v1 = pow(10.0, (double)(a1 - 1));
v2 = sqrt(v1 + v1);
return (unsigned int)(int)round(v2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOV RAX,qword ptr [0x00102058]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101090
ADDSD XMM0,XMM0
MOVQ RAX,XMM0
MOVQ XMM0,RAX
CALL 0x001010b0
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVQ XMM0,RAX
CALL 0x00101080
CVTTSD2SI EAX,XMM0
LEAVE
RET | int func0(int param_1)
{
double dVar1;
dVar1 = pow(DAT_00102058,(double)(param_1 + -1));
dVar1 = sqrt(dVar1 + dVar1);
dVar1 = round(dVar1);
return (int)dVar1;
} |
6,849 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
double x = sqrt(2 * pow(10, (n - 1)));
return (int)round(x);
}
| int main() {
assert(func0(2) == 4);
assert(func0(3) == 14);
assert(func0(4) == 45);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x18,%rsp
sub $0x1,%edi
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
movsd 0xeb4(%rip),%xmm0
callq 1090 <pow@plt>
addsd %xmm0,%xmm0
movapd %xmm0,%xmm2
sqrtsd %xmm2,%xmm2
movsd %xmm2,0x8(%rsp)
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja 11f9 <func0+0x50>
movsd 0x8(%rsp),%xmm0
callq 1080 <round@plt>
cvttsd2si %xmm0,%eax
add $0x18,%rsp
retq
callq 10b0 <sqrt@plt>
jmp 11e5 <func0+0x3c>
| func0:
endbr64
sub rsp, 8
sub edi, 1
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
movsd xmm0, cs:qword_2058
call _pow
addsd xmm0, xmm0
pxor xmm1, xmm1
ucomisd xmm1, xmm0
ja short loc_11E9
sqrtsd xmm0, xmm0
loc_11DB:
call _round
cvttsd2si eax, xmm0
add rsp, 8
retn
loc_11E9:
call _sqrt
jmp short loc_11DB | long long func0(int a1)
{
double v1; // xmm0_8
double v2; // xmm0_8
double v3; // xmm0_8
v1 = pow(10.0, (double)(a1 - 1));
v2 = v1 + v1;
if ( v2 < 0.0 )
v3 = sqrt(v2);
else
v3 = sqrt(v2);
return (unsigned int)(int)round(v3);
} | func0:
ENDBR64
SUB RSP,0x8
SUB EDI,0x1
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MOVSD XMM0,qword ptr [0x00102058]
CALL 0x00101090
ADDSD XMM0,XMM0
PXOR XMM1,XMM1
UCOMISD XMM1,XMM0
JA 0x001011e9
SQRTSD XMM0,XMM0
LAB_001011db:
CALL 0x00101080
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET
LAB_001011e9:
CALL 0x001010b0
JMP 0x001011db | int func0(int param_1)
{
double dVar1;
dVar1 = pow(DAT_00102058,(double)(param_1 + -1));
dVar1 = dVar1 + dVar1;
if (dVar1 < 0.0) {
dVar1 = sqrt(dVar1);
}
else {
dVar1 = SQRT(dVar1);
}
dVar1 = round(dVar1);
return (int)dVar1;
} |
6,850 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
double x = sqrt(2 * pow(10, (n - 1)));
return (int)round(x);
}
| int main() {
assert(func0(2) == 4);
assert(func0(3) == 14);
assert(func0(4) == 45);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x1,%edi
pxor %xmm1,%xmm1
sub $0x18,%rsp
movsd 0xe11(%rip),%xmm0
cvtsi2sd %edi,%xmm1
callq 1090 <pow@plt>
pxor %xmm2,%xmm2
addsd %xmm0,%xmm0
ucomisd %xmm0,%xmm2
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
ja 1298 <func0+0x48>
movapd %xmm1,%xmm0
callq 1080 <round@plt>
add $0x18,%rsp
cvttsd2si %xmm0,%eax
retq
movsd %xmm1,0x8(%rsp)
callq 10b0 <sqrt@plt>
movsd 0x8(%rsp),%xmm1
jmp 1286 <func0+0x36>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
sub edi, 1
pxor xmm1, xmm1
sub rsp, 8
movsd xmm0, cs:qword_2058
cvtsi2sd xmm1, edi
call _pow
pxor xmm1, xmm1
addsd xmm0, xmm0
ucomisd xmm1, xmm0
ja short loc_1290
sqrtsd xmm0, xmm0
loc_1282:
call _round
add rsp, 8
cvttsd2si eax, xmm0
retn
loc_1290:
call _sqrt
jmp short loc_1282 | long long func0(int a1)
{
double v1; // xmm0_8
double v2; // xmm0_8
double v3; // xmm0_8
v1 = pow(10.0, (double)(a1 - 1));
v2 = v1 + v1;
if ( v2 < 0.0 )
v3 = sqrt(v2);
else
v3 = sqrt(v2);
return (unsigned int)(int)round(v3);
} | func0:
ENDBR64
SUB EDI,0x1
PXOR XMM1,XMM1
SUB RSP,0x8
MOVSD XMM0,qword ptr [0x00102058]
CVTSI2SD XMM1,EDI
CALL 0x00101090
PXOR XMM1,XMM1
ADDSD XMM0,XMM0
UCOMISD XMM1,XMM0
JA 0x00101290
SQRTSD XMM0,XMM0
LAB_00101282:
CALL 0x00101080
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET
LAB_00101290:
CALL 0x001010b0
JMP 0x00101282 | int func0(int param_1)
{
double dVar1;
dVar1 = pow(DAT_00102058,(double)(param_1 + -1));
dVar1 = dVar1 + dVar1;
if (dVar1 < 0.0) {
dVar1 = sqrt(dVar1);
}
else {
dVar1 = SQRT(dVar1);
}
dVar1 = round(dVar1);
return (int)dVar1;
} |
6,851 | func0 |
#include <math.h>
#include <assert.h>
| int func0(int n) {
double x = sqrt(2 * pow(10, (n - 1)));
return (int)round(x);
}
| int main() {
assert(func0(2) == 4);
assert(func0(3) == 14);
assert(func0(4) == 45);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x1,%edi
pxor %xmm1,%xmm1
sub $0x18,%rsp
movsd 0xe11(%rip),%xmm0
cvtsi2sd %edi,%xmm1
callq 1090 <pow@plt>
pxor %xmm2,%xmm2
addsd %xmm0,%xmm0
ucomisd %xmm0,%xmm2
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
ja 1298 <func0+0x48>
movapd %xmm1,%xmm0
callq 1080 <round@plt>
add $0x18,%rsp
cvttsd2si %xmm0,%eax
retq
movsd %xmm1,0x8(%rsp)
callq 10b0 <sqrt@plt>
movsd 0x8(%rsp),%xmm1
jmp 1286 <func0+0x36>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
sub edi, 1
pxor xmm1, xmm1
sub rsp, 8
movsd xmm0, cs:x; x
cvtsi2sd xmm1, edi; y
call _pow
addsd xmm0, xmm0
sqrtsd xmm0, xmm0; x
call _round
add rsp, 8
cvttsd2si eax, xmm0
retn | long long func0(int a1)
{
double v1; // xmm0_8
v1 = pow(10.0, (double)(a1 - 1));
return (unsigned int)(int)round(sqrt(v1 + v1));
} | func0:
ENDBR64
SUB EDI,0x1
PXOR XMM1,XMM1
SUB RSP,0x8
MOVSD XMM0,qword ptr [0x00102058]
CVTSI2SD XMM1,EDI
CALL 0x00101080
ADDSD XMM0,XMM0
SQRTSD XMM0,XMM0
CALL 0x00101070
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET | int func0(int param_1)
{
double dVar1;
dVar1 = pow(DAT_00102058,(double)(param_1 + -1));
dVar1 = round(SQRT(dVar1 + dVar1));
return (int)dVar1;
} |
6,852 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
| Pair *func0(int *arr, int size) {
Pair *dict =(Pair*) malloc((size / 2) * sizeof(Pair));
for (int i = 0; i < size; i += 2) {
dict[i / 2].key = arr[i];
dict[i / 2].value = arr[i + 1];
}
return dict;
}
| int main() {
int test1[] = {1, 5, 7, 10, 13, 5};
Pair *dict1 = func0(test1, 6);
assert((dict1[0].key == 1 && dict1[0].value == 5) && (dict1[1].key == 7 && dict1[1].value == 10) && (dict1[2].key == 13 && dict1[2].value == 5));
int test2[] = {1, 2, 3, 4, 5, 6};
Pair *dict2 = func0(test2, 6);
assert((dict2[0].key == 1 && dict2[0].value == 2) && (dict2[1].key == 3 && dict2[1].value == 4) && (dict2[2].key == 5 && dict2[2].value == 6));
int test3[] = {7, 8, 9, 10, 11, 12};
Pair *dict3 = func0(test3, 6);
assert((dict3[0].key == 7 && dict3[0].value == 8) && (dict3[1].key == 9 && dict3[1].value == 10) && (dict3[2].key == 11 && dict3[2].value == 12));
free(dict1);
free(dict2);
free(dict3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1258 <func0+0xaf>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,(%rdx)
mov -0xc(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0xc(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov (%rcx),%eax
mov %eax,0x4(%rdx)
addl $0x2,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11e3 <func0+0x3a>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov eax, [rbp+var_1C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_1258
loc_11E3:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx], eax
mov eax, [rbp+var_C]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
lea rcx, [rdx+rax]
mov eax, [rbp+var_C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rcx]
mov [rdx+4], eax
add [rbp+var_C], 2
loc_1258:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11E3
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v4; // [rsp+18h] [rbp-8h]
v4 = malloc(8LL * (a2 / 2));
for ( i = 0; i < a2; i += 2 )
{
v4[2 * (i / 2)] = *(_DWORD *)(4LL * i + a1);
v4[2 * (i / 2) + 1] = *(_DWORD *)(4 * (i + 1LL) + a1);
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101258
LAB_001011e3:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0xc]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RCX]
MOV dword ptr [RDX + 0x4],EAX
ADD dword ptr [RBP + -0xc],0x2
LAB_00101258:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011e3
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2)
{
void *pvVar1;
int local_14;
pvVar1 = malloc((long)(param_2 / 2) << 3);
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 2) {
*(int4 *)((long)(local_14 / 2) * 8 + (long)pvVar1) =
*(int4 *)((long)local_14 * 4 + param_1);
*(int4 *)((long)pvVar1 + (long)(local_14 / 2) * 8 + 4) =
*(int4 *)(((long)local_14 + 1) * 4 + param_1);
}
return pvVar1;
} |
6,853 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
| Pair *func0(int *arr, int size) {
Pair *dict =(Pair*) malloc((size / 2) * sizeof(Pair));
for (int i = 0; i < size; i += 2) {
dict[i / 2].key = arr[i];
dict[i / 2].value = arr[i + 1];
}
return dict;
}
| int main() {
int test1[] = {1, 5, 7, 10, 13, 5};
Pair *dict1 = func0(test1, 6);
assert((dict1[0].key == 1 && dict1[0].value == 5) && (dict1[1].key == 7 && dict1[1].value == 10) && (dict1[2].key == 13 && dict1[2].value == 5));
int test2[] = {1, 2, 3, 4, 5, 6};
Pair *dict2 = func0(test2, 6);
assert((dict2[0].key == 1 && dict2[0].value == 2) && (dict2[1].key == 3 && dict2[1].value == 4) && (dict2[2].key == 5 && dict2[2].value == 6));
int test3[] = {7, 8, 9, 10, 11, 12};
Pair *dict3 = func0(test3, 6);
assert((dict3[0].key == 7 && dict3[0].value == 8) && (dict3[1].key == 9 && dict3[1].value == 10) && (dict3[2].key == 11 && dict3[2].value == 12));
free(dict1);
free(dict2);
free(dict3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
mov %esi,%edi
shr $0x1f,%edi
add %esi,%edi
sar %edi
movslq %edi,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 11fa <func0+0x51>
mov $0x0,%ecx
mov %ecx,%edx
shr $0x1f,%edx
add %ecx,%edx
sar %edx
movslq %edx,%rdx
lea (%rax,%rdx,8),%rdx
mov (%rbx,%rcx,4),%esi
mov %esi,(%rdx)
mov 0x4(%rbx,%rcx,4),%esi
mov %esi,0x4(%rdx)
add $0x2,%rcx
cmp %ecx,%ebp
jg 11d6 <func0+0x2d>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, esi
mov edi, esi
shr edi, 1Fh
add edi, esi
sar edi, 1
movsxd rdi, edi
shl rdi, 3
call _malloc
test ebp, ebp
jle short loc_11FA
mov ecx, 0
loc_11D6:
mov edx, ecx
shr edx, 1Fh
add edx, ecx
sar edx, 1
movsxd rdx, edx
lea rdx, [rax+rdx*8]
mov esi, [rbx+rcx*4]
mov [rdx], esi
mov esi, [rbx+rcx*4+4]
mov [rdx+4], esi
add rcx, 2
cmp ebp, ecx
jg short loc_11D6
loc_11FA:
add rsp, 8
pop rbx
pop rbp
retn | long long func0(long long a1, int a2)
{
long long result; // rax
long long v3; // rcx
_DWORD *v4; // rdx
result = malloc(8LL * (a2 / 2));
if ( a2 > 0 )
{
v3 = 0LL;
do
{
v4 = (_DWORD *)(result + 8LL * ((int)v3 / 2));
*v4 = *(_DWORD *)(a1 + 4 * v3);
v4[1] = *(_DWORD *)(a1 + 4 * v3 + 4);
v3 += 2LL;
}
while ( a2 > (int)v3 );
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,ESI
MOV EDI,ESI
SHR EDI,0x1f
ADD EDI,ESI
SAR EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x3
CALL 0x001010b0
TEST EBP,EBP
JLE 0x001011fa
MOV ECX,0x0
LAB_001011d6:
MOV EDX,ECX
SHR EDX,0x1f
ADD EDX,ECX
SAR EDX,0x1
MOVSXD RDX,EDX
LEA RDX,[RAX + RDX*0x8]
MOV ESI,dword ptr [RBX + RCX*0x4]
MOV dword ptr [RDX],ESI
MOV ESI,dword ptr [RBX + RCX*0x4 + 0x4]
MOV dword ptr [RDX + 0x4],ESI
ADD RCX,0x2
CMP EBP,ECX
JG 0x001011d6
LAB_001011fa:
ADD RSP,0x8
POP RBX
POP RBP
RET | void func0(long param_1,int param_2)
{
int4 *puVar1;
void *pvVar2;
ulong uVar3;
pvVar2 = malloc((long)(param_2 / 2) << 3);
if (0 < param_2) {
uVar3 = 0;
do {
puVar1 = (int4 *)
((long)pvVar2 + (long)((int)(((uint)(uVar3 >> 0x1f) & 1) + (int)uVar3) >> 1) * 8);
*puVar1 = *(int4 *)(param_1 + uVar3 * 4);
puVar1[1] = *(int4 *)(param_1 + 4 + uVar3 * 4);
uVar3 = uVar3 + 2;
} while ((int)uVar3 < param_2);
}
return;
} |
6,854 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
| Pair *func0(int *arr, int size) {
Pair *dict =(Pair*) malloc((size / 2) * sizeof(Pair));
for (int i = 0; i < size; i += 2) {
dict[i / 2].key = arr[i];
dict[i / 2].value = arr[i + 1];
}
return dict;
}
| int main() {
int test1[] = {1, 5, 7, 10, 13, 5};
Pair *dict1 = func0(test1, 6);
assert((dict1[0].key == 1 && dict1[0].value == 5) && (dict1[1].key == 7 && dict1[1].value == 10) && (dict1[2].key == 13 && dict1[2].value == 5));
int test2[] = {1, 2, 3, 4, 5, 6};
Pair *dict2 = func0(test2, 6);
assert((dict2[0].key == 1 && dict2[0].value == 2) && (dict2[1].key == 3 && dict2[1].value == 4) && (dict2[2].key == 5 && dict2[2].value == 6));
int test3[] = {7, 8, 9, 10, 11, 12};
Pair *dict3 = func0(test3, 6);
assert((dict3[0].key == 7 && dict3[0].value == 8) && (dict3[1].key == 9 && dict3[1].value == 10) && (dict3[2].key == 11 && dict3[2].value == 12));
free(dict1);
free(dict2);
free(dict3);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
mov %esi,%edi
shr $0x1f,%edi
add %esi,%edi
sar %edi
sub $0x8,%rsp
movslq %edi,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 140f <func0+0x4f>
xor %edx,%edx
nopw 0x0(%rax,%rax,1)
mov %edx,%ecx
mov (%rbx,%rdx,4),%edi
sar %ecx
movslq %ecx,%rcx
lea (%rax,%rcx,8),%rcx
mov %edi,(%rcx)
mov 0x4(%rbx,%rdx,4),%edi
add $0x2,%rdx
mov %edi,0x4(%rcx)
cmp %edx,%ebp
jg 13f0 <func0+0x30>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
mov edi, esi
shr edi, 1Fh
add edi, esi
sar edi, 1
sub rsp, 8
movsxd rdi, edi
shl rdi, 3
call _malloc
test ebp, ebp
jle short loc_140F
xor edx, edx
nop word ptr [rax+rax+00h]
loc_13F0:
mov ecx, edx
mov esi, [rbx+rdx*4]
sar ecx, 1
movsxd rcx, ecx
lea rcx, [rax+rcx*8]
mov [rcx], esi
mov esi, [rbx+rdx*4+4]
add rdx, 2
mov [rcx+4], esi
cmp ebp, edx
jg short loc_13F0
loc_140F:
add rsp, 8
pop rbx
pop rbp
retn | long long func0(long long a1, int a2)
{
long long result; // rax
long long v4; // rdx
_DWORD *v5; // rcx
int v6; // esi
result = malloc(8LL * (a2 / 2));
if ( a2 > 0 )
{
v4 = 0LL;
do
{
v5 = (_DWORD *)(result + 8LL * ((int)v4 >> 1));
*v5 = *(_DWORD *)(a1 + 4 * v4);
v6 = *(_DWORD *)(a1 + 4 * v4 + 4);
v4 += 2LL;
v5[1] = v6;
}
while ( a2 > (int)v4 );
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
MOV EDI,ESI
SHR EDI,0x1f
ADD EDI,ESI
SAR EDI,0x1
SUB RSP,0x8
MOVSXD RDI,EDI
SHL RDI,0x3
CALL 0x001010b0
TEST EBP,EBP
JLE 0x0010140f
XOR EDX,EDX
NOP word ptr [RAX + RAX*0x1]
LAB_001013f0:
MOV ECX,EDX
MOV ESI,dword ptr [RBX + RDX*0x4]
SAR ECX,0x1
MOVSXD RCX,ECX
LEA RCX,[RAX + RCX*0x8]
MOV dword ptr [RCX],ESI
MOV ESI,dword ptr [RBX + RDX*0x4 + 0x4]
ADD RDX,0x2
MOV dword ptr [RCX + 0x4],ESI
CMP EBP,EDX
JG 0x001013f0
LAB_0010140f:
ADD RSP,0x8
POP RBX
POP RBP
RET | void func0(long param_1,int param_2)
{
int4 *puVar1;
long lVar2;
void *pvVar3;
long lVar4;
pvVar3 = malloc((long)(param_2 / 2) << 3);
if (0 < param_2) {
lVar4 = 0;
do {
puVar1 = (int4 *)((long)pvVar3 + (long)((int)lVar4 >> 1) * 8);
*puVar1 = *(int4 *)(param_1 + lVar4 * 4);
lVar2 = lVar4 * 4;
lVar4 = lVar4 + 2;
puVar1[1] = *(int4 *)(param_1 + 4 + lVar2);
} while ((int)lVar4 < param_2);
}
return;
} |
6,855 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
| Pair *func0(int *arr, int size) {
Pair *dict =(Pair*) malloc((size / 2) * sizeof(Pair));
for (int i = 0; i < size; i += 2) {
dict[i / 2].key = arr[i];
dict[i / 2].value = arr[i + 1];
}
return dict;
}
| int main() {
int test1[] = {1, 5, 7, 10, 13, 5};
Pair *dict1 = func0(test1, 6);
assert((dict1[0].key == 1 && dict1[0].value == 5) && (dict1[1].key == 7 && dict1[1].value == 10) && (dict1[2].key == 13 && dict1[2].value == 5));
int test2[] = {1, 2, 3, 4, 5, 6};
Pair *dict2 = func0(test2, 6);
assert((dict2[0].key == 1 && dict2[0].value == 2) && (dict2[1].key == 3 && dict2[1].value == 4) && (dict2[2].key == 5 && dict2[2].value == 6));
int test3[] = {7, 8, 9, 10, 11, 12};
Pair *dict3 = func0(test3, 6);
assert((dict3[0].key == 7 && dict3[0].value == 8) && (dict3[1].key == 9 && dict3[1].value == 10) && (dict3[2].key == 11 && dict3[2].value == 12));
free(dict1);
free(dict2);
free(dict3);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
mov %esi,%edi
shr $0x1f,%edi
add %esi,%edi
sar %edi
sub $0x8,%rsp
movslq %edi,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 13df <func0+0x4f>
xor %edx,%edx
nopw 0x0(%rax,%rax,1)
mov %edx,%ecx
mov (%rbx,%rdx,4),%edi
sar %ecx
movslq %ecx,%rcx
lea (%rax,%rcx,8),%rcx
mov %edi,(%rcx)
mov 0x4(%rbx,%rdx,4),%edi
add $0x2,%rdx
mov %edi,0x4(%rcx)
cmp %edx,%ebp
jg 13c0 <func0+0x30>
add $0x8,%rsp
pop %rbx
pop %rbp
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
push rbp
mov rbp, rdi
mov edi, esi
shr edi, 1Fh
push rbx
mov ebx, esi
add edi, esi
sar edi, 1
movsxd rdi, edi
sub rsp, 8
shl rdi, 3; size
call _malloc
test ebx, ebx
jle short loc_13C8
xor edx, edx
nop word ptr [rax+rax+00h]
loc_13B0:
mov ecx, edx
mov rdi, [rbp+rdx*4+0]
add rdx, 2
sar ecx, 1
movsxd rcx, ecx
mov [rax+rcx*8], rdi
cmp ebx, edx
jg short loc_13B0
loc_13C8:
add rsp, 8
pop rbx
pop rbp
retn | _QWORD * func0(long long a1, int a2)
{
_QWORD *result; // rax
long long v4; // rdx
int v5; // ecx
long long v6; // rdi
result = malloc(8LL * (a2 / 2));
if ( a2 > 0 )
{
v4 = 0LL;
do
{
v5 = v4;
v6 = *(_QWORD *)(a1 + 4 * v4);
v4 += 2LL;
result[v5 >> 1] = v6;
}
while ( a2 > (int)v4 );
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
MOV EDI,ESI
SHR EDI,0x1f
PUSH RBX
MOV EBX,ESI
ADD EDI,ESI
SAR EDI,0x1
MOVSXD RDI,EDI
SUB RSP,0x8
SHL RDI,0x3
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001013c8
XOR EDX,EDX
NOP word ptr [RAX + RAX*0x1]
LAB_001013b0:
MOV ECX,EDX
MOV RDI,qword ptr [RBP + RDX*0x4]
ADD RDX,0x2
SAR ECX,0x1
MOVSXD RCX,ECX
MOV qword ptr [RAX + RCX*0x8],RDI
CMP EBX,EDX
JG 0x001013b0
LAB_001013c8:
ADD RSP,0x8
POP RBX
POP RBP
RET | void func0(long param_1,int param_2)
{
void *pvVar1;
long lVar2;
long lVar3;
pvVar1 = malloc((long)(param_2 / 2) << 3);
if (0 < param_2) {
lVar2 = 0;
do {
lVar3 = lVar2 + 2;
*(int8 *)((long)pvVar1 + (long)((int)lVar2 >> 1) * 8) =
*(int8 *)(param_1 + lVar2 * 4);
lVar2 = lVar3;
} while ((int)lVar3 < param_2);
}
return;
} |
6,856 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(const char *s) {
int n = strlen(s);
for (int i = 1; i < n; i++) {
if (s[i] != s[0]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("python") == false);
assert(func0("aaa") == true);
assert(func0("data") == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x1,-0x8(%rbp)
jmp 11b7 <func0+0x4e>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp %al,%dl
je 11b3 <func0+0x4a>
mov $0x0,%eax
jmp 11c4 <func0+0x5b>
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 1191 <func0+0x28>
mov $0x1,%eax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_8], 1
jmp short loc_11B7
loc_1191:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov rax, [rbp+s]
movzx eax, byte ptr [rax]
cmp dl, al
jz short loc_11B3
mov eax, 0
jmp short locret_11C4
loc_11B3:
add [rbp+var_8], 1
loc_11B7:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jl short loc_1191
mov eax, 1
locret_11C4:
leave
retn | long long func0(const char *a1)
{
int i; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
v3 = strlen(a1);
for ( i = 1; i < v3; ++i )
{
if ( a1[i] != *a1 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x8],0x1
JMP 0x001011b7
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JZ 0x001011b3
MOV EAX,0x0
JMP 0x001011c4
LAB_001011b3:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011b7:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x00101191
MOV EAX,0x1
LAB_001011c4:
LEAVE
RET | int8 func0(char *param_1)
{
size_t sVar1;
int local_10;
sVar1 = strlen(param_1);
local_10 = 1;
while( true ) {
if ((int)sVar1 <= local_10) {
return 1;
}
if (param_1[local_10] != *param_1) break;
local_10 = local_10 + 1;
}
return 0;
} |
6,857 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(const char *s) {
int n = strlen(s);
for (int i = 1; i < n; i++) {
if (s[i] != s[0]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("python") == false);
assert(func0("aaa") == true);
assert(func0("data") == false);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rsi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp $0x1,%ecx
jle 118c <func0+0x43>
movzbl (%rsi),%edx
lea 0x1(%rsi),%rax
lea -0x2(%rcx),%ecx
lea 0x2(%rsi,%rcx,1),%rcx
cmp %dl,(%rax)
jne 1192 <func0+0x49>
add $0x1,%rax
cmp %rcx,%rax
jne 1179 <func0+0x30>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
cmp eax, 1
jle short loc_119E
movzx ecx, byte ptr [rbx]
lea rdx, [rbx+1]
lea eax, [rax-2]
lea rax, [rbx+rax+2]
loc_118A:
cmp [rdx], cl
jnz short loc_11A5
add rdx, 1
cmp rdx, rax
jnz short loc_118A
mov eax, 1
jmp short loc_11AA
loc_119E:
mov eax, 1
jmp short loc_11AA
loc_11A5:
mov eax, 0
loc_11AA:
pop rbx
retn | long long func0(_BYTE *a1)
{
int v1; // eax
_BYTE *v2; // rdx
long long v3; // rax
v1 = strlen();
if ( v1 <= 1 )
return 1LL;
v2 = a1 + 1;
v3 = (long long)&a1[v1 - 2 + 2];
while ( *v2 == *a1 )
{
if ( ++v2 == (_BYTE *)v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
CMP EAX,0x1
JLE 0x0010119e
MOVZX ECX,byte ptr [RBX]
LEA RDX,[RBX + 0x1]
LEA EAX,[RAX + -0x2]
LEA RAX,[RBX + RAX*0x1 + 0x2]
LAB_0010118a:
CMP byte ptr [RDX],CL
JNZ 0x001011a5
ADD RDX,0x1
CMP RDX,RAX
JNZ 0x0010118a
MOV EAX,0x1
JMP 0x001011aa
LAB_0010119e:
MOV EAX,0x1
JMP 0x001011aa
LAB_001011a5:
MOV EAX,0x0
LAB_001011aa:
POP RBX
RET | int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
sVar1 = strlen(param_1);
if (1 < (int)sVar1) {
pcVar2 = param_1 + 1;
do {
if (*pcVar2 != *param_1) {
return 0;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != param_1 + (ulong)((int)sVar1 - 2) + 2);
}
return 1;
} |
6,858 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(const char *s) {
int n = strlen(s);
for (int i = 1; i < n; i++) {
if (s[i] != s[0]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("python") == false);
assert(func0("aaa") == true);
assert(func0("data") == false);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
cmp $0x1,%eax
jle 1250 <func0+0x40>
sub $0x2,%eax
movzbl (%rbx),%ecx
lea 0x1(%rbx),%rdx
lea 0x2(%rbx,%rax,1),%rax
jmp 1241 <func0+0x31>
nopl 0x0(%rax,%rax,1)
add $0x1,%rdx
cmp %rax,%rdx
je 1250 <func0+0x40>
cmp %cl,(%rdx)
je 1238 <func0+0x28>
xor %eax,%eax
pop %rbx
retq
nopl 0x0(%rax)
mov $0x1,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
cmp eax, 1
jle short loc_1250
sub eax, 2
movzx ecx, byte ptr [rbx]
lea rdx, [rbx+1]
lea rax, [rbx+rax+2]
jmp short loc_1241
loc_1238:
add rdx, 1
cmp rdx, rax
jz short loc_1250
loc_1241:
cmp [rdx], cl
jz short loc_1238
xor eax, eax
pop rbx
retn
loc_1250:
mov eax, 1
pop rbx
retn | long long func0(_BYTE *a1)
{
int v1; // eax
_BYTE *v2; // rdx
long long v3; // rax
v1 = strlen();
if ( v1 <= 1 )
return 1LL;
v2 = a1 + 1;
v3 = (long long)&a1[v1 - 2 + 2];
while ( *v2 == *a1 )
{
if ( ++v2 == (_BYTE *)v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
CMP EAX,0x1
JLE 0x00101250
SUB EAX,0x2
MOVZX ECX,byte ptr [RBX]
LEA RDX,[RBX + 0x1]
LEA RAX,[RBX + RAX*0x1 + 0x2]
JMP 0x00101241
LAB_00101238:
ADD RDX,0x1
CMP RDX,RAX
JZ 0x00101250
LAB_00101241:
CMP byte ptr [RDX],CL
JZ 0x00101238
XOR EAX,EAX
POP RBX
RET
LAB_00101250:
MOV EAX,0x1
POP RBX
RET | int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
sVar1 = strlen(param_1);
if (1 < (int)sVar1) {
pcVar2 = param_1 + 1;
do {
if (*pcVar2 != *param_1) {
return 0;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != param_1 + (ulong)((int)sVar1 - 2) + 2);
}
return 1;
} |
6,859 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(const char *s) {
int n = strlen(s);
for (int i = 1; i < n; i++) {
if (s[i] != s[0]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("python") == false);
assert(func0("aaa") == true);
assert(func0("data") == false);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
cmp $0x1,%eax
jle 1250 <func0+0x40>
sub $0x2,%eax
movzbl (%rbx),%ecx
lea 0x1(%rbx),%rdx
lea 0x2(%rbx,%rax,1),%rax
jmp 1241 <func0+0x31>
nopl 0x0(%rax,%rax,1)
add $0x1,%rdx
cmp %rax,%rdx
je 1250 <func0+0x40>
cmp %cl,(%rdx)
je 1238 <func0+0x28>
xor %eax,%eax
pop %rbx
retq
nopl 0x0(%rax)
mov $0x1,%eax
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
cmp eax, 1
jle short loc_1250
sub eax, 2
movzx ecx, byte ptr [rbx]
lea rdx, [rbx+1]
lea rax, [rbx+rax+2]
jmp short loc_1241
loc_1238:
add rdx, 1
cmp rdx, rax
jz short loc_1250
loc_1241:
cmp [rdx], cl
jz short loc_1238
xor eax, eax
pop rbx
retn
loc_1250:
mov eax, 1
pop rbx
retn | long long func0(const char *a1)
{
int v1; // eax
_BYTE *v2; // rdx
long long v3; // rax
v1 = strlen(a1);
if ( v1 <= 1 )
return 1LL;
v2 = a1 + 1;
v3 = (long long)&a1[v1 - 2 + 2];
while ( *v2 == *a1 )
{
if ( ++v2 == (_BYTE *)v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
CMP EAX,0x1
JLE 0x00101250
SUB EAX,0x2
MOVZX ECX,byte ptr [RBX]
LEA RDX,[RBX + 0x1]
LEA RAX,[RBX + RAX*0x1 + 0x2]
JMP 0x00101241
LAB_00101238:
ADD RDX,0x1
CMP RDX,RAX
JZ 0x00101250
LAB_00101241:
CMP byte ptr [RDX],CL
JZ 0x00101238
XOR EAX,EAX
POP RBX
RET
LAB_00101250:
MOV EAX,0x1
POP RBX
RET | int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
sVar1 = strlen(param_1);
if (1 < (int)sVar1) {
pcVar2 = param_1 + 1;
do {
if (*pcVar2 != *param_1) {
return 0;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != param_1 + (ulong)((int)sVar1 - 2) + 2);
}
return 1;
} |
6,860 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double side) {
double area = sqrt(3) * (side * side);
return area;
}
| int main() {
assert(func0(3) == 15.588457268119894);
assert(func0(20) == 692.8203230275509);
assert(func0(10) == 173.20508075688772);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm0
movapd %xmm0,%xmm1
mulsd %xmm0,%xmm1
movsd 0xf45(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd xmm0, [rbp+var_18]
movapd xmm1, xmm0
mulsd xmm1, xmm0
movsd xmm0, cs:qword_2090
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 1.732050807568877 * (a1 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM0,qword ptr [RBP + -0x18]
MOVAPD XMM1,XMM0
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102090]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1)
{
return DAT_00102090 * param_1 * param_1;
} |
6,861 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double side) {
double area = sqrt(3) * (side * side);
return area;
}
| int main() {
assert(func0(3) == 15.588457268119894);
assert(func0(20) == 692.8203230275509);
assert(func0(10) == 173.20508075688772);
return 0;
}
| O1 | c | func0:
endbr64
mulsd %xmm0,%xmm0
mulsd 0xecf(%rip),%xmm0
retq
| func0:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * a1 * 1.732050807568877;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * param_1 * _DAT_00102008;
} |
6,862 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double side) {
double area = sqrt(3) * (side * side);
return area;
}
| int main() {
assert(func0(3) == 15.588457268119894);
assert(func0(20) == 692.8203230275509);
assert(func0(10) == 173.20508075688772);
return 0;
}
| O2 | c | func0:
endbr64
mulsd %xmm0,%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * a1 * 1.732050807568877;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * param_1 * _DAT_00102008;
} |
6,863 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double side) {
double area = sqrt(3) * (side * side);
return area;
}
| int main() {
assert(func0(3) == 15.588457268119894);
assert(func0(20) == 692.8203230275509);
assert(func0(10) == 173.20508075688772);
return 0;
}
| O3 | c | func0:
endbr64
mulsd %xmm0,%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * a1 * 1.732050807568877;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * param_1 * _DAT_00102008;
} |
6,864 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int list1[], int size, int m, int n) {
int new_size = m + (size - n);
int* result = (int*)malloc(new_size * sizeof(int));
for(int i = 0; i < m; i++) {
result[i] = list1[size - m + i];
}
for(int i = 0; i < (size - n); i++) {
result[m + i] = list1[i];
}
return result;
}
| int main() {
int list1a[] = {1,2,3,4,5,6,7,8,9,10};
int expected1[] = {8,9,10,1,2,3,4,5,6};
int* result1 = func0(list1a, 10, 3, 4);
assert(memcmp(result1, expected1, 9 * sizeof(int)) == 0);
free(result1);
int list1b[] = {1,2,3,4,5,6,7,8,9,10};
int expected2[] = {9,10,1,2,3,4,5,6,7,8};
int* result2 = func0(list1b, 10, 2, 2);
assert(memcmp(result2, expected2, 10 * sizeof(int)) == 0);
free(result2);
int list1c[] = {1,2,3,4,5,6,7,8,9,10};
int expected3[] = {6,7,8,9,10,1,2,3,4,5,6,7,8};
int* result3 = func0(list1c, 10, 5, 2);
assert(memcmp(result3, expected3, 13 * sizeof(int)) == 0);
free(result3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %ecx,-0x34(%rbp)
mov -0x2c(%rbp),%eax
sub -0x34(%rbp),%eax
mov %eax,%edx
mov -0x30(%rbp),%eax
add %edx,%eax
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
jmp 124b <func0+0x82>
mov -0x2c(%rbp),%eax
sub -0x30(%rbp),%eax
mov %eax,%edx
mov -0x14(%rbp),%eax
add %edx,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x14(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 1210 <func0+0x47>
movl $0x0,-0x10(%rbp)
jmp 1292 <func0+0xc9>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0x30(%rbp),%ecx
mov -0x10(%rbp),%edx
add %ecx,%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x8(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x10(%rbp)
mov -0x2c(%rbp),%eax
sub -0x34(%rbp),%eax
cmp %eax,-0x10(%rbp)
jl 125c <func0+0x93>
mov -0x8(%rbp),%rax
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov [rbp+var_34], ecx
mov eax, [rbp+var_2C]
sub eax, [rbp+var_34]
mov edx, eax
mov eax, [rbp+var_30]
add eax, edx
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_14], 0
jmp short loc_124B
loc_1210:
mov eax, [rbp+var_2C]
sub eax, [rbp+var_30]
mov edx, eax
mov eax, [rbp+var_14]
add eax, edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_14]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_8]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_14], 1
loc_124B:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_30]
jl short loc_1210
mov [rbp+var_10], 0
jmp short loc_1292
loc_125C:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov ecx, [rbp+var_30]
mov edx, [rbp+var_10]
add edx, ecx
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_8]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_10], 1
loc_1292:
mov eax, [rbp+var_2C]
sub eax, [rbp+var_34]
cmp [rbp+var_10], eax
jl short loc_125C
mov rax, [rbp+var_8]
leave
retn | _DWORD * func0(long long a1, int a2, int a3, int a4)
{
int i; // [rsp+2Ch] [rbp-14h]
int j; // [rsp+30h] [rbp-10h]
_DWORD *v9; // [rsp+38h] [rbp-8h]
v9 = malloc(4LL * (a2 - a4 + a3));
for ( i = 0; i < a3; ++i )
v9[i] = *(_DWORD *)(4LL * (a2 - a3 + i) + a1);
for ( j = 0; j < a2 - a4; ++j )
v9[a3 + j] = *(_DWORD *)(4LL * j + a1);
return v9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV dword ptr [RBP + -0x34],ECX
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,dword ptr [RBP + -0x34]
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010124b
LAB_00101210:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,dword ptr [RBP + -0x30]
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x14],0x1
LAB_0010124b:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x00101210
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101292
LAB_0010125c:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV ECX,dword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x10]
ADD EDX,ECX
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x10],0x1
LAB_00101292:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,dword ptr [RBP + -0x34]
CMP dword ptr [RBP + -0x10],EAX
JL 0x0010125c
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | void * func0(long param_1,int param_2,int param_3,int param_4)
{
void *pvVar1;
int4 local_1c;
int4 local_18;
pvVar1 = malloc((long)(param_3 + (param_2 - param_4)) << 2);
for (local_1c = 0; local_1c < param_3; local_1c = local_1c + 1) {
*(int4 *)((long)pvVar1 + (long)local_1c * 4) =
*(int4 *)(param_1 + (long)(local_1c + (param_2 - param_3)) * 4);
}
for (local_18 = 0; local_18 < param_2 - param_4; local_18 = local_18 + 1) {
*(int4 *)((long)pvVar1 + (long)(local_18 + param_3) * 4) =
*(int4 *)(param_1 + (long)local_18 * 4);
}
return pvVar1;
} |
6,865 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int list1[], int size, int m, int n) {
int new_size = m + (size - n);
int* result = (int*)malloc(new_size * sizeof(int));
for(int i = 0; i < m; i++) {
result[i] = list1[size - m + i];
}
for(int i = 0; i < (size - n); i++) {
result[m + i] = list1[i];
}
return result;
}
| int main() {
int list1a[] = {1,2,3,4,5,6,7,8,9,10};
int expected1[] = {8,9,10,1,2,3,4,5,6};
int* result1 = func0(list1a, 10, 3, 4);
assert(memcmp(result1, expected1, 9 * sizeof(int)) == 0);
free(result1);
int list1b[] = {1,2,3,4,5,6,7,8,9,10};
int expected2[] = {9,10,1,2,3,4,5,6,7,8};
int* result2 = func0(list1b, 10, 2, 2);
assert(memcmp(result2, expected2, 10 * sizeof(int)) == 0);
free(result2);
int list1c[] = {1,2,3,4,5,6,7,8,9,10};
int expected3[] = {6,7,8,9,10,1,2,3,4,5,6,7,8};
int* result3 = func0(list1c, 10, 5, 2);
assert(memcmp(result3, expected3, 13 * sizeof(int)) == 0);
free(result3);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%r13d
mov %edx,%ebp
mov %esi,%r12d
sub %ecx,%r12d
lea (%r12,%rdx,1),%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 1220 <func0+0x57>
lea -0x1(%rbp),%edi
movslq %ebp,%rdx
movslq %r13d,%r13
sub %rdx,%r13
lea (%rbx,%r13,4),%rsi
mov $0x0,%edx
mov (%rsi,%rdx,4),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rdi,%rcx
jne 120e <func0+0x45>
test %r12d,%r12d
jle 1248 <func0+0x7f>
lea -0x1(%r12),%edi
movslq %ebp,%rbp
lea (%rax,%rbp,4),%rsi
mov $0x0,%edx
mov (%rbx,%rdx,4),%ecx
mov %ecx,(%rsi,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rcx,%rdi
jne 1236 <func0+0x6d>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
| func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov r13d, esi
mov ebp, edx
mov r12d, esi
sub r12d, ecx
lea edi, [r12+rdx]
movsxd rdi, edi
shl rdi, 2
call _malloc
mov rcx, rax
test ebp, ebp
jle short loc_121F
mov edi, ebp
movsxd rax, ebp
movsxd r13, r13d
sub r13, rax
lea rsi, [rbx+r13*4]
mov eax, 0
loc_1210:
mov edx, [rsi+rax*4]
mov [rcx+rax*4], edx
add rax, 1
cmp rax, rdi
jnz short loc_1210
loc_121F:
test r12d, r12d
jle short loc_1242
mov esi, r12d
movsxd rbp, ebp
lea rdi, [rcx+rbp*4]
mov eax, 0
loc_1233:
mov edx, [rbx+rax*4]
mov [rdi+rax*4], edx
add rax, 1
cmp rax, rsi
jnz short loc_1233
loc_1242:
mov rax, rcx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | long long func0(long long a1, int a2, int a3, int a4)
{
int v5; // r12d
long long v6; // rcx
long long v7; // rax
long long i; // rax
v5 = a2 - a4;
v6 = malloc(4LL * (a2 - a4 + a3));
if ( a3 > 0 )
{
v7 = 0LL;
do
{
*(_DWORD *)(v6 + 4 * v7) = *(_DWORD *)(a1 + 4 * (a2 - (long long)a3) + 4 * v7);
++v7;
}
while ( v7 != a3 );
}
if ( v5 > 0 )
{
for ( i = 0LL; i != v5; ++i )
*(_DWORD *)(v6 + 4LL * a3 + 4 * i) = *(_DWORD *)(a1 + 4 * i);
}
return v6;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV R13D,ESI
MOV EBP,EDX
MOV R12D,ESI
SUB R12D,ECX
LEA EDI,[R12 + RDX*0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV RCX,RAX
TEST EBP,EBP
JLE 0x0010121f
MOV EDI,EBP
MOVSXD RAX,EBP
MOVSXD R13,R13D
SUB R13,RAX
LEA RSI,[RBX + R13*0x4]
MOV EAX,0x0
LAB_00101210:
MOV EDX,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RCX + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RDI
JNZ 0x00101210
LAB_0010121f:
TEST R12D,R12D
JLE 0x00101242
MOV ESI,R12D
MOVSXD RBP,EBP
LEA RDI,[RCX + RBP*0x4]
MOV EAX,0x0
LAB_00101233:
MOV EDX,dword ptr [RBX + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101233
LAB_00101242:
MOV RAX,RCX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | void * func0(long param_1,int param_2,uint param_3,int param_4)
{
void *pvVar1;
ulong uVar2;
uint uVar3;
uVar3 = param_2 - param_4;
pvVar1 = malloc((long)(int)(uVar3 + param_3) << 2);
if (0 < (int)param_3) {
uVar2 = 0;
do {
*(int4 *)((long)pvVar1 + uVar2 * 4) =
*(int4 *)(param_1 + ((long)param_2 - (long)(int)param_3) * 4 + uVar2 * 4);
uVar2 = uVar2 + 1;
} while (uVar2 != param_3);
}
if (0 < (int)uVar3) {
uVar2 = 0;
do {
*(int4 *)((long)pvVar1 + uVar2 * 4 + (long)(int)param_3 * 4) =
*(int4 *)(param_1 + uVar2 * 4);
uVar2 = uVar2 + 1;
} while (uVar2 != uVar3);
}
return pvVar1;
} |
6,866 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int list1[], int size, int m, int n) {
int new_size = m + (size - n);
int* result = (int*)malloc(new_size * sizeof(int));
for(int i = 0; i < m; i++) {
result[i] = list1[size - m + i];
}
for(int i = 0; i < (size - n); i++) {
result[m + i] = list1[i];
}
return result;
}
| int main() {
int list1a[] = {1,2,3,4,5,6,7,8,9,10};
int expected1[] = {8,9,10,1,2,3,4,5,6};
int* result1 = func0(list1a, 10, 3, 4);
assert(memcmp(result1, expected1, 9 * sizeof(int)) == 0);
free(result1);
int list1b[] = {1,2,3,4,5,6,7,8,9,10};
int expected2[] = {9,10,1,2,3,4,5,6,7,8};
int* result2 = func0(list1b, 10, 2, 2);
assert(memcmp(result2, expected2, 10 * sizeof(int)) == 0);
free(result2);
int list1c[] = {1,2,3,4,5,6,7,8,9,10};
int expected3[] = {6,7,8,9,10,1,2,3,4,5,6,7,8};
int* result3 = func0(list1c, 10, 5, 2);
assert(memcmp(result3, expected3, 13 * sizeof(int)) == 0);
free(result3);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %esi,%r13d
push %r12
sub %ecx,%r13d
mov %esi,%r12d
push %rbp
movslq %edx,%rbp
push %rbx
mov %rdi,%rbx
lea 0x0(%r13,%rbp,1),%edi
movslq %edi,%rdi
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 156a <func0+0x5a>
sub %ebp,%r12d
lea -0x1(%rbp),%edi
xor %ecx,%ecx
movslq %r12d,%r12
lea (%rbx,%r12,4),%rdx
nopl 0x0(%rax)
mov (%rdx,%rcx,4),%esi
mov %esi,(%rax,%rcx,4)
mov %rcx,%rsi
add $0x1,%rcx
cmp %rsi,%rdi
jne 1558 <func0+0x48>
test %r13d,%r13d
jle 1592 <func0+0x82>
lea -0x1(%r13),%edi
lea (%rax,%rbp,4),%rsi
xor %edx,%edx
nopl 0x0(%rax)
mov (%rbx,%rdx,4),%ecx
mov %ecx,(%rsi,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp %rdi,%rcx
jne 1580 <func0+0x70>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl (%rax)
| func0:
endbr64
push r14
push r13
mov r13d, esi
push r12
sub r13d, ecx
mov r12, rdi
push rbp
mov ebp, esi
push rbx
movsxd rbx, edx
lea edi, [r13+rbx+0]
movsxd rdi, edi
shl rdi, 2
call _malloc
mov r14, rax
test ebx, ebx
jle short loc_157A
sub ebp, ebx
movsxd rdx, ebx
mov rdi, rax
movsxd rbp, ebp
shl rdx, 2
lea rsi, [r12+rbp*4]
call _memcpy
loc_157A:
test r13d, r13d
jle short loc_1592
movsxd rdx, r13d
lea rdi, [r14+rbx*4]
mov rsi, r12
shl rdx, 2
call _memcpy
loc_1592:
pop rbx
mov rax, r14
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, int a2, int a3, int a4)
{
int v4; // r13d
long long v5; // rbx
long long v6; // rax
long long v7; // r14
v4 = a2 - a4;
v5 = a3;
v6 = malloc(4LL * (a2 - a4 + a3));
v7 = v6;
if ( (int)v5 > 0 )
memcpy(v6, a1 + 4LL * (a2 - (int)v5), 4LL * (int)v5);
if ( v4 > 0 )
memcpy(v7 + 4 * v5, a1, 4LL * v4);
return v7;
} | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13D,ESI
PUSH R12
SUB R13D,ECX
MOV R12,RDI
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOVSXD RBX,EDX
LEA EDI,[R13 + RBX*0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV R14,RAX
TEST EBX,EBX
JLE 0x0010157a
SUB EBP,EBX
MOVSXD RDX,EBX
MOV RDI,RAX
MOVSXD RBP,EBP
SHL RDX,0x2
LEA RSI,[R12 + RBP*0x4]
CALL 0x001010c0
LAB_0010157a:
TEST R13D,R13D
JLE 0x00101592
MOVSXD RDX,R13D
LEA RDI,[R14 + RBX*0x4]
MOV RSI,R12
SHL RDX,0x2
CALL 0x001010c0
LAB_00101592:
POP RBX
MOV RAX,R14
POP RBP
POP R12
POP R13
POP R14
RET | void * func0(void *param_1,int param_2,int param_3,int param_4)
{
void *__dest;
param_4 = param_2 - param_4;
__dest = malloc((long)(param_4 + param_3) << 2);
if (0 < param_3) {
memcpy(__dest,(void *)((long)param_1 + (long)(param_2 - param_3) * 4),(long)param_3 << 2);
}
if (0 < param_4) {
memcpy((void *)((long)__dest + (long)param_3 * 4),param_1,(long)param_4 << 2);
}
return __dest;
} |
6,867 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int list1[], int size, int m, int n) {
int new_size = m + (size - n);
int* result = (int*)malloc(new_size * sizeof(int));
for(int i = 0; i < m; i++) {
result[i] = list1[size - m + i];
}
for(int i = 0; i < (size - n); i++) {
result[m + i] = list1[i];
}
return result;
}
| int main() {
int list1a[] = {1,2,3,4,5,6,7,8,9,10};
int expected1[] = {8,9,10,1,2,3,4,5,6};
int* result1 = func0(list1a, 10, 3, 4);
assert(memcmp(result1, expected1, 9 * sizeof(int)) == 0);
free(result1);
int list1b[] = {1,2,3,4,5,6,7,8,9,10};
int expected2[] = {9,10,1,2,3,4,5,6,7,8};
int* result2 = func0(list1b, 10, 2, 2);
assert(memcmp(result2, expected2, 10 * sizeof(int)) == 0);
free(result2);
int list1c[] = {1,2,3,4,5,6,7,8,9,10};
int expected3[] = {6,7,8,9,10,1,2,3,4,5,6,7,8};
int* result3 = func0(list1c, 10, 5, 2);
assert(memcmp(result3, expected3, 13 * sizeof(int)) == 0);
free(result3);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r13
mov %esi,%r13d
push %r12
sub %ecx,%r13d
mov %rdi,%r12
push %rbp
mov %esi,%ebp
push %rbx
movslq %edx,%rbx
lea 0x0(%r13,%rbx,1),%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r14
test %ebx,%ebx
jle 151e <func0+0x4e>
sub %ebx,%ebp
lea -0x1(%rbx),%eax
mov %r14,%rdi
movslq %ebp,%rbp
lea 0x4(,%rax,4),%rdx
lea (%r12,%rbp,4),%rsi
callq 10c0 <memcpy@plt>
test %r13d,%r13d
jle 153b <func0+0x6b>
lea -0x1(%r13),%eax
lea (%r14,%rbx,4),%rdi
mov %r12,%rsi
lea 0x4(,%rax,4),%rdx
callq 10c0 <memcpy@plt>
pop %rbx
mov %r14,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
push r14
mov r14d, esi
sub r14d, ecx
push r13
mov r13, rdi
push r12
lea edi, [r14+rdx]
push rbp
movsxd rdi, edi
mov ebp, esi
push rbx
shl rdi, 2; size
mov ebx, edx
call _malloc
mov r12, rax
test ebx, ebx
jle short loc_1508
sub ebp, ebx
mov edx, ebx
mov rdi, rax; dest
movsxd rbp, ebp
shl rdx, 2; n
lea rsi, [r13+rbp*4+0]; src
call _memcpy
loc_1508:
test r14d, r14d
jle short loc_1523
movsxd rbx, ebx
mov edx, r14d
mov rsi, r13; src
lea rdi, [r12+rbx*4]; dest
shl rdx, 2; n
call _memcpy
loc_1523:
pop rbx
mov rax, r12
pop rbp
pop r12
pop r13
pop r14
retn | char * func0(char *src, int a2, int a3, int a4)
{
int v4; // r14d
char *v6; // rax
char *v7; // r12
v4 = a2 - a4;
v6 = (char *)malloc(4LL * (a2 - a4 + a3));
v7 = v6;
if ( a3 > 0 )
memcpy(v6, &src[4 * (a2 - a3)], 4LL * (unsigned int)a3);
if ( v4 > 0 )
memcpy(&v7[4 * a3], src, 4LL * (unsigned int)v4);
return v7;
} | func0:
ENDBR64
PUSH R14
MOV R14D,ESI
SUB R14D,ECX
PUSH R13
MOV R13,RDI
PUSH R12
LEA EDI,[R14 + RDX*0x1]
PUSH RBP
MOVSXD RDI,EDI
MOV EBP,ESI
PUSH RBX
SHL RDI,0x2
MOV EBX,EDX
CALL 0x001010d0
MOV R12,RAX
TEST EBX,EBX
JLE 0x00101508
SUB EBP,EBX
MOV EDX,EBX
MOV RDI,RAX
MOVSXD RBP,EBP
SHL RDX,0x2
LEA RSI,[R13 + RBP*0x4]
CALL 0x001010c0
LAB_00101508:
TEST R14D,R14D
JLE 0x00101523
MOVSXD RBX,EBX
MOV EDX,R14D
MOV RSI,R13
LEA RDI,[R12 + RBX*0x4]
SHL RDX,0x2
CALL 0x001010c0
LAB_00101523:
POP RBX
MOV RAX,R12
POP RBP
POP R12
POP R13
POP R14
RET | void * func0(void *param_1,int param_2,uint param_3,int param_4)
{
void *__dest;
uint uVar1;
uVar1 = param_2 - param_4;
__dest = malloc((long)(int)(uVar1 + param_3) << 2);
if (0 < (int)param_3) {
memcpy(__dest,(void *)((long)param_1 + (long)(int)(param_2 - param_3) * 4),(ulong)param_3 << 2);
}
if (0 < (int)uVar1) {
memcpy((void *)((long)__dest + (long)(int)param_3 * 4),param_1,(ulong)uVar1 << 2);
}
return __dest;
} |
6,868 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int *test_tup, int size) {
for (int i = 0; i < size; i++) {
if (test_tup[i] == 0) {
return true;
}
}
return false;
}
| int main() {
int arr1[] = {10, 4, 5, 6, 0}; // 0 is used to represent None
int arr2[] = {7, 8, 9, 11, 14};
int arr3[] = {1, 2, 3, 4, 0}; // 0 is used to represent None
assert(func0(arr1, 5) == true);
assert(func0(arr2, 5) == false);
assert(func0(arr3, 5) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a6 <func0+0x3d>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jne 11a2 <func0+0x39>
mov $0x1,%eax
jmp 11b3 <func0+0x4a>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1181 <func0+0x18>
mov $0x0,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11A6
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
jnz short loc_11A2
mov eax, 1
jmp short loc_11B3
loc_11A2:
add [rbp+var_4], 1
loc_11A6:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1181
mov eax, 0
loc_11B3:
pop rbp
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( !*(_DWORD *)(4LL * i + a1) )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a6
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x001011a2
MOV EAX,0x1
JMP 0x001011b3
LAB_001011a2:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011a6:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101181
MOV EAX,0x0
LAB_001011b3:
POP RBP
RET | int8 func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 0;
}
if (*(int *)(param_1 + (long)local_c * 4) == 0) break;
local_c = local_c + 1;
}
return 1;
} |
6,869 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int *test_tup, int size) {
for (int i = 0; i < size; i++) {
if (test_tup[i] == 0) {
return true;
}
}
return false;
}
| int main() {
int arr1[] = {10, 4, 5, 6, 0}; // 0 is used to represent None
int arr2[] = {7, 8, 9, 11, 14};
int arr3[] = {1, 2, 3, 4, 0}; // 0 is used to represent None
assert(func0(arr1, 5) == true);
assert(func0(arr2, 5) == false);
assert(func0(arr3, 5) == true);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1190 <func0+0x27>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
cmpl $0x0,(%rax)
je 1196 <func0+0x2d>
add $0x4,%rax
cmp %rdx,%rax
jne 117c <func0+0x13>
mov $0x0,%eax
retq
mov $0x0,%eax
retq
mov $0x1,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_1190
mov rax, rdi
lea edx, [rsi-1]
lea rdx, [rdi+rdx*4+4]
loc_117C:
cmp dword ptr [rax], 0
jz short loc_1196
add rax, 4
cmp rax, rdx
jnz short loc_117C
mov eax, 0
retn
loc_1190:
mov eax, 0
retn
loc_1196:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
if ( a2 <= 0 )
return 0LL;
v2 = a1;
while ( *v2 )
{
if ( ++v2 == &a1[a2 - 1 + 1] )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RDX,[RDI + RDX*0x4 + 0x4]
LAB_0010117c:
CMP dword ptr [RAX],0x0
JZ 0x00101196
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x0010117c
MOV EAX,0x0
RET
LAB_00101190:
MOV EAX,0x0
RET
LAB_00101196:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2)
{
int *piVar1;
if (param_2 < 1) {
return 0;
}
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*param_1 == 0) {
return 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return 0;
} |
6,870 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int *test_tup, int size) {
for (int i = 0; i < size; i++) {
if (test_tup[i] == 0) {
return true;
}
}
return false;
}
| int main() {
int arr1[] = {10, 4, 5, 6, 0}; // 0 is used to represent None
int arr2[] = {7, 8, 9, 11, 14};
int arr3[] = {1, 2, 3, 4, 0}; // 0 is used to represent None
assert(func0(arr1, 5) == true);
assert(func0(arr2, 5) == false);
assert(func0(arr3, 5) == true);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
mov (%rdi),%edx
test %edx,%edx
jne 1158 <func0+0x18>
mov $0x1,%eax
retq
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1310
lea eax, [rsi-1]
lea rax, [rdi+rax*4+4]
jmp short loc_1301
loc_12F8:
add rdi, 4
cmp rdi, rax
jz short loc_1310
loc_1301:
mov edx, [rdi]
test edx, edx
jnz short loc_12F8
mov eax, 1
retn
loc_1310:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
while ( *a1 )
{
if ( ++a1 == (_DWORD *)v2 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101310
LEA EAX,[RSI + -0x1]
LEA RAX,[RDI + RAX*0x4 + 0x4]
JMP 0x00101301
LAB_001012f8:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101310
LAB_00101301:
MOV EDX,dword ptr [RDI]
TEST EDX,EDX
JNZ 0x001012f8
MOV EAX,0x1
RET
LAB_00101310:
XOR EAX,EAX
RET | int8 func0(int *param_1,int param_2)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*param_1 == 0) {
return 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 0;
} |
6,871 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int *test_tup, int size) {
for (int i = 0; i < size; i++) {
if (test_tup[i] == 0) {
return true;
}
}
return false;
}
| int main() {
int arr1[] = {10, 4, 5, 6, 0}; // 0 is used to represent None
int arr2[] = {7, 8, 9, 11, 14};
int arr3[] = {1, 2, 3, 4, 0}; // 0 is used to represent None
assert(func0(arr1, 5) == true);
assert(func0(arr2, 5) == false);
assert(func0(arr3, 5) == true);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1240 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1231 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1240 <func0+0x30>
mov (%rdi),%edx
test %edx,%edx
jne 1228 <func0+0x18>
mov $0x1,%eax
retq
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
lea rax, [rdi+rsi*4]
jmp short loc_1161
loc_1158:
add rdi, 4
cmp rdi, rax
jz short loc_1170
loc_1161:
mov edx, [rdi]
test edx, edx
jnz short loc_1158
mov eax, 1
retn
loc_1170:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
if ( a2 <= 0 )
return 0LL;
v2 = &a1[a2];
while ( *a1 )
{
if ( ++a1 == v2 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x4]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101170
LAB_00101161:
MOV EDX,dword ptr [RDI]
TEST EDX,EDX
JNZ 0x00101158
MOV EAX,0x1
RET
LAB_00101170:
XOR EAX,EAX
RET | int8 func0(int *param_1,int param_2)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
if (*param_1 == 0) {
return 1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 0;
} |
6,872 | func0 |
#include <stdbool.h>
#include <stdio.h>
#include <assert.h>
| void func0(int startnum, int endnum, int result[], int *result_size) {
*result_size = 0;
for (int n = startnum; n <= endnum; ++n) {
bool divisible = true;
int temp = n;
while (temp > 0) {
int digit = temp % 10;
if (digit == 0 || n % digit != 0) {
divisible = false;
break;
}
temp /= 10;
}
if (divisible) {
result[*result_size] = n;
(*result_size)++;
}
}
}
| int main() {
int result[100];
int result_size;
func0(1, 22, result, &result_size);
int expected1[13] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22};
assert(result_size == 13);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected1[i]);
}
func0(1, 15, result, &result_size);
int expected2[12] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15};
assert(result_size == 12);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected2[i]);
}
func0(20, 25, result, &result_size);
int expected3[2] = {22, 24};
assert(result_size == 2);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %rdx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
mov -0x28(%rbp),%rax
movl $0x0,(%rax)
mov -0x14(%rbp),%eax
mov %eax,-0xc(%rbp)
jmpq 123f <func0+0xd6>
movb $0x1,-0xd(%rbp)
mov -0xc(%rbp),%eax
mov %eax,-0x8(%rbp)
jmp 1204 <func0+0x9b>
mov -0x8(%rbp),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
shl $0x2,%eax
add %ecx,%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
je 11e0 <func0+0x77>
mov -0xc(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
je 11e6 <func0+0x7d>
movb $0x0,-0xd(%rbp)
jmp 120a <func0+0xa1>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jg 11a0 <func0+0x37>
cmpb $0x0,-0xd(%rbp)
je 123b <func0+0xd2>
mov -0x28(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
mov %eax,(%rdx)
mov -0x28(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%edx
mov -0x28(%rbp),%rax
mov %edx,(%rax)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x18(%rbp),%eax
jle 1194 <func0+0x2b>
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_28]
mov dword ptr [rax], 0
mov eax, [rbp+var_14]
mov [rbp+var_C], eax
jmp loc_123D
loc_1194:
mov [rbp+var_D], 1
mov eax, [rbp+var_C]
mov [rbp+var_8], eax
jmp short loc_1202
loc_11A0:
mov edx, [rbp+var_8]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
mov ecx, eax
sar ecx, 2
mov eax, edx
sar eax, 1Fh
sub ecx, eax
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
sub edx, eax
mov [rbp+var_4], edx
cmp [rbp+var_4], 0
jz short loc_11DE
mov eax, [rbp+var_C]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jz short loc_11E4
loc_11DE:
mov [rbp+var_D], 0
jmp short loc_1208
loc_11E4:
mov eax, [rbp+var_8]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_8], eax
loc_1202:
cmp [rbp+var_8], 0
jg short loc_11A0
loc_1208:
cmp [rbp+var_D], 0
jz short loc_1239
mov rax, [rbp+var_28]
mov eax, [rax]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_20]
add rdx, rax
mov eax, [rbp+var_C]
mov [rdx], eax
mov rax, [rbp+var_28]
mov eax, [rax]
lea edx, [rax+1]
mov rax, [rbp+var_28]
mov [rax], edx
loc_1239:
add [rbp+var_C], 1
loc_123D:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_18]
jle loc_1194
nop
nop
pop rbp
retn | long long func0(int a1, int a2, long long a3, _DWORD *a4)
{
long long result; // rax
char v5; // [rsp+1Bh] [rbp-Dh]
int i; // [rsp+20h] [rbp-8h]
*a4 = 0;
while ( 1 )
{
result = (unsigned int)a1;
if ( a1 > a2 )
return result;
v5 = 1;
for ( i = a1; i > 0; i /= 10 )
{
if ( !(i % 10) || a1 % (i % 10) )
{
v5 = 0;
break;
}
}
if ( v5 )
*(_DWORD *)(a3 + 4LL * (int)(*a4)++) = a1;
++a1;
}
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0010123d
LAB_00101194:
MOV byte ptr [RBP + -0xd],0x1
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101202
LAB_001011a0:
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV ECX,EAX
SAR ECX,0x2
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
SUB EDX,EAX
MOV dword ptr [RBP + -0x4],EDX
CMP dword ptr [RBP + -0x4],0x0
JZ 0x001011de
MOV EAX,dword ptr [RBP + -0xc]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JZ 0x001011e4
LAB_001011de:
MOV byte ptr [RBP + -0xd],0x0
JMP 0x00101208
LAB_001011e4:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
LAB_00101202:
CMP dword ptr [RBP + -0x8],0x0
JG 0x001011a0
LAB_00101208:
CMP byte ptr [RBP + -0xd],0x0
JZ 0x00101239
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
LEA EDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],EDX
LAB_00101239:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010123d:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x18]
JLE 0x00101194
NOP
NOP
POP RBP
RET | void func0(int param_1,int param_2,long param_3,int *param_4)
{
bool bVar1;
int4 local_14;
int4 local_10;
*param_4 = 0;
local_14 = param_1;
do {
if (param_2 < local_14) {
return;
}
bVar1 = true;
for (local_10 = local_14; 0 < local_10; local_10 = local_10 / 10) {
if ((local_10 % 10 == 0) || (local_14 % (local_10 % 10) != 0)) {
bVar1 = false;
break;
}
}
if (bVar1) {
*(int *)((long)*param_4 * 4 + param_3) = local_14;
*param_4 = *param_4 + 1;
}
local_14 = local_14 + 1;
} while( true );
} |
6,873 | func0 |
#include <stdbool.h>
#include <stdio.h>
#include <assert.h>
| void func0(int startnum, int endnum, int result[], int *result_size) {
*result_size = 0;
for (int n = startnum; n <= endnum; ++n) {
bool divisible = true;
int temp = n;
while (temp > 0) {
int digit = temp % 10;
if (digit == 0 || n % digit != 0) {
divisible = false;
break;
}
temp /= 10;
}
if (divisible) {
result[*result_size] = n;
(*result_size)++;
}
}
}
| int main() {
int result[100];
int result_size;
func0(1, 22, result, &result_size);
int expected1[13] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22};
assert(result_size == 13);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected1[i]);
}
func0(1, 15, result, &result_size);
int expected2[12] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15};
assert(result_size == 12);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected2[i]);
}
func0(20, 25, result, &result_size);
int expected3[2] = {22, 24};
assert(result_size == 2);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O1 | c | func0:
endbr64
mov %rdx,%r9
movl $0x0,(%rcx)
cmp %esi,%edi
jg 120d <func0+0xa4>
lea 0x1(%rsi),%r10d
jmp 1196 <func0+0x2d>
movslq (%rcx),%rax
mov %edi,(%r9,%rax,4)
addl $0x1,(%rcx)
add $0x1,%edi
cmp %edi,%r10d
je 120d <func0+0xa4>
test %edi,%edi
jle 1184 <func0+0x1b>
movslq %edi,%rsi
imul $0x66666667,%rsi,%rsi
sar $0x22,%rsi
mov %edi,%eax
sar $0x1f,%eax
sub %eax,%esi
lea (%rsi,%rsi,4),%eax
add %eax,%eax
mov %edi,%esi
sub %eax,%esi
je 118e <func0+0x25>
mov %edi,%eax
cltd
idiv %esi
test %edx,%edx
jne 118e <func0+0x25>
mov %edi,%r8d
mov %r8d,%edx
movslq %r8d,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
sar $0x1f,%r8d
sub %r8d,%eax
mov %eax,%r8d
cmp $0x9,%edx
jle 1184 <func0+0x1b>
movslq %eax,%rsi
imul $0x66666667,%rsi,%rsi
sar $0x22,%rsi
cltd
sub %edx,%esi
lea (%rsi,%rsi,4),%edx
add %edx,%edx
sub %edx,%eax
mov %eax,%esi
je 118e <func0+0x25>
mov %edi,%eax
cltd
idiv %esi
test %edx,%edx
je 11c6 <func0+0x5d>
jmp 118e <func0+0x25>
retq
| func0:
endbr64
mov r9, rdx
mov r8, rcx
mov dword ptr [rcx], 0
cmp edi, esi
jg locret_1210
lea r10d, [rsi+1]
jmp short loc_119A
loc_1187:
movsxd rax, dword ptr [r8]
mov [r9+rax*4], edi
add dword ptr [r8], 1
loc_1192:
add edi, 1
cmp r10d, edi
jz short locret_1210
loc_119A:
test edi, edi
jle short loc_1187
movsxd rcx, edi
imul rcx, 66666667h
sar rcx, 22h
mov eax, edi
sar eax, 1Fh
sub ecx, eax
lea eax, [rcx+rcx*4]
add eax, eax
mov ecx, edi
sub ecx, eax
jz short loc_1192
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_1192
mov esi, edi
loc_11C9:
mov eax, esi
movsxd rdx, esi
imul rdx, 66666667h
sar rdx, 22h
sar esi, 1Fh
sub edx, esi
mov esi, edx
cmp eax, 9
jle short loc_1187
movsxd rcx, edx
imul rcx, 66666667h
sar rcx, 22h
mov eax, edx
sar eax, 1Fh
sub ecx, eax
lea eax, [rcx+rcx*4]
add eax, eax
mov ecx, edx
sub ecx, eax
jz short loc_1192
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_11C9
jmp short loc_1192
locret_1210:
retn | long long func0(int a1, int a2, long long a3, int *a4)
{
int v6; // r10d
long long result; // rax
int v8; // ecx
int v9; // esi
int v10; // eax
int v11; // edx
int v12; // ecx
*a4 = 0;
if ( a1 <= a2 )
{
v6 = a2 + 1;
do
{
if ( a1 > 0 )
{
result = (unsigned int)(10 * (a1 / 10));
v8 = a1 % 10;
if ( !(a1 % 10) )
goto LABEL_4;
result = (unsigned int)(a1 / v8);
if ( a1 % v8 )
goto LABEL_4;
v9 = a1;
while ( 1 )
{
v10 = v9;
v11 = v9 / 10;
v9 /= 10;
if ( v10 <= 9 )
break;
result = (unsigned int)(10 * (v11 / 10));
v12 = v11 % 10;
if ( v11 % 10 )
{
result = (unsigned int)(a1 / v12);
if ( !(a1 % v12) )
continue;
}
goto LABEL_4;
}
}
result = *a4;
*(_DWORD *)(a3 + 4 * result) = a1;
++*a4;
LABEL_4:
++a1;
}
while ( v6 != a1 );
}
return result;
} | func0:
ENDBR64
MOV R9,RDX
MOV R8,RCX
MOV dword ptr [RCX],0x0
CMP EDI,ESI
JG 0x00101210
LEA R10D,[RSI + 0x1]
JMP 0x0010119a
LAB_00101187:
MOVSXD RAX,dword ptr [R8]
MOV dword ptr [R9 + RAX*0x4],EDI
ADD dword ptr [R8],0x1
LAB_00101192:
ADD EDI,0x1
CMP R10D,EDI
JZ 0x00101210
LAB_0010119a:
TEST EDI,EDI
JLE 0x00101187
MOVSXD RCX,EDI
IMUL RCX,RCX,0x66666667
SAR RCX,0x22
MOV EAX,EDI
SAR EAX,0x1f
SUB ECX,EAX
LEA EAX,[RCX + RCX*0x4]
ADD EAX,EAX
MOV ECX,EDI
SUB ECX,EAX
JZ 0x00101192
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101192
MOV ESI,EDI
LAB_001011c9:
MOV EAX,ESI
MOVSXD RDX,ESI
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
SAR ESI,0x1f
SUB EDX,ESI
MOV ESI,EDX
CMP EAX,0x9
JLE 0x00101187
MOVSXD RCX,EDX
IMUL RCX,RCX,0x66666667
SAR RCX,0x22
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
LEA EAX,[RCX + RCX*0x4]
ADD EAX,EAX
MOV ECX,EDX
SUB ECX,EAX
JZ 0x00101192
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001011c9
JMP 0x00101192
LAB_00101210:
RET | void func0(int param_1,int param_2,long param_3,int *param_4)
{
bool bVar1;
int iVar2;
*param_4 = 0;
if (param_1 <= param_2) {
do {
iVar2 = param_1;
if (0 < param_1) {
do {
if ((iVar2 % 10 == 0) || (param_1 % (iVar2 % 10) != 0)) goto LAB_00101192;
bVar1 = 9 < iVar2;
iVar2 = iVar2 / 10;
} while (bVar1);
}
*(int *)(param_3 + (long)*param_4 * 4) = param_1;
*param_4 = *param_4 + 1;
LAB_00101192:
param_1 = param_1 + 1;
} while (param_2 + 1 != param_1);
}
return;
} |
6,874 | func0 |
#include <stdbool.h>
#include <stdio.h>
#include <assert.h>
| void func0(int startnum, int endnum, int result[], int *result_size) {
*result_size = 0;
for (int n = startnum; n <= endnum; ++n) {
bool divisible = true;
int temp = n;
while (temp > 0) {
int digit = temp % 10;
if (digit == 0 || n % digit != 0) {
divisible = false;
break;
}
temp /= 10;
}
if (divisible) {
result[*result_size] = n;
(*result_size)++;
}
}
}
| int main() {
int result[100];
int result_size;
func0(1, 22, result, &result_size);
int expected1[13] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22};
assert(result_size == 13);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected1[i]);
}
func0(1, 15, result, &result_size);
int expected2[12] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15};
assert(result_size == 12);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected2[i]);
}
func0(20, 25, result, &result_size);
int expected3[2] = {22, 24};
assert(result_size == 2);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O2 | c | func0:
endbr64
movl $0x0,(%rcx)
mov %rdx,%r10
cmp %esi,%edi
jg 147d <func0+0x9d>
lea 0x1(%rsi),%r11d
mov $0xcccccccd,%r9d
test %edi,%edi
jle 146b <func0+0x8b>
movslq %edi,%rsi
mov %edi,%eax
imul $0x66666667,%rsi,%rsi
sar $0x1f,%eax
sar $0x22,%rsi
sub %eax,%esi
lea (%rsi,%rsi,4),%eax
mov %edi,%esi
add %eax,%eax
sub %eax,%esi
je 1475 <func0+0x95>
mov %edi,%eax
cltd
idiv %esi
test %edx,%edx
jne 1475 <func0+0x95>
mov %edi,%r8d
jmp 1458 <func0+0x78>
nopw 0x0(%rax,%rax,1)
mov %r8d,%esi
imul %r9,%rsi
shr $0x23,%rsi
lea (%rsi,%rsi,4),%eax
mov %r8d,%esi
add %eax,%eax
sub %eax,%esi
je 1475 <func0+0x95>
mov %edi,%eax
cltd
idiv %esi
test %edx,%edx
jne 1475 <func0+0x95>
mov %r8d,%r8d
mov %r8,%rax
imul %r9,%r8
shr $0x23,%r8
cmp $0x9,%eax
jg 1438 <func0+0x58>
movslq (%rcx),%rax
mov %edi,(%r10,%rax,4)
addl $0x1,(%rcx)
add $0x1,%edi
cmp %edi,%r11d
jne 1400 <func0+0x20>
retq
xchg %ax,%ax
| func0:
endbr64
mov dword ptr [rcx], 0
mov r10, rdx
mov r9, rcx
cmp edi, esi
jg locret_1493
lea r11d, [rsi+1]
mov r8d, 0CCCCCCCDh
nop word ptr [rax+rax+00h]
loc_1418:
test edi, edi
jle short loc_1480
movsxd rcx, edi
mov eax, edi
imul rcx, 66666667h
sar eax, 1Fh
sar rcx, 22h
sub ecx, eax
lea eax, [rcx+rcx*4]
mov ecx, edi
add eax, eax
sub ecx, eax
jz short loc_148B
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_148B
mov esi, edi
jmp short loc_146E
loc_1450:
mov ecx, esi
imul rcx, r8
shr rcx, 23h
lea edx, [rcx+rcx*4]
mov ecx, esi
add edx, edx
sub ecx, edx
jz short loc_148B
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_148B
loc_146E:
mov esi, esi
mov rax, rsi
imul rsi, r8
shr rsi, 23h
cmp eax, 9
jg short loc_1450
loc_1480:
movsxd rax, dword ptr [r9]
mov [r10+rax*4], edi
add dword ptr [r9], 1
loc_148B:
add edi, 1
cmp r11d, edi
jnz short loc_1418
locret_1493:
retn | long long func0(int a1, int a2, long long a3, int *a4)
{
int v5; // r11d
long long result; // rax
int v7; // ecx
unsigned int v8; // esi
signed int v9; // ecx
*a4 = 0;
if ( a1 <= a2 )
{
v5 = a2 + 1;
do
{
if ( a1 > 0 )
{
result = (unsigned int)(10 * (a1 / 10));
v7 = a1 % 10;
if ( !(a1 % 10) )
goto LABEL_11;
result = (unsigned int)(a1 / v7);
if ( a1 % v7 )
goto LABEL_11;
v8 = a1;
while ( 1 )
{
result = v8;
v8 /= 0xAu;
if ( (int)result <= 9 )
break;
v9 = v8 % 0xA;
if ( v8 != 10 * (v8 / 0xA) )
{
result = (unsigned int)(a1 / v9);
if ( !(a1 % v9) )
continue;
}
goto LABEL_11;
}
}
result = *a4;
*(_DWORD *)(a3 + 4 * result) = a1;
++*a4;
LABEL_11:
++a1;
}
while ( v5 != a1 );
}
return result;
} | func0:
ENDBR64
MOV dword ptr [RCX],0x0
MOV R10,RDX
MOV R9,RCX
CMP EDI,ESI
JG 0x00101493
LEA R11D,[RSI + 0x1]
MOV R8D,0xcccccccd
NOP word ptr [RAX + RAX*0x1]
LAB_00101418:
TEST EDI,EDI
JLE 0x00101480
MOVSXD RCX,EDI
MOV EAX,EDI
IMUL RCX,RCX,0x66666667
SAR EAX,0x1f
SAR RCX,0x22
SUB ECX,EAX
LEA EAX,[RCX + RCX*0x4]
MOV ECX,EDI
ADD EAX,EAX
SUB ECX,EAX
JZ 0x0010148b
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010148b
MOV ESI,EDI
JMP 0x0010146e
LAB_00101450:
MOV ECX,ESI
IMUL RCX,R8
SHR RCX,0x23
LEA EDX,[RCX + RCX*0x4]
MOV ECX,ESI
ADD EDX,EDX
SUB ECX,EDX
JZ 0x0010148b
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010148b
LAB_0010146e:
MOV ESI,ESI
MOV RAX,RSI
IMUL RSI,R8
SHR RSI,0x23
CMP EAX,0x9
JG 0x00101450
LAB_00101480:
MOVSXD RAX,dword ptr [R9]
MOV dword ptr [R10 + RAX*0x4],EDI
ADD dword ptr [R9],0x1
LAB_0010148b:
ADD EDI,0x1
CMP R11D,EDI
JNZ 0x00101418
LAB_00101493:
RET | void func0(uint param_1,int param_2,long param_3,int *param_4)
{
uint uVar1;
int iVar2;
*param_4 = 0;
if ((int)param_1 <= param_2) {
do {
if ((int)param_1 < 1) {
LAB_00101480:
*(uint *)(param_3 + (long)*param_4 * 4) = param_1;
*param_4 = *param_4 + 1;
}
else {
iVar2 = (int)param_1 % 10;
uVar1 = param_1;
while ((iVar2 != 0 && ((int)param_1 % iVar2 == 0))) {
if ((int)uVar1 < 10) goto LAB_00101480;
iVar2 = uVar1 / 10 + ((uVar1 / 10) / 10) * -10;
uVar1 = uVar1 / 10;
}
}
param_1 = param_1 + 1;
} while (param_2 + 1U != param_1);
}
return;
} |
6,875 | func0 |
#include <stdbool.h>
#include <stdio.h>
#include <assert.h>
| void func0(int startnum, int endnum, int result[], int *result_size) {
*result_size = 0;
for (int n = startnum; n <= endnum; ++n) {
bool divisible = true;
int temp = n;
while (temp > 0) {
int digit = temp % 10;
if (digit == 0 || n % digit != 0) {
divisible = false;
break;
}
temp /= 10;
}
if (divisible) {
result[*result_size] = n;
(*result_size)++;
}
}
}
| int main() {
int result[100];
int result_size;
func0(1, 22, result, &result_size);
int expected1[13] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22};
assert(result_size == 13);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected1[i]);
}
func0(1, 15, result, &result_size);
int expected2[12] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15};
assert(result_size == 12);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected2[i]);
}
func0(20, 25, result, &result_size);
int expected3[2] = {22, 24};
assert(result_size == 2);
for (int i = 0; i < result_size; i++) {
assert(result[i] == expected3[i]);
}
return 0;
}
| O3 | c | func0:
endbr64
movl $0x0,(%rcx)
mov %rdx,%r11
cmp %esi,%edi
jg 15b1 <func0+0xe1>
test %edi,%edi
jle 1588 <func0+0xb8>
mov $0xcccccccd,%r10d
nopl 0x0(%rax,%rax,1)
movslq %edi,%r8
mov %edi,%eax
imul $0x66666667,%r8,%r8
sar $0x1f,%eax
sar $0x22,%r8
sub %eax,%r8d
lea (%r8,%r8,4),%eax
mov %edi,%r8d
add %eax,%eax
sub %eax,%r8d
je 1577 <func0+0xa7>
mov %edi,%eax
cltd
idiv %r8d
test %edx,%edx
jne 1577 <func0+0xa7>
mov %edi,%r8d
jmp 1553 <func0+0x83>
nopl 0x0(%rax,%rax,1)
mov %r8d,%r9d
imul %r10,%r9
shr $0x23,%r9
lea (%r9,%r9,4),%eax
mov %r8d,%r9d
add %eax,%eax
sub %eax,%r9d
je 1577 <func0+0xa7>
mov %edi,%eax
cltd
idiv %r9d
test %edx,%edx
jne 1577 <func0+0xa7>
movslq %r8d,%r8
mov %r8,%rax
imul $0x66666667,%r8,%r8
cltd
sar $0x22,%r8
sub %edx,%r8d
cmp $0x9,%eax
jg 1530 <func0+0x60>
movslq (%rcx),%rax
mov %edi,(%r11,%rax,4)
addl $0x1,(%rcx)
add $0x1,%edi
cmp %edi,%esi
jge 14f8 <func0+0x28>
retq
nopl 0x0(%rax,%rax,1)
test %esi,%esi
mov $0x0,%edx
cmovle %esi,%edx
nopw 0x0(%rax,%rax,1)
movslq (%rcx),%rax
mov %edi,(%r11,%rax,4)
add $0x1,%edi
addl $0x1,(%rcx)
cmp %edx,%edi
jle 1598 <func0+0xc8>
cmp %edi,%esi
jge 14ed <func0+0x1d>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
mov dword ptr [rcx], 0
mov r10d, esi
mov r9, rdx
cmp edi, esi
jg locret_14C0
xor edx, edx
test esi, esi
cmovle edx, esi
test edi, edi
jg short loc_1432
nop dword ptr [rax+rax+00h]
loc_1418:
movsxd rax, dword ptr [rcx]
mov [r9+rax*4], edi
add edi, 1
add dword ptr [rcx], 1
cmp edi, edx
jle short loc_1418
cmp r10d, edi
jl locret_14C1
loc_1432:
mov r11d, 0CCCCCCCDh
loc_1438:
movsxd rsi, edi
mov eax, edi
imul rsi, 66666667h
sar eax, 1Fh
sar rsi, 22h
sub esi, eax
lea eax, [rsi+rsi*4]
mov esi, edi
add eax, eax
sub esi, eax
jz short loc_14AD
mov eax, edi
cdq
idiv esi
test edx, edx
jnz short loc_14AD
mov r8d, edi
jmp short loc_1490
loc_1470:
mov esi, r8d
imul rsi, r11
shr rsi, 23h
lea eax, [rsi+rsi*4]
mov esi, r8d
add eax, eax
sub esi, eax
jz short loc_14AD
mov eax, edi
cdq
idiv esi
test edx, edx
jnz short loc_14AD
loc_1490:
mov r8d, r8d
mov rax, r8
imul r8, r11
shr r8, 23h
cmp eax, 9
jg short loc_1470
movsxd rax, dword ptr [rcx]
mov [r9+rax*4], edi
add dword ptr [rcx], 1
loc_14AD:
add edi, 1
cmp r10d, edi
jge short loc_1438
retn
locret_14C0:
retn
locret_14C1:
retn | long long func0(int a1, int a2, long long a3, int *a4)
{
int v6; // edx
long long result; // rax
int v8; // esi
unsigned int v9; // r8d
signed int v10; // esi
int v11; // eax
*a4 = 0;
if ( a1 <= a2 )
{
v6 = 0;
if ( a2 <= 0 )
v6 = a2;
if ( a1 > 0 )
goto LABEL_17;
do
{
result = *a4;
*(_DWORD *)(a3 + 4 * result) = a1++;
++*a4;
}
while ( a1 <= v6 );
if ( a2 >= a1 )
{
LABEL_17:
do
{
result = (unsigned int)(10 * (a1 / 10));
v8 = a1 % 10;
if ( a1 % 10 )
{
result = (unsigned int)(a1 / v8);
if ( !(a1 % v8) )
{
v9 = a1;
while ( 1 )
{
v11 = v9;
v9 /= 0xAu;
if ( v11 <= 9 )
break;
result = 10 * (v9 / 0xA);
v10 = v9 % 0xA;
if ( v9 != (_DWORD)result )
{
result = (unsigned int)(a1 / v10);
if ( !(a1 % v10) )
continue;
}
goto LABEL_14;
}
result = *a4;
*(_DWORD *)(a3 + 4 * result) = a1;
++*a4;
}
}
LABEL_14:
++a1;
}
while ( a2 >= a1 );
}
}
return result;
} | func0:
ENDBR64
MOV dword ptr [RCX],0x0
MOV R10D,ESI
MOV R9,RDX
CMP EDI,ESI
JG 0x001014c0
XOR EDX,EDX
TEST ESI,ESI
CMOVLE EDX,ESI
TEST EDI,EDI
JG 0x00101432
NOP dword ptr [RAX + RAX*0x1]
LAB_00101418:
MOVSXD RAX,dword ptr [RCX]
MOV dword ptr [R9 + RAX*0x4],EDI
ADD EDI,0x1
ADD dword ptr [RCX],0x1
CMP EDI,EDX
JLE 0x00101418
CMP R10D,EDI
JL 0x001014c1
LAB_00101432:
MOV R11D,0xcccccccd
LAB_00101438:
MOVSXD RSI,EDI
MOV EAX,EDI
IMUL RSI,RSI,0x66666667
SAR EAX,0x1f
SAR RSI,0x22
SUB ESI,EAX
LEA EAX,[RSI + RSI*0x4]
MOV ESI,EDI
ADD EAX,EAX
SUB ESI,EAX
JZ 0x001014ad
MOV EAX,EDI
CDQ
IDIV ESI
TEST EDX,EDX
JNZ 0x001014ad
MOV R8D,EDI
JMP 0x00101490
LAB_00101470:
MOV ESI,R8D
IMUL RSI,R11
SHR RSI,0x23
LEA EAX,[RSI + RSI*0x4]
MOV ESI,R8D
ADD EAX,EAX
SUB ESI,EAX
JZ 0x001014ad
MOV EAX,EDI
CDQ
IDIV ESI
TEST EDX,EDX
JNZ 0x001014ad
LAB_00101490:
MOV R8D,R8D
MOV RAX,R8
IMUL R8,R11
SHR R8,0x23
CMP EAX,0x9
JG 0x00101470
MOVSXD RAX,dword ptr [RCX]
MOV dword ptr [R9 + RAX*0x4],EDI
ADD dword ptr [RCX],0x1
LAB_001014ad:
ADD EDI,0x1
CMP R10D,EDI
JGE 0x00101438
RET
LAB_001014c0:
RET
LAB_001014c1:
RET | ulong func0(uint param_1,int param_2,long param_3,int *param_4)
{
int iVar1;
ulong in_RAX;
ulong uVar2;
int iVar3;
ulong uVar4;
*param_4 = 0;
if (param_2 < (int)param_1) {
return in_RAX;
}
iVar3 = 0;
if (param_2 < 1) {
iVar3 = param_2;
}
if ((int)param_1 < 1) {
do {
iVar1 = *param_4;
*(uint *)(param_3 + (long)iVar1 * 4) = param_1;
param_1 = param_1 + 1;
*param_4 = *param_4 + 1;
} while ((int)param_1 <= iVar3);
if (param_2 < (int)param_1) {
return (long)iVar1;
}
}
do {
uVar2 = (ulong)(uint)(((int)param_1 / 10) * 10);
iVar3 = (int)param_1 % 10;
if ((iVar3 != 0) &&
(uVar2 = (long)(int)param_1 / (long)iVar3 & 0xffffffff, (int)param_1 % iVar3 == 0)) {
uVar4 = (ulong)param_1;
while (9 < (int)uVar4) {
iVar3 = (int)((uVar4 / 10) / 10);
uVar2 = (ulong)(uint)(iVar3 * 10);
iVar3 = (int)(uVar4 / 10) + iVar3 * -10;
if ((iVar3 == 0) ||
(uVar2 = (long)(int)param_1 / (long)iVar3 & 0xffffffff, uVar4 = uVar4 / 10,
(int)param_1 % iVar3 != 0)) goto LAB_001014ad;
}
uVar2 = (ulong)*param_4;
*(uint *)(param_3 + uVar2 * 4) = param_1;
*param_4 = *param_4 + 1;
}
LAB_001014ad:
param_1 = param_1 + 1;
if (param_2 < (int)param_1) {
return uVar2;
}
} while( true );
} |
6,876 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int r, int a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return -1; // Using -1 to represent None since C doesn't have a None type
}
double sectorarea = (pi * r * r) * (a / 360.0);
return sectorarea;
}
| int main() {
assert(func0(4, 45) == 6.285714285714286);
assert(func0(9, 45) == 31.82142857142857);
assert(func0(9, 360) == -1); // Using -1 to check for None
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movsd 0xf51(%rip),%xmm0
movsd %xmm0,-0x10(%rbp)
cmpl $0x167,-0x18(%rbp)
jle 1177 <func0+0x2e>
movsd 0xf43(%rip),%xmm0
jmp 11ad <func0+0x64>
cvtsi2sdl -0x14(%rbp),%xmm0
movapd %xmm0,%xmm1
mulsd -0x10(%rbp),%xmm1
cvtsi2sdl -0x14(%rbp),%xmm0
mulsd %xmm0,%xmm1
cvtsi2sdl -0x18(%rbp),%xmm0
movsd 0xf25(%rip),%xmm2
divsd %xmm2,%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
movsd xmm0, cs:qword_2090
movsd [rbp+var_10], xmm0
cmp [rbp+var_18], 167h
jle short loc_1177
movsd xmm0, cs:qword_2098
jmp short loc_11B9
loc_1177:
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_14]
movapd xmm1, xmm0
mulsd xmm1, [rbp+var_10]
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_14]
mulsd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_18]
movsd xmm2, cs:qword_20A0
divsd xmm0, xmm2
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
loc_11B9:
pop rbp
retn | double func0(int a1, int a2)
{
if ( a2 <= 359 )
return (double)a2 / 360.0 * ((double)a1 * 3.142857142857143 * (double)a1);
else
return -1.0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOVSD XMM0,qword ptr [0x00102090]
MOVSD qword ptr [RBP + -0x10],XMM0
CMP dword ptr [RBP + -0x18],0x167
JLE 0x00101177
MOVSD XMM0,qword ptr [0x00102098]
JMP 0x001011b9
LAB_00101177:
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x14]
MOVAPD XMM1,XMM0
MULSD XMM1,qword ptr [RBP + -0x10]
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x14]
MULSD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x18]
MOVSD XMM2,qword ptr [0x001020a0]
DIVSD XMM0,XMM2
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
LAB_001011b9:
POP RBP
RET | void func0(void)
{
return;
} |
6,877 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int r, int a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return -1; // Using -1 to represent None since C doesn't have a None type
}
double sectorarea = (pi * r * r) * (a / 360.0);
return sectorarea;
}
| int main() {
assert(func0(4, 45) == 6.285714285714286);
assert(func0(9, 45) == 31.82142857142857);
assert(func0(9, 360) == -1); // Using -1 to check for None
return 0;
}
| O1 | c | func0:
endbr64
movsd 0xed3(%rip),%xmm0
cmp $0x167,%esi
jg 1169 <func0+0x40>
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movapd %xmm0,%xmm1
mulsd 0xebf(%rip),%xmm1
mulsd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
divsd 0xeb3(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
| func0:
endbr64
movsd xmm0, cs:qword_2008
cmp esi, 167h
jg short locret_1169
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
movapd xmm0, xmm1
mulsd xmm0, cs:qword_2010
mulsd xmm0, xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
divsd xmm1, cs:qword_2018
mulsd xmm0, xmm1
locret_1169:
retn | double func0(int a1, int a2)
{
double result; // xmm0_8
result = -1.0;
if ( a2 <= 359 )
return (double)a1 * 3.142857142857143 * (double)a1 * ((double)a2 / 360.0);
return result;
} | func0:
ENDBR64
MOVSD XMM0,qword ptr [0x00102008]
CMP ESI,0x167
JG 0x00101169
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MOVAPD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102010]
MULSD XMM0,XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM1,qword ptr [0x00102018]
MULSD XMM0,XMM1
LAB_00101169:
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = DAT_00102008;
if (param_2 < 0x168) {
dVar1 = (double)param_1 * _DAT_00102010 * (double)param_1 * ((double)param_2 / _DAT_00102018);
}
return dVar1;
} |
6,878 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int r, int a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return -1; // Using -1 to represent None since C doesn't have a None type
}
double sectorarea = (pi * r * r) * (a / 360.0);
return sectorarea;
}
| int main() {
assert(func0(4, 45) == 6.285714285714286);
assert(func0(9, 45) == 31.82142857142857);
assert(func0(9, 360) == -1); // Using -1 to check for None
return 0;
}
| O2 | c | func0:
endbr64
movsd 0xebc(%rip),%xmm0
cmp $0x167,%esi
jg 1180 <func0+0x40>
pxor %xmm0,%xmm0
movsd 0xeb0(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd %xmm0,%xmm1
mulsd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
divsd 0xe9c(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsd xmm0, cs:qword_2008
cmp esi, 167h
jg short locret_1180
pxor xmm1, xmm1
movsd xmm0, cs:qword_2010
cvtsi2sd xmm1, edi
mulsd xmm0, xmm1
mulsd xmm0, xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
divsd xmm1, cs:qword_2018
mulsd xmm0, xmm1
locret_1180:
retn | double func0(int a1, int a2)
{
double result; // xmm0_8
result = -1.0;
if ( a2 <= 359 )
return 3.142857142857143 * (double)a1 * (double)a1 * ((double)a2 / 360.0);
return result;
} | func0:
ENDBR64
MOVSD XMM0,qword ptr [0x00102008]
CMP ESI,0x167
JG 0x00101180
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102010]
CVTSI2SD XMM1,EDI
MULSD XMM0,XMM1
MULSD XMM0,XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM1,qword ptr [0x00102018]
MULSD XMM0,XMM1
LAB_00101180:
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = DAT_00102008;
if (param_2 < 0x168) {
dVar1 = DAT_00102010 * (double)param_1 * (double)param_1 * ((double)param_2 / _DAT_00102018);
}
return dVar1;
} |
6,879 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(int r, int a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return -1; // Using -1 to represent None since C doesn't have a None type
}
double sectorarea = (pi * r * r) * (a / 360.0);
return sectorarea;
}
| int main() {
assert(func0(4, 45) == 6.285714285714286);
assert(func0(9, 45) == 31.82142857142857);
assert(func0(9, 360) == -1); // Using -1 to check for None
return 0;
}
| O3 | c | func0:
endbr64
movsd 0xebc(%rip),%xmm0
cmp $0x167,%esi
jg 1180 <func0+0x40>
pxor %xmm0,%xmm0
movsd 0xeb0(%rip),%xmm1
cvtsi2sd %edi,%xmm0
mulsd %xmm0,%xmm1
mulsd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
divsd 0xe9c(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
cmp esi, 167h
jg short loc_1180
pxor xmm1, xmm1
movsd xmm0, cs:qword_2010
cvtsi2sd xmm1, edi
mulsd xmm0, xmm1
mulsd xmm0, xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
divsd xmm1, cs:qword_2018
mulsd xmm0, xmm1
retn
loc_1180:
movsd xmm0, cs:qword_2008
retn | double func0(int a1, int a2)
{
if ( a2 > 359 )
return -1.0;
else
return 3.142857142857143 * (double)a1 * (double)a1 * ((double)a2 / 360.0);
} | func0:
ENDBR64
CMP ESI,0x167
JG 0x00101180
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102010]
CVTSI2SD XMM1,EDI
MULSD XMM0,XMM1
MULSD XMM0,XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
DIVSD XMM1,qword ptr [0x00102018]
MULSD XMM0,XMM1
RET
LAB_00101180:
MOVSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1,int param_2)
{
if (param_2 < 0x168) {
return DAT_00102010 * (double)param_1 * (double)param_1 * ((double)param_2 / _DAT_00102018);
}
return DAT_00102008;
} |
6,880 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(char* X, char* Y, char* Z, int m, int n, int o) {
int L[m+1][n+1][o+1];
int i, j, k;
for (i = 0; i <= m; i++) {
for (j = 0; j <= n; j++) {
for (k = 0; k <= o; k++) {
if (i == 0 || j == 0 || k == 0) {
L[i][j][k] = 0;
} else if (X[i-1] == Y[j-1] && X[i-1] == Z[k-1]) {
L[i][j][k] = L[i-1][j-1][k-1] + 1;
} else {
int max1 = L[i-1][j][k] > L[i][j-1][k] ? L[i-1][j][k] : L[i][j-1][k];
L[i][j][k] = max1 > L[i][j][k-1] ? max1 : L[i][j][k-1];
}
}
}
}
return L[m][n][o];
}
| int main() {
// Testing the implementation with assertions
assert(func0("AGGT12", "12TXAYB", "12XBA", 6, 7, 5) == 2);
assert(func0("Reels", "Reelsfor", "ReelsforReels", 5, 8, 13) == 5);
assert(func0("abcd1e2", "bc12ea", "bd1ea", 7, 6, 5) == 3);
printf("All tests passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0xd8,%rsp
mov %rdi,-0x78(%rbp)
mov %rsi,-0x80(%rbp)
mov %rdx,-0x88(%rbp)
mov %ecx,-0x8c(%rbp)
mov %r8d,-0x90(%rbp)
mov %r9d,-0x94(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,-0xa0(%rbp)
mov -0x94(%rbp),%eax
lea 0x1(%rax),%edi
mov -0x90(%rbp),%eax
lea 0x1(%rax),%r8d
mov -0x8c(%rbp),%eax
lea 0x1(%rax),%r9d
movslq %edi,%rax
sub $0x1,%rax
mov %rax,-0x58(%rbp)
movslq %edi,%rax
mov %rax,%r10
mov $0x0,%r11d
movslq %edi,%rax
lea 0x0(,%rax,4),%r11
movslq %r8d,%rax
sub $0x1,%rax
mov %rax,-0x50(%rbp)
movslq %edi,%rax
mov %rax,%r14
mov $0x0,%r15d
movslq %r8d,%rax
mov %rax,%r12
mov $0x0,%r13d
mov %r15,%rdx
imul %r12,%rdx
mov %r13,%rax
imul %r14,%rax
lea (%rdx,%rax,1),%rcx
mov %r14,%rax
mul %r12
add %rdx,%rcx
mov %rcx,%rdx
movslq %edi,%rdx
movslq %r8d,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%r10
movslq %r9d,%rax
sub $0x1,%rax
mov %rax,-0x48(%rbp)
movslq %edi,%rax
mov %rax,-0xb0(%rbp)
movq $0x0,-0xa8(%rbp)
movslq %r8d,%rax
mov %rax,-0xc0(%rbp)
movq $0x0,-0xb8(%rbp)
mov -0xb0(%rbp),%rcx
mov -0xa8(%rbp),%rbx
mov %rbx,%rdx
mov -0xc0(%rbp),%r14
mov -0xb8(%rbp),%r15
imul %r14,%rdx
mov %r15,%rax
imul %rcx,%rax
lea (%rdx,%rax,1),%rsi
mov %rcx,%rax
mul %r14
mov %rax,%rcx
mov %rdx,%rbx
lea (%rsi,%rbx,1),%rax
mov %rax,%rbx
movslq %r9d,%rax
mov %rax,-0xd0(%rbp)
movq $0x0,-0xc8(%rbp)
mov -0xd0(%rbp),%r14
mov -0xc8(%rbp),%r15
mov %r14,%rdx
imul %rbx,%rdx
mov %r15,%rax
imul %rcx,%rax
lea (%rdx,%rax,1),%rsi
mov %r14,%rax
mul %rcx
lea (%rsi,%rdx,1),%rcx
mov %rcx,%rdx
movslq %edi,%rax
mov %rax,-0xe0(%rbp)
movq $0x0,-0xd8(%rbp)
movslq %r8d,%rax
mov %rax,-0xf0(%rbp)
movq $0x0,-0xe8(%rbp)
mov -0xe0(%rbp),%rbx
mov -0xd8(%rbp),%rsi
mov %rsi,%rdx
mov -0xf0(%rbp),%r14
mov -0xe8(%rbp),%r15
imul %r14,%rdx
mov %r15,%rax
imul %rbx,%rax
lea (%rdx,%rax,1),%rcx
mov %rbx,%rax
mul %r14
add %rdx,%rcx
mov %rcx,%rdx
movslq %r9d,%rcx
mov %rcx,-0x100(%rbp)
movq $0x0,-0xf8(%rbp)
mov -0x100(%rbp),%r14
mov -0xf8(%rbp),%r15
mov %r14,%rsi
imul %rdx,%rsi
mov %r15,%rcx
imul %rax,%rcx
add %rsi,%rcx
mul %r14
add %rdx,%rcx
mov %rcx,%rdx
movslq %edi,%rdx
movslq %r8d,%rax
imul %rax,%rdx
movslq %r9d,%rax
imul %rdx,%rax
lea 0x0(,%rax,4),%rdx
mov $0x10,%eax
sub $0x1,%rax
add %rdx,%rax
mov $0x10,%ebx
mov $0x0,%edx
div %rbx
imul $0x10,%rax,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 1428 <func0+0x29f>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 1411 <func0+0x288>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
mov %rax,%rdx
and $0xfff,%edx
test %rdx,%rdx
je 1452 <func0+0x2c9>
and $0xfff,%eax
sub $0x8,%rax
add %rsp,%rax
orq $0x0,(%rax)
mov %rsp,%rax
add $0x3,%rax
shr $0x2,%rax
shl $0x2,%rax
mov %rax,-0x40(%rbp)
movl $0x0,-0x60(%rbp)
jmpq 16ca <func0+0x541>
movl $0x0,-0x64(%rbp)
jmpq 16b7 <func0+0x52e>
movl $0x0,-0x68(%rbp)
jmpq 16a4 <func0+0x51b>
cmpl $0x0,-0x60(%rbp)
je 149b <func0+0x312>
cmpl $0x0,-0x64(%rbp)
je 149b <func0+0x312>
cmpl $0x0,-0x68(%rbp)
jne 14d9 <func0+0x350>
mov %r10,%rcx
shr $0x2,%rcx
mov %r11,%rdi
shr $0x2,%rdi
mov -0x40(%rbp),%rax
mov -0x68(%rbp),%edx
movslq %edx,%rsi
mov -0x60(%rbp),%edx
movslq %edx,%rdx
imul %rdx,%rcx
mov -0x64(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rcx
add %rcx,%rdx
movl $0x0,(%rax,%rdx,4)
jmpq 16a0 <func0+0x517>
mov -0x60(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x64(%rbp),%eax
cltq
lea -0x1(%rax),%rcx
mov -0x80(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 15b0 <func0+0x427>
mov -0x60(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x78(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x68(%rbp),%eax
cltq
lea -0x1(%rax),%rcx
mov -0x88(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 15b0 <func0+0x427>
mov %r10,%rcx
shr $0x2,%rcx
mov %r11,%rdi
shr $0x2,%rdi
mov -0x60(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x64(%rbp),%eax
lea -0x1(%rax),%r8d
mov -0x68(%rbp),%eax
lea -0x1(%rax),%esi
mov -0x40(%rbp),%rax
movslq %esi,%rsi
movslq %edx,%rdx
imul %rdx,%rcx
movslq %r8d,%rdx
imul %rdi,%rdx
add %rsi,%rcx
add %rcx,%rdx
mov (%rax,%rdx,4),%eax
mov %r10,%rsi
shr $0x2,%rsi
mov %r11,%r8
shr $0x2,%r8
lea 0x1(%rax),%ecx
mov -0x40(%rbp),%rax
mov -0x68(%rbp),%edx
movslq %edx,%rdi
mov -0x60(%rbp),%edx
movslq %edx,%rdx
imul %rdx,%rsi
mov -0x64(%rbp),%edx
movslq %edx,%rdx
imul %r8,%rdx
add %rdi,%rsi
add %rsi,%rdx
mov %ecx,(%rax,%rdx,4)
jmpq 16a0 <func0+0x517>
mov %r10,%rcx
shr $0x2,%rcx
mov %r11,%rdi
shr $0x2,%rdi
mov -0x64(%rbp),%eax
lea -0x1(%rax),%r8d
mov -0x40(%rbp),%rax
mov -0x68(%rbp),%edx
movslq %edx,%rsi
mov -0x60(%rbp),%edx
movslq %edx,%rdx
imul %rdx,%rcx
movslq %r8d,%rdx
imul %rdi,%rdx
add %rsi,%rcx
add %rcx,%rdx
mov (%rax,%rdx,4),%edx
mov %r10,%rsi
shr $0x2,%rsi
mov %r11,%r8
shr $0x2,%r8
mov -0x60(%rbp),%eax
lea -0x1(%rax),%r9d
mov -0x40(%rbp),%rax
mov -0x68(%rbp),%ecx
movslq %ecx,%rdi
movslq %r9d,%rcx
imul %rcx,%rsi
mov -0x64(%rbp),%ecx
movslq %ecx,%rcx
imul %r8,%rcx
add %rdi,%rsi
add %rsi,%rcx
mov (%rax,%rcx,4),%eax
cmp %eax,%edx
cmovge %edx,%eax
mov %eax,-0x5c(%rbp)
mov %r10,%rcx
shr $0x2,%rcx
mov %r11,%rdi
shr $0x2,%rdi
mov -0x68(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x40(%rbp),%rax
movslq %edx,%rsi
mov -0x60(%rbp),%edx
movslq %edx,%rdx
imul %rdx,%rcx
mov -0x64(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rcx
add %rcx,%rdx
mov (%rax,%rdx,4),%eax
mov %r10,%rsi
shr $0x2,%rsi
mov %r11,%r8
shr $0x2,%r8
cmp %eax,-0x5c(%rbp)
cmovge -0x5c(%rbp),%eax
mov %eax,%edx
mov -0x40(%rbp),%rax
mov -0x68(%rbp),%ecx
movslq %ecx,%rdi
mov -0x60(%rbp),%ecx
movslq %ecx,%rcx
imul %rcx,%rsi
mov -0x64(%rbp),%ecx
movslq %ecx,%rcx
imul %r8,%rcx
add %rdi,%rsi
add %rsi,%rcx
mov %edx,(%rax,%rcx,4)
addl $0x1,-0x68(%rbp)
mov -0x68(%rbp),%eax
cmp -0x94(%rbp),%eax
jle 1489 <func0+0x300>
addl $0x1,-0x64(%rbp)
mov -0x64(%rbp),%eax
cmp -0x90(%rbp),%eax
jle 147d <func0+0x2f4>
addl $0x1,-0x60(%rbp)
mov -0x60(%rbp),%eax
cmp -0x8c(%rbp),%eax
jle 1471 <func0+0x2e8>
mov %r10,%rcx
shr $0x2,%rcx
mov %r11,%rdi
shr $0x2,%rdi
mov -0x40(%rbp),%rax
mov -0x94(%rbp),%edx
movslq %edx,%rsi
mov -0x8c(%rbp),%edx
movslq %edx,%rdx
imul %rdx,%rcx
mov -0x90(%rbp),%edx
movslq %edx,%rdx
imul %rdi,%rdx
add %rsi,%rcx
add %rcx,%rdx
mov (%rax,%rdx,4),%eax
mov -0xa0(%rbp),%rsp
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
je 1732 <func0+0x5a9>
callq 1080 <__stack_chk_fail@plt>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 78h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_78], rdx
mov [rbp+var_7C], ecx
mov [rbp+var_80], r8d
mov [rbp+var_84], r9d
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov rax, rsp
mov r13, rax
mov eax, [rbp+var_84]
lea edi, [rax+1]
mov eax, [rbp+var_80]
lea r10d, [rax+1]
mov eax, [rbp+var_7C]
lea r11d, [rax+1]
movsxd rax, edi
sub rax, 1
mov [rbp+var_48], rax
movsxd rax, edi
lea rcx, ds:0[rax*4]
movsxd rax, r10d
sub rax, 1
mov [rbp+var_40], rax
movsxd rax, edi
mov r8, rax
mov r9d, 0
movsxd rax, r10d
mov rax, rax
mov edx, 0
mov rbx, r9
imul rbx, rax
mov rsi, rdx
imul rsi, r8
add rsi, rbx
mul r8
add rsi, rdx
mov rdx, rsi
movsxd rdx, edi
movsxd rax, r10d
imul rax, rdx
lea rsi, ds:0[rax*4]
movsxd rax, r11d
sub rax, 1
mov [rbp+var_38], rax
movsxd rax, edi
mov r8, rax
mov r9d, 0
movsxd rax, r10d
mov rax, rax
mov edx, 0
mov r12, r9
imul r12, rax
mov rbx, rdx
imul rbx, r8
add rbx, r12
mul r8
lea r8, [rbx+rdx]
mov rdx, r8
movsxd r8, r11d
mov r8, r8
mov r9d, 0
mov r12, rdx
imul r12, r8
mov rbx, r9
imul rbx, rax
add rbx, r12
mul r8
lea r8, [rbx+rdx]
mov rdx, r8
movsxd rax, edi
mov r8, rax
mov r9d, 0
movsxd rax, r10d
mov rax, rax
mov edx, 0
mov r12, r9
imul r12, rax
mov rbx, rdx
imul rbx, r8
add rbx, r12
mul r8
lea r8, [rbx+rdx]
mov rdx, r8
movsxd r8, r11d
mov r8, r8
mov r9d, 0
mov r12, rdx
imul r12, r8
mov rbx, r9
imul rbx, rax
add rbx, r12
mul r8
lea r8, [rbx+rdx]
mov rdx, r8
movsxd rdx, edi
movsxd rax, r10d
imul rdx, rax
movsxd rax, r11d
imul rax, rdx
lea rdx, ds:0[rax*4]
mov eax, 10h
sub rax, 1
add rax, rdx
mov ebx, 10h
mov edx, 0
div rbx
imul rax, 10h
mov rdi, rax
and rdi, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rdi
loc_1347:
cmp rsp, rdx
jz short loc_135E
sub rsp, 1000h
or [rsp+1090h+var_98], 0
jmp short loc_1347
loc_135E:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
mov rdx, rax
and edx, 0FFFh
test rdx, rdx
jz short loc_1388
and eax, 0FFFh
sub rax, 8
add rax, rsp
or qword ptr [rax], 0
loc_1388:
mov rax, rsp
add rax, 3
shr rax, 2
shl rax, 2
mov [rbp+var_30], rax
mov [rbp+var_58], 0
jmp loc_15FA
loc_13A7:
mov [rbp+var_54], 0
jmp loc_15EA
loc_13B3:
mov [rbp+var_50], 0
jmp loc_15D7
loc_13BF:
cmp [rbp+var_58], 0
jz short loc_13D1
cmp [rbp+var_54], 0
jz short loc_13D1
cmp [rbp+var_50], 0
jnz short loc_140F
loc_13D1:
mov rdi, rsi
shr rdi, 2
mov r9, rcx
shr r9, 2
mov rax, [rbp+var_30]
mov edx, [rbp+var_50]
movsxd r8, edx
mov edx, [rbp+var_58]
movsxd rdx, edx
imul rdi, rdx
mov edx, [rbp+var_54]
movsxd rdx, edx
imul rdx, r9
add rdi, r8
add rdx, rdi
mov dword ptr [rax+rdx*4], 0
jmp loc_15D3
loc_140F:
mov eax, [rbp+var_58]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+var_68]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_54]
cdqe
lea rdi, [rax-1]
mov rax, [rbp+var_70]
add rax, rdi
movzx eax, byte ptr [rax]
cmp dl, al
jnz loc_14E4
mov eax, [rbp+var_58]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+var_68]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_50]
cdqe
lea rdi, [rax-1]
mov rax, [rbp+var_78]
add rax, rdi
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_14E4
mov rdi, rsi
shr rdi, 2
mov eax, [rbp+var_58]
lea edx, [rax-1]
mov r9, rcx
shr r9, 2
mov eax, [rbp+var_54]
lea r10d, [rax-1]
mov eax, [rbp+var_50]
lea r8d, [rax-1]
mov rax, [rbp+var_30]
movsxd r8, r8d
movsxd rdx, edx
imul rdi, rdx
movsxd rdx, r10d
imul rdx, r9
add rdi, r8
add rdx, rdi
mov eax, [rax+rdx*4]
mov r8, rsi
shr r8, 2
mov r10, rcx
shr r10, 2
lea edi, [rax+1]
mov rax, [rbp+var_30]
mov edx, [rbp+var_50]
movsxd r9, edx
mov edx, [rbp+var_58]
movsxd rdx, edx
imul r8, rdx
mov edx, [rbp+var_54]
movsxd rdx, edx
imul rdx, r10
add r8, r9
add rdx, r8
mov [rax+rdx*4], edi
jmp loc_15D3
loc_14E4:
mov rdi, rsi
shr rdi, 2
mov r9, rcx
shr r9, 2
mov eax, [rbp+var_54]
lea r10d, [rax-1]
mov rax, [rbp+var_30]
mov edx, [rbp+var_50]
movsxd r8, edx
mov edx, [rbp+var_58]
movsxd rdx, edx
imul rdi, rdx
movsxd rdx, r10d
imul rdx, r9
add rdi, r8
add rdx, rdi
mov edx, [rax+rdx*4]
mov r8, rsi
shr r8, 2
mov eax, [rbp+var_58]
lea r11d, [rax-1]
mov r10, rcx
shr r10, 2
mov rax, [rbp+var_30]
mov edi, [rbp+var_50]
movsxd r9, edi
movsxd rdi, r11d
imul r8, rdi
mov edi, [rbp+var_54]
movsxd rdi, edi
imul rdi, r10
add r8, r9
add rdi, r8
mov eax, [rax+rdi*4]
cmp edx, eax
cmovge eax, edx
mov [rbp+var_4C], eax
mov rdi, rsi
shr rdi, 2
mov r9, rcx
shr r9, 2
mov eax, [rbp+var_50]
lea edx, [rax-1]
mov rax, [rbp+var_30]
movsxd r8, edx
mov edx, [rbp+var_58]
movsxd rdx, edx
imul rdi, rdx
mov edx, [rbp+var_54]
movsxd rdx, edx
imul rdx, r9
add rdi, r8
add rdx, rdi
mov edx, [rax+rdx*4]
mov r8, rsi
shr r8, 2
mov r10, rcx
shr r10, 2
mov eax, [rbp+var_4C]
cmp edx, eax
cmovl edx, eax
mov rax, [rbp+var_30]
mov edi, [rbp+var_50]
movsxd r9, edi
mov edi, [rbp+var_58]
movsxd rdi, edi
imul r8, rdi
mov edi, [rbp+var_54]
movsxd rdi, edi
imul rdi, r10
add r8, r9
add rdi, r8
mov [rax+rdi*4], edx
loc_15D3:
add [rbp+var_50], 1
loc_15D7:
mov eax, [rbp+var_50]
cmp eax, [rbp+var_84]
jle loc_13BF
add [rbp+var_54], 1
loc_15EA:
mov eax, [rbp+var_54]
cmp eax, [rbp+var_80]
jle loc_13B3
add [rbp+var_58], 1
loc_15FA:
mov eax, [rbp+var_58]
cmp eax, [rbp+var_7C]
jle loc_13A7
shr rsi, 2
mov r8, rsi
shr rcx, 2
mov rdi, rcx
mov rax, [rbp+var_30]
mov edx, [rbp+var_84]
movsxd rsi, edx
mov edx, [rbp+var_7C]
movsxd rdx, edx
mov rcx, rdx
imul rcx, r8
mov edx, [rbp+var_80]
movsxd rdx, edx
imul rdx, rdi
add rcx, rsi
add rdx, rcx
mov eax, [rax+rdx*4]
mov rsp, r13
mov rdx, [rbp+var_28]
sub rdx, fs:28h
jz short loc_1658
call ___stack_chk_fail
loc_1658:
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r13
pop rbp
retn | long long func0(long long a1, long long a2, long long a3, int a4, int a5, int a6)
{
int v6; // r11d
unsigned long long v7; // rcx
unsigned long long v8; // rsi
unsigned long long v9; // rax
void *v10; // rsp
int v11; // eax
int v12; // edx
_BYTE v14[12]; // [rsp+8h] [rbp-90h] BYREF
int v15; // [rsp+14h] [rbp-84h]
int v16; // [rsp+18h] [rbp-80h]
int v17; // [rsp+1Ch] [rbp-7Ch]
long long v18; // [rsp+20h] [rbp-78h]
long long v19; // [rsp+28h] [rbp-70h]
long long v20; // [rsp+30h] [rbp-68h]
int i; // [rsp+40h] [rbp-58h]
int j; // [rsp+44h] [rbp-54h]
int k; // [rsp+48h] [rbp-50h]
int v24; // [rsp+4Ch] [rbp-4Ch]
long long v25; // [rsp+50h] [rbp-48h]
long long v26; // [rsp+58h] [rbp-40h]
long long v27; // [rsp+60h] [rbp-38h]
_BYTE *v28; // [rsp+68h] [rbp-30h]
unsigned long long v29; // [rsp+70h] [rbp-28h]
v20 = a1;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
v15 = a6;
v29 = __readfsqword(0x28u);
v6 = a4 + 1;
v25 = a6 + 1 - 1LL;
v7 = 4LL * (a6 + 1);
v26 = a5 + 1 - 1LL;
v8 = 4 * (a6 + 1) * (long long)(a5 + 1);
v27 = v6 - 1LL;
v9 = 16 * ((4 * (a5 + 1) * (long long)(a6 + 1) * v6 + 15) / 0x10uLL);
while ( v14 != &v14[-(v9 & 0xFFFFFFFFFFFFF000LL)] )
;
v10 = alloca(v9 & 0xFFF);
if ( (v9 & 0xFFF) != 0 )
*(_QWORD *)&v14[(v9 & 0xFFF) - 8] = *(_QWORD *)&v14[(v9 & 0xFFF) - 8];
v28 = v14;
for ( i = 0; i <= v17; ++i )
{
for ( j = 0; j <= v16; ++j )
{
for ( k = 0; k <= v15; ++k )
{
if ( i && j && k )
{
if ( *(_BYTE *)(i - 1LL + v20) == *(_BYTE *)(j - 1LL + v19)
&& *(_BYTE *)(i - 1LL + v20) == *(_BYTE *)(k - 1LL + v18) )
{
*(_DWORD *)&v28[4 * k + 4 * i * (v8 >> 2) + 4 * (v7 >> 2) * j] = *(_DWORD *)&v28[4 * k
- 4
+ 4 * (i - 1) * (v8 >> 2)
+ 4 * (v7 >> 2) * (j - 1)]
+ 1;
}
else
{
v11 = *(_DWORD *)&v28[4 * k + 4 * (i - 1) * (v8 >> 2) + 4 * (v7 >> 2) * j];
if ( *(_DWORD *)&v28[4 * k + 4 * i * (v8 >> 2) + 4 * (v7 >> 2) * (j - 1)] >= v11 )
v11 = *(_DWORD *)&v28[4 * k + 4 * i * (v8 >> 2) + 4 * (v7 >> 2) * (j - 1)];
v24 = v11;
v12 = *(_DWORD *)&v28[4 * k - 4 + 4 * i * (v8 >> 2) + 4 * (v7 >> 2) * j];
if ( v12 < v11 )
v12 = v11;
*(_DWORD *)&v28[4 * k + 4 * i * (v8 >> 2) + 4 * (v7 >> 2) * j] = v12;
}
}
else
{
*(_DWORD *)&v28[4 * k + 4 * i * (v8 >> 2) + 4 * (v7 >> 2) * j] = 0;
}
}
}
}
return *(unsigned int *)&v28[4 * v15 + 4 * (v8 >> 2) * v17 + 4 * (v7 >> 2) * v16];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x78],RDX
MOV dword ptr [RBP + -0x7c],ECX
MOV dword ptr [RBP + -0x80],R8D
MOV dword ptr [RBP + -0x84],R9D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV R13,RAX
MOV EAX,dword ptr [RBP + -0x84]
LEA EDI,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x80]
LEA R10D,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x7c]
LEA R11D,[RAX + 0x1]
MOVSXD RAX,EDI
SUB RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
MOVSXD RAX,EDI
LEA RCX,[RAX*0x4]
MOVSXD RAX,R10D
SUB RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOVSXD RAX,EDI
MOV R8,RAX
MOV R9D,0x0
MOVSXD RAX,R10D
MOV RAX,RAX
MOV EDX,0x0
MOV RBX,R9
IMUL RBX,RAX
MOV RSI,RDX
IMUL RSI,R8
ADD RSI,RBX
MUL R8
ADD RSI,RDX
MOV RDX,RSI
MOVSXD RDX,EDI
MOVSXD RAX,R10D
IMUL RAX,RDX
LEA RSI,[RAX*0x4]
MOVSXD RAX,R11D
SUB RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
MOVSXD RAX,EDI
MOV R8,RAX
MOV R9D,0x0
MOVSXD RAX,R10D
MOV RAX,RAX
MOV EDX,0x0
MOV R12,R9
IMUL R12,RAX
MOV RBX,RDX
IMUL RBX,R8
ADD RBX,R12
MUL R8
LEA R8,[RBX + RDX*0x1]
MOV RDX,R8
MOVSXD R8,R11D
MOV R8,R8
MOV R9D,0x0
MOV R12,RDX
IMUL R12,R8
MOV RBX,R9
IMUL RBX,RAX
ADD RBX,R12
MUL R8
LEA R8,[RBX + RDX*0x1]
MOV RDX,R8
MOVSXD RAX,EDI
MOV R8,RAX
MOV R9D,0x0
MOVSXD RAX,R10D
MOV RAX,RAX
MOV EDX,0x0
MOV R12,R9
IMUL R12,RAX
MOV RBX,RDX
IMUL RBX,R8
ADD RBX,R12
MUL R8
LEA R8,[RBX + RDX*0x1]
MOV RDX,R8
MOVSXD R8,R11D
MOV R8,R8
MOV R9D,0x0
MOV R12,RDX
IMUL R12,R8
MOV RBX,R9
IMUL RBX,RAX
ADD RBX,R12
MUL R8
LEA R8,[RBX + RDX*0x1]
MOV RDX,R8
MOVSXD RDX,EDI
MOVSXD RAX,R10D
IMUL RDX,RAX
MOVSXD RAX,R11D
IMUL RAX,RDX
LEA RDX,[RAX*0x4]
MOV EAX,0x10
SUB RAX,0x1
ADD RAX,RDX
MOV EBX,0x10
MOV EDX,0x0
DIV RBX
IMUL RAX,RAX,0x10
MOV RDI,RAX
AND RDI,-0x1000
MOV RDX,RSP
SUB RDX,RDI
LAB_00101347:
CMP RSP,RDX
JZ 0x0010135e
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x00101347
LAB_0010135e:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
MOV RDX,RAX
AND EDX,0xfff
TEST RDX,RDX
JZ 0x00101388
AND EAX,0xfff
SUB RAX,0x8
ADD RAX,RSP
OR qword ptr [RAX],0x0
LAB_00101388:
MOV RAX,RSP
ADD RAX,0x3
SHR RAX,0x2
SHL RAX,0x2
MOV qword ptr [RBP + -0x30],RAX
MOV dword ptr [RBP + -0x58],0x0
JMP 0x001015fa
LAB_001013a7:
MOV dword ptr [RBP + -0x54],0x0
JMP 0x001015ea
LAB_001013b3:
MOV dword ptr [RBP + -0x50],0x0
JMP 0x001015d7
LAB_001013bf:
CMP dword ptr [RBP + -0x58],0x0
JZ 0x001013d1
CMP dword ptr [RBP + -0x54],0x0
JZ 0x001013d1
CMP dword ptr [RBP + -0x50],0x0
JNZ 0x0010140f
LAB_001013d1:
MOV RDI,RSI
SHR RDI,0x2
MOV R9,RCX
SHR R9,0x2
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x50]
MOVSXD R8,EDX
MOV EDX,dword ptr [RBP + -0x58]
MOVSXD RDX,EDX
IMUL RDI,RDX
MOV EDX,dword ptr [RBP + -0x54]
MOVSXD RDX,EDX
IMUL RDX,R9
ADD RDI,R8
ADD RDX,RDI
MOV dword ptr [RAX + RDX*0x4],0x0
JMP 0x001015d3
LAB_0010140f:
MOV EAX,dword ptr [RBP + -0x58]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x54]
CDQE
LEA RDI,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,RDI
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x001014e4
MOV EAX,dword ptr [RBP + -0x58]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x50]
CDQE
LEA RDI,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RDI
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x001014e4
MOV RDI,RSI
SHR RDI,0x2
MOV EAX,dword ptr [RBP + -0x58]
LEA EDX,[RAX + -0x1]
MOV R9,RCX
SHR R9,0x2
MOV EAX,dword ptr [RBP + -0x54]
LEA R10D,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0x50]
LEA R8D,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD R8,R8D
MOVSXD RDX,EDX
IMUL RDI,RDX
MOVSXD RDX,R10D
IMUL RDX,R9
ADD RDI,R8
ADD RDX,RDI
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV R8,RSI
SHR R8,0x2
MOV R10,RCX
SHR R10,0x2
LEA EDI,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x50]
MOVSXD R9,EDX
MOV EDX,dword ptr [RBP + -0x58]
MOVSXD RDX,EDX
IMUL R8,RDX
MOV EDX,dword ptr [RBP + -0x54]
MOVSXD RDX,EDX
IMUL RDX,R10
ADD R8,R9
ADD RDX,R8
MOV dword ptr [RAX + RDX*0x4],EDI
JMP 0x001015d3
LAB_001014e4:
MOV RDI,RSI
SHR RDI,0x2
MOV R9,RCX
SHR R9,0x2
MOV EAX,dword ptr [RBP + -0x54]
LEA R10D,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x50]
MOVSXD R8,EDX
MOV EDX,dword ptr [RBP + -0x58]
MOVSXD RDX,EDX
IMUL RDI,RDX
MOVSXD RDX,R10D
IMUL RDX,R9
ADD RDI,R8
ADD RDX,RDI
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV R8,RSI
SHR R8,0x2
MOV EAX,dword ptr [RBP + -0x58]
LEA R11D,[RAX + -0x1]
MOV R10,RCX
SHR R10,0x2
MOV RAX,qword ptr [RBP + -0x30]
MOV EDI,dword ptr [RBP + -0x50]
MOVSXD R9,EDI
MOVSXD RDI,R11D
IMUL R8,RDI
MOV EDI,dword ptr [RBP + -0x54]
MOVSXD RDI,EDI
IMUL RDI,R10
ADD R8,R9
ADD RDI,R8
MOV EAX,dword ptr [RAX + RDI*0x4]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RBP + -0x4c],EAX
MOV RDI,RSI
SHR RDI,0x2
MOV R9,RCX
SHR R9,0x2
MOV EAX,dword ptr [RBP + -0x50]
LEA EDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD R8,EDX
MOV EDX,dword ptr [RBP + -0x58]
MOVSXD RDX,EDX
IMUL RDI,RDX
MOV EDX,dword ptr [RBP + -0x54]
MOVSXD RDX,EDX
IMUL RDX,R9
ADD RDI,R8
ADD RDX,RDI
MOV EDX,dword ptr [RAX + RDX*0x4]
MOV R8,RSI
SHR R8,0x2
MOV R10,RCX
SHR R10,0x2
MOV EAX,dword ptr [RBP + -0x4c]
CMP EDX,EAX
CMOVL EDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EDI,dword ptr [RBP + -0x50]
MOVSXD R9,EDI
MOV EDI,dword ptr [RBP + -0x58]
MOVSXD RDI,EDI
IMUL R8,RDI
MOV EDI,dword ptr [RBP + -0x54]
MOVSXD RDI,EDI
IMUL RDI,R10
ADD R8,R9
ADD RDI,R8
MOV dword ptr [RAX + RDI*0x4],EDX
LAB_001015d3:
ADD dword ptr [RBP + -0x50],0x1
LAB_001015d7:
MOV EAX,dword ptr [RBP + -0x50]
CMP EAX,dword ptr [RBP + -0x84]
JLE 0x001013bf
ADD dword ptr [RBP + -0x54],0x1
LAB_001015ea:
MOV EAX,dword ptr [RBP + -0x54]
CMP EAX,dword ptr [RBP + -0x80]
JLE 0x001013b3
ADD dword ptr [RBP + -0x58],0x1
LAB_001015fa:
MOV EAX,dword ptr [RBP + -0x58]
CMP EAX,dword ptr [RBP + -0x7c]
JLE 0x001013a7
SHR RSI,0x2
MOV R8,RSI
SHR RCX,0x2
MOV RDI,RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x84]
MOVSXD RSI,EDX
MOV EDX,dword ptr [RBP + -0x7c]
MOVSXD RDX,EDX
MOV RCX,RDX
IMUL RCX,R8
MOV EDX,dword ptr [RBP + -0x80]
MOVSXD RDX,EDX
IMUL RDX,RDI
ADD RCX,RSI
ADD RDX,RCX
MOV EAX,dword ptr [RAX + RDX*0x4]
MOV RSP,R13
MOV RDX,qword ptr [RBP + -0x28]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101658
CALL 0x00101080
LAB_00101658:
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R13
POP RBP
RET | int4 func0(long param_1,long param_2,long param_3,int param_4,int param_5,int param_6)
{
long lVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
int *puVar6;
long in_FS_OFFSET;
int auStack_98 [12];
int local_8c;
int local_88;
int local_84;
long local_80;
long local_78;
long local_70;
int local_60;
int local_5c;
int local_58;
int local_54;
long local_50;
long local_48;
long local_40;
int *local_38;
long local_30;
local_70 = param_1;
local_78 = param_2;
local_80 = param_3;
local_84 = param_4;
local_88 = param_5;
local_8c = param_6;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
param_6 = param_6 + 1;
param_5 = param_5 + 1;
local_50 = (long)param_6 + -1;
uVar3 = (ulong)param_6;
local_48 = (long)param_5 + -1;
uVar4 = (long)param_5 * (long)param_6;
local_40 = (long)(param_4 + 1) + -1;
uVar5 = (((long)(param_4 + 1) * (long)param_6 * (long)param_5 * 4 + 0xfU) / 0x10) * 0x10;
for (puVar6 = auStack_98; puVar6 != auStack_98 + -(uVar5 & 0xfffffffffffff000);
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
lVar1 = -(ulong)((uint)uVar5 & 0xfff);
if ((uVar5 & 0xfff) != 0) {
*(int8 *)(puVar6 + ((ulong)((uint)uVar5 & 0xfff) - 8) + lVar1) =
*(int8 *)(puVar6 + ((ulong)((uint)uVar5 & 0xfff) - 8) + lVar1);
}
for (local_60 = 0; local_60 <= local_84; local_60 = local_60 + 1) {
for (local_5c = 0; local_5c <= local_88; local_5c = local_5c + 1) {
for (local_58 = 0; local_58 <= local_8c; local_58 = local_58 + 1) {
if (((local_60 == 0) || (local_5c == 0)) || (local_58 == 0)) {
*(int4 *)
(puVar6 + ((long)local_5c * (uVar3 & 0x3fffffffffffffff) +
(uVar4 & 0x3fffffffffffffff) * (long)local_60 + (long)local_58) * 4 + lVar1) =
0;
}
else if ((*(char *)(local_70 + (long)local_60 + -1) ==
*(char *)(local_78 + (long)local_5c + -1)) &&
(*(char *)(local_70 + (long)local_60 + -1) ==
*(char *)(local_80 + (long)local_58 + -1))) {
*(int *)(puVar6 + ((long)local_5c * (uVar3 & 0x3fffffffffffffff) +
(uVar4 & 0x3fffffffffffffff) * (long)local_60 + (long)local_58) * 4 +
lVar1) =
*(int *)(puVar6 + ((long)(local_5c + -1) * (uVar3 & 0x3fffffffffffffff) +
(uVar4 & 0x3fffffffffffffff) * (long)(local_60 + -1) +
(long)(local_58 + -1)) * 4 + lVar1) + 1;
}
else {
local_54 = *(int *)(puVar6 + ((long)local_5c * (uVar3 & 0x3fffffffffffffff) +
(uVar4 & 0x3fffffffffffffff) * (long)(local_60 + -1) +
(long)local_58) * 4 + lVar1);
if (*(int *)(puVar6 + ((long)local_5c * (uVar3 & 0x3fffffffffffffff) +
(uVar4 & 0x3fffffffffffffff) * (long)(local_60 + -1) +
(long)local_58) * 4 + lVar1) <=
*(int *)(puVar6 + ((long)(local_5c + -1) * (uVar3 & 0x3fffffffffffffff) +
(uVar4 & 0x3fffffffffffffff) * (long)local_60 + (long)local_58) * 4
+ lVar1)) {
local_54 = *(int *)(puVar6 + ((long)(local_5c + -1) * (uVar3 & 0x3fffffffffffffff) +
(uVar4 & 0x3fffffffffffffff) * (long)local_60 +
(long)local_58) * 4 + lVar1);
}
iVar2 = *(int *)(puVar6 + ((long)local_5c * (uVar3 & 0x3fffffffffffffff) +
(uVar4 & 0x3fffffffffffffff) * (long)local_60 +
(long)(local_58 + -1)) * 4 + lVar1);
if (*(int *)(puVar6 + ((long)local_5c * (uVar3 & 0x3fffffffffffffff) +
(uVar4 & 0x3fffffffffffffff) * (long)local_60 +
(long)(local_58 + -1)) * 4 + lVar1) < local_54) {
iVar2 = local_54;
}
*(int *)(puVar6 + ((long)local_5c * (uVar3 & 0x3fffffffffffffff) +
(uVar4 & 0x3fffffffffffffff) * (long)local_60 + (long)local_58) * 4 +
lVar1) = iVar2;
}
}
}
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
local_38 = puVar6 + lVar1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return *(int4 *)
(puVar6 + ((long)local_88 * (uVar3 & 0x3fffffffffffffff) +
(long)local_84 * (uVar4 & 0x3fffffffffffffff) + (long)local_8c) * 4 + lVar1);
} |
6,881 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(char* X, char* Y, char* Z, int m, int n, int o) {
int L[m+1][n+1][o+1];
int i, j, k;
for (i = 0; i <= m; i++) {
for (j = 0; j <= n; j++) {
for (k = 0; k <= o; k++) {
if (i == 0 || j == 0 || k == 0) {
L[i][j][k] = 0;
} else if (X[i-1] == Y[j-1] && X[i-1] == Z[k-1]) {
L[i][j][k] = L[i-1][j-1][k-1] + 1;
} else {
int max1 = L[i-1][j][k] > L[i][j-1][k] ? L[i-1][j][k] : L[i][j-1][k];
L[i][j][k] = max1 > L[i][j][k-1] ? max1 : L[i][j][k-1];
}
}
}
}
return L[m][n][o];
}
| int main() {
// Testing the implementation with assertions
assert(func0("AGGT12", "12TXAYB", "12XBA", 6, 7, 5) == 2);
assert(func0("Reels", "Reelsfor", "ReelsforReels", 5, 8, 13) == 5);
assert(func0("abcd1e2", "bc12ea", "bd1ea", 7, 6, 5) == 3);
printf("All tests passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0xa8,%rsp
mov %rdi,%r13
mov %rsi,%r14
mov %rdx,-0x70(%rbp)
mov %ecx,-0xbc(%rbp)
mov %r8d,-0x50(%rbp)
mov %r9d,%eax
mov %r9d,-0x4c(%rbp)
mov %fs:0x28,%rbx
mov %rbx,-0x38(%rbp)
xor %ebx,%ebx
add $0x1,%eax
movslq %eax,%rdx
lea 0x0(,%rdx,4),%r11
lea 0x1(%r8),%eax
cltq
imul %rdx,%rax
lea 0x0(,%rax,4),%rbx
mov %rbx,-0xb8(%rbp)
lea 0x1(%rcx),%edx
movslq %edx,%rdx
imul %rdx,%rax
lea 0xf(,%rax,4),%rdx
mov %rdx,%rax
and $0xfffffffffffffff0,%rax
and $0xfffffffffffff000,%rdx
mov %rsp,%rbx
sub %rdx,%rbx
mov %rbx,%rdx
cmp %rdx,%rsp
je 1232 <func0+0xa9>
sub $0x1000,%rsp
orq $0x0,0xff8(%rsp)
jmp 121b <func0+0x92>
mov %rax,%rdx
and $0xfff,%edx
sub %rdx,%rsp
test %rdx,%rdx
je 1249 <func0+0xc0>
orq $0x0,-0x8(%rsp,%rdx,1)
mov %rsp,%rsi
mov %rsi,-0xc8(%rbp)
mov -0xbc(%rbp),%ecx
test %ecx,%ecx
js 1409 <func0+0x280>
mov -0xb8(%rbp),%rbx
shr $0x2,%rbx
mov %rbx,-0x98(%rbp)
mov %r11,%rax
shr $0x2,%rax
mov %rbx,%rdi
neg %rdi
mov %rdi,-0x80(%rbp)
sub $0x1,%r13
mov %ecx,%ecx
mov %rcx,-0xa0(%rbp)
mov %rsi,-0xa8(%rbp)
sub %r11,%rsi
mov %rsi,-0xb0(%rbp)
mov %rdi,-0x90(%rbp)
movq $0x0,-0x88(%rbp)
movq $0x0,-0x78(%rbp)
mov $0x0,%esi
mov -0x50(%rbp),%edi
mov %rdi,-0x58(%rbp)
add %rbx,%rax
shl $0x2,%rax
mov %rax,-0x60(%rbp)
mov -0x4c(%rbp),%edi
movq $0x0,-0x68(%rbp)
jmpq 13ba <func0+0x231>
movl $0x0,(%r8,%rax,4)
lea 0x1(%rax),%rdx
cmp %rax,%rdi
je 1352 <func0+0x1c9>
mov %rdx,%rax
test %esi,%esi
sete %r15b
test %ecx,%ecx
sete %dl
or %dl,%r15b
jne 12e3 <func0+0x15a>
test %eax,%eax
je 12e3 <func0+0x15a>
movzbl 0x0(%r13),%edx
cmp -0x1(%r14,%rcx,1),%dl
je 1335 <func0+0x1ac>
mov (%rbx,%rax,4),%edx
cmp %edx,(%r10,%rax,4)
cmovge (%r10,%rax,4),%edx
mov -0x4(%r9,%rax,4),%r15d
cmp %r15d,%edx
cmovl %r15d,%edx
mov %edx,(%r9,%rax,4)
jmp 12eb <func0+0x162>
mov -0x70(%rbp),%r15
cmp -0x1(%r15,%rax,1),%dl
jne 1317 <func0+0x18e>
mov -0x4(%r12,%rax,4),%edx
add $0x1,%edx
mov -0x48(%rbp),%r15
mov %edx,(%r15,%rax,4)
jmp 12eb <func0+0x162>
lea 0x1(%rcx),%rax
add %r11,%r8
add %r11,%r12
add %r11,%r10
add %r11,%rbx
add %r11,%r9
cmp -0x58(%rbp),%rcx
je 1389 <func0+0x200>
mov %rax,%rcx
mov -0x60(%rbp),%rax
add %r12,%rax
mov %rax,-0x48(%rbp)
mov -0x68(%rbp),%rax
cmpl $0x0,-0x4c(%rbp)
jns 12f7 <func0+0x16e>
jmp 1352 <func0+0x1c9>
lea 0x1(%rsi),%rax
mov -0x98(%rbp),%rbx
add %rbx,-0x78(%rbp)
add %rbx,-0x80(%rbp)
add %rbx,-0x88(%rbp)
add %rbx,-0x90(%rbp)
add $0x1,%r13
cmp -0xa0(%rbp),%rsi
je 1409 <func0+0x280>
mov %rax,%rsi
cmpl $0x0,-0x50(%rbp)
js 1389 <func0+0x200>
mov -0xa8(%rbp),%rax
mov -0x78(%rbp),%rbx
lea (%rax,%rbx,4),%r8
mov -0xb0(%rbp),%rbx
mov -0x80(%rbp),%rcx
lea (%rbx,%rcx,4),%r12
mov -0x88(%rbp),%rcx
lea 0x0(,%rcx,4),%r9
lea (%rbx,%r9,1),%r10
mov -0x90(%rbp),%rbx
lea (%rax,%rbx,4),%rbx
add %rax,%r9
mov $0x0,%ecx
jmpq 136e <func0+0x1e5>
movslq -0x4c(%rbp),%rax
movslq -0xbc(%rbp),%rcx
mov -0xb8(%rbp),%rdx
shr $0x2,%rdx
imul %rdx,%rcx
movslq -0x50(%rbp),%rdx
shr $0x2,%r11
imul %rdx,%r11
add %rcx,%rax
add %r11,%rax
mov -0xc8(%rbp),%rbx
mov (%rbx,%rax,4),%eax
mov -0x38(%rbp),%rbx
xor %fs:0x28,%rbx
jne 145d <func0+0x2d4>
lea -0x28(%rbp),%rsp
pop %rbx
pop %r12
pop %r13
pop %r14
pop %r15
pop %rbp
retq
callq 1080 <__stack_chk_fail@plt>
| func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov rbx, rdi
mov r14, rsi
mov [rbp+var_70], rdx
mov [rbp+var_BC], ecx
mov [rbp+var_58], r8d
mov [rbp+var_54], r9d
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea edx, [r9+1]
movsxd rdx, edx
lea rax, ds:0[rdx*4]
mov [rbp+var_50], rax
lea eax, [r8+1]
cdqe
imul rax, rdx
lea rdi, ds:0[rax*4]
mov [rbp+var_B8], rdi
lea edx, [rcx+1]
movsxd rdx, edx
imul rax, rdx
lea rdx, ds:0Fh[rax*4]
mov rax, rdx
and rax, 0FFFFFFFFFFFFFFF0h
and rdx, 0FFFFFFFFFFFFF000h
mov rcx, rsp
sub rcx, rdx
loc_121A:
cmp rsp, rcx
jz short loc_1231
sub rsp, 1000h
or [rsp+10C0h+var_C8], 0
jmp short loc_121A
loc_1231:
mov rdx, rax
and edx, 0FFFh
sub rsp, rdx
test rdx, rdx
jz short loc_1248
or [rsp+rdx+0C0h+var_C8], 0
loc_1248:
mov rcx, rsp
mov [rbp+var_A8], rcx
mov r11d, [rbp+var_BC]
test r11d, r11d
js loc_140A
mov rax, [rbp+var_B8]
shr rax, 2
mov [rbp+var_78], rax
mov rsi, [rbp+var_50]
mov rdx, rsi
shr rdx, 2
mov rdi, rax
neg rdi
mov [rbp+var_88], rdi
sub rbx, 1
lea edi, [r11+1]
mov [rbp+var_A0], rdi
sub rcx, rsi
mov [rbp+var_B0], rcx
mov [rbp+var_98], 0
mov [rbp+var_90], 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], 0
mov edi, 0
mov esi, [rbp+var_58]
lea esi, [rsi+1]
mov [rbp+var_60], rsi
add rax, rdx
shl rax, 2
mov [rbp+var_68], rax
mov eax, [rbp+var_54]
lea r8d, [rax+1]
neg rdx
mov r13, rdx
jmp loc_13BF
loc_12EC:
mov dword ptr [r9+rax*4], 0
loc_12F4:
add rax, 1
add rdx, 4
cmp rax, r8
jz short loc_135A
loc_1301:
test edi, edi
setz cl
test esi, esi
setz r15b
or cl, r15b
jnz short loc_12EC
test eax, eax
jz short loc_12EC
movzx ecx, byte ptr [rbx]
cmp cl, [r14+rsi-1]
jz short loc_133D
loc_131F:
mov ecx, [rdx+r13*4]
mov r15d, [rdx+r12*4]
cmp ecx, r15d
cmovl ecx, r15d
mov r15d, [rdx-4]
cmp ecx, r15d
cmovl ecx, r15d
mov [rdx], ecx
jmp short loc_12F4
loc_133D:
mov r15, [rbp+var_70]
cmp cl, [r15+rax-1]
jnz short loc_131F
mov ecx, [r10+rax*4-4]
add ecx, 1
mov r15, [rbp+var_48]
mov [r15+rax*4], ecx
jmp short loc_12F4
loc_135A:
add rsi, 1
mov rax, [rbp+var_50]
add r9, rax
add r10, rax
add r11, rax
cmp rsi, [rbp+var_60]
jz short loc_1390
loc_1371:
mov rax, [rbp+var_68]
add rax, r10
mov [rbp+var_48], rax
mov rdx, r11
mov eax, 0
cmp [rbp+var_54], 0
jns loc_1301
jmp short loc_135A
loc_1390:
add rdi, 1
mov rax, [rbp+var_78]
add [rbp+var_80], rax
add [rbp+var_88], rax
add [rbp+var_90], 1
add rbx, 1
add [rbp+var_98], rax
cmp rdi, [rbp+var_A0]
jz short loc_140A
loc_13BF:
cmp [rbp+var_58], 0
js short loc_1390
mov rax, [rbp+var_A8]
mov rsi, [rbp+var_80]
lea r9, [rax+rsi*4]
mov rsi, [rbp+var_B0]
mov rdx, [rbp+var_88]
lea r10, [rsi+rdx*4]
mov rsi, [rbp+var_98]
lea r11, [rax+rsi*4]
mov r12, [rbp+var_90]
sub r12, rdi
imul r12, [rbp+var_78]
mov esi, 0
jmp loc_1371
loc_140A:
movsxd rdx, [rbp+var_54]
movsxd rsi, [rbp+var_BC]
mov rax, [rbp+var_B8]
shr rax, 2
imul rsi, rax
movsxd rcx, [rbp+var_58]
mov rax, [rbp+var_50]
shr rax, 2
imul rcx, rax
lea rax, [rdx+rsi]
add rax, rcx
mov rbx, [rbp+var_A8]
mov eax, [rbx+rax*4]
mov rdx, [rbp+var_38]
sub rdx, fs:28h
jnz short loc_1463
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1463:
call ___stack_chk_fail | long long func0(long long a1, long long a2, long long a3, int a4, int a5, int a6)
{
long long v7; // rdx
long long v8; // rax
long long v9; // rdx
__int16 v10; // ax
signed long long v11; // rdx
void *v12; // rsp
_BYTE *v13; // rbx
long long v14; // rdi
long long v15; // r8
long long v16; // r13
long long v17; // rax
_DWORD *v18; // rdx
int v19; // ecx
long long v20; // rsi
_BYTE *v21; // r9
_BYTE *v22; // r10
_DWORD *v23; // r11
long long v24; // r12
_BYTE v27[4]; // [rsp+8h] [rbp-C0h] BYREF
int v28; // [rsp+Ch] [rbp-BCh]
unsigned long long v29; // [rsp+10h] [rbp-B8h]
_BYTE *v30; // [rsp+18h] [rbp-B0h]
_BYTE *v31; // [rsp+20h] [rbp-A8h]
long long v32; // [rsp+28h] [rbp-A0h]
long long v33; // [rsp+30h] [rbp-98h]
long long v34; // [rsp+38h] [rbp-90h]
long long v35; // [rsp+40h] [rbp-88h]
long long v36; // [rsp+48h] [rbp-80h]
unsigned long long v37; // [rsp+50h] [rbp-78h]
long long v38; // [rsp+58h] [rbp-70h]
long long v39; // [rsp+60h] [rbp-68h]
long long v40; // [rsp+68h] [rbp-60h]
int v41; // [rsp+70h] [rbp-58h]
int v42; // [rsp+74h] [rbp-54h]
unsigned long long v43; // [rsp+78h] [rbp-50h]
_BYTE *v44; // [rsp+80h] [rbp-48h]
unsigned long long v45; // [rsp+90h] [rbp-38h]
v38 = a3;
v28 = a4;
v41 = a5;
v42 = a6;
v45 = __readfsqword(0x28u);
v7 = a6 + 1;
v43 = 4 * v7;
v8 = v7 * (a5 + 1);
v29 = 4 * v8;
v9 = 4 * (a4 + 1) * v8 + 15;
v10 = (4 * (a4 + 1) * v8 + 15) & 0xFFF0;
while ( v27 != &v27[-(v9 & 0xFFFFFFFFFFFFF000LL)] )
;
v11 = v10 & 0xFFF;
v12 = alloca(v11);
if ( (v10 & 0xFFF) != 0 )
*(_QWORD *)&v27[v11 - 8] = *(_QWORD *)&v27[v11 - 8];
v31 = v27;
if ( v28 >= 0 )
{
v37 = v29 >> 2;
v35 = -(long long)(v29 >> 2);
v13 = (_BYTE *)(a1 - 1);
v32 = (unsigned int)(v28 + 1);
v30 = &v27[-v43];
v33 = 0LL;
v34 = -1LL;
v36 = 0LL;
v14 = 0LL;
v40 = (unsigned int)(v41 + 1);
v39 = 4 * ((v43 >> 2) + (v29 >> 2));
v15 = (unsigned int)(v42 + 1);
v16 = -(long long)(v43 >> 2);
do
{
if ( v41 >= 0 )
{
v21 = &v31[4 * v36];
v22 = &v30[4 * v35];
v23 = &v31[4 * v33];
v24 = v37 * (v34 - v14);
v20 = 0LL;
do
{
v44 = &v22[v39];
v18 = v23;
v17 = 0LL;
if ( v42 >= 0 )
{
do
{
if ( (_DWORD)v20 == 0 || (_DWORD)v14 == 0 || !(_DWORD)v17 )
{
*(_DWORD *)&v21[4 * v17] = 0;
}
else if ( *v13 == *(_BYTE *)(a2 + v20 - 1) && *v13 == *(_BYTE *)(v38 + v17 - 1) )
{
*(_DWORD *)&v44[4 * v17] = *(_DWORD *)&v22[4 * v17 - 4] + 1;
}
else
{
v19 = v18[v16];
if ( v19 < v18[v24] )
v19 = v18[v24];
if ( v19 < *(v18 - 1) )
v19 = *(v18 - 1);
*v18 = v19;
}
++v17;
++v18;
}
while ( v17 != v15 );
}
++v20;
v21 += v43;
v22 += v43;
v23 = (_DWORD *)((char *)v23 + v43);
}
while ( v20 != v40 );
}
++v14;
v36 += v37;
v35 += v37;
++v34;
++v13;
v33 += v37;
}
while ( v14 != v32 );
}
return *(unsigned int *)&v31[4 * (v43 >> 2) * v41 + 4 * v42 + 4 * (v29 >> 2) * v28];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV RBX,RDI
MOV R14,RSI
MOV qword ptr [RBP + -0x70],RDX
MOV dword ptr [RBP + -0xbc],ECX
MOV dword ptr [RBP + -0x58],R8D
MOV dword ptr [RBP + -0x54],R9D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA EDX,[R9 + 0x1]
MOVSXD RDX,EDX
LEA RAX,[RDX*0x4]
MOV qword ptr [RBP + -0x50],RAX
LEA EAX,[R8 + 0x1]
CDQE
IMUL RAX,RDX
LEA RDI,[RAX*0x4]
MOV qword ptr [RBP + -0xb8],RDI
LEA EDX,[RCX + 0x1]
MOVSXD RDX,EDX
IMUL RAX,RDX
LEA RDX,[0xf + RAX*0x4]
MOV RAX,RDX
AND RAX,-0x10
AND RDX,-0x1000
MOV RCX,RSP
SUB RCX,RDX
LAB_0010121a:
CMP RSP,RCX
JZ 0x00101231
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0x0
JMP 0x0010121a
LAB_00101231:
MOV RDX,RAX
AND EDX,0xfff
SUB RSP,RDX
TEST RDX,RDX
JZ 0x00101248
OR qword ptr [RSP + RDX*0x1 + -0x8],0x0
LAB_00101248:
MOV RCX,RSP
MOV qword ptr [RBP + -0xa8],RCX
MOV R11D,dword ptr [RBP + -0xbc]
TEST R11D,R11D
JS 0x0010140a
MOV RAX,qword ptr [RBP + -0xb8]
SHR RAX,0x2
MOV qword ptr [RBP + -0x78],RAX
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,RSI
SHR RDX,0x2
MOV RDI,RAX
NEG RDI
MOV qword ptr [RBP + -0x88],RDI
SUB RBX,0x1
LEA EDI,[R11 + 0x1]
MOV qword ptr [RBP + -0xa0],RDI
SUB RCX,RSI
MOV qword ptr [RBP + -0xb0],RCX
MOV qword ptr [RBP + -0x98],0x0
MOV qword ptr [RBP + -0x90],-0x1
MOV qword ptr [RBP + -0x80],0x0
MOV EDI,0x0
MOV ESI,dword ptr [RBP + -0x58]
LEA ESI,[RSI + 0x1]
MOV qword ptr [RBP + -0x60],RSI
ADD RAX,RDX
SHL RAX,0x2
MOV qword ptr [RBP + -0x68],RAX
MOV EAX,dword ptr [RBP + -0x54]
LEA R8D,[RAX + 0x1]
NEG RDX
MOV R13,RDX
JMP 0x001013bf
LAB_001012ec:
MOV dword ptr [R9 + RAX*0x4],0x0
LAB_001012f4:
ADD RAX,0x1
ADD RDX,0x4
CMP RAX,R8
JZ 0x0010135a
LAB_00101301:
TEST EDI,EDI
SETZ CL
TEST ESI,ESI
SETZ R15B
OR CL,R15B
JNZ 0x001012ec
TEST EAX,EAX
JZ 0x001012ec
MOVZX ECX,byte ptr [RBX]
CMP CL,byte ptr [R14 + RSI*0x1 + -0x1]
JZ 0x0010133d
LAB_0010131f:
MOV ECX,dword ptr [RDX + R13*0x4]
MOV R15D,dword ptr [RDX + R12*0x4]
CMP ECX,R15D
CMOVL ECX,R15D
MOV R15D,dword ptr [RDX + -0x4]
CMP ECX,R15D
CMOVL ECX,R15D
MOV dword ptr [RDX],ECX
JMP 0x001012f4
LAB_0010133d:
MOV R15,qword ptr [RBP + -0x70]
CMP CL,byte ptr [R15 + RAX*0x1 + -0x1]
JNZ 0x0010131f
MOV ECX,dword ptr [R10 + RAX*0x4 + -0x4]
ADD ECX,0x1
MOV R15,qword ptr [RBP + -0x48]
MOV dword ptr [R15 + RAX*0x4],ECX
JMP 0x001012f4
LAB_0010135a:
ADD RSI,0x1
MOV RAX,qword ptr [RBP + -0x50]
ADD R9,RAX
ADD R10,RAX
ADD R11,RAX
CMP RSI,qword ptr [RBP + -0x60]
JZ 0x00101390
LAB_00101371:
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,R10
MOV qword ptr [RBP + -0x48],RAX
MOV RDX,R11
MOV EAX,0x0
CMP dword ptr [RBP + -0x54],0x0
JNS 0x00101301
JMP 0x0010135a
LAB_00101390:
ADD RDI,0x1
MOV RAX,qword ptr [RBP + -0x78]
ADD qword ptr [RBP + -0x80],RAX
ADD qword ptr [RBP + -0x88],RAX
ADD qword ptr [RBP + -0x90],0x1
ADD RBX,0x1
ADD qword ptr [RBP + -0x98],RAX
CMP RDI,qword ptr [RBP + -0xa0]
JZ 0x0010140a
LAB_001013bf:
CMP dword ptr [RBP + -0x58],0x0
JS 0x00101390
MOV RAX,qword ptr [RBP + -0xa8]
MOV RSI,qword ptr [RBP + -0x80]
LEA R9,[RAX + RSI*0x4]
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDX,qword ptr [RBP + -0x88]
LEA R10,[RSI + RDX*0x4]
MOV RSI,qword ptr [RBP + -0x98]
LEA R11,[RAX + RSI*0x4]
MOV R12,qword ptr [RBP + -0x90]
SUB R12,RDI
IMUL R12,qword ptr [RBP + -0x78]
MOV ESI,0x0
JMP 0x00101371
LAB_0010140a:
MOVSXD RDX,dword ptr [RBP + -0x54]
MOVSXD RSI,dword ptr [RBP + -0xbc]
MOV RAX,qword ptr [RBP + -0xb8]
SHR RAX,0x2
IMUL RSI,RAX
MOVSXD RCX,dword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x2
IMUL RCX,RAX
LEA RAX,[RDX + RSI*0x1]
ADD RAX,RCX
MOV RBX,qword ptr [RBP + -0xa8]
MOV EAX,dword ptr [RBX + RAX*0x4]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101463
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00101463:
CALL 0x00101080 | int4 func0(long param_1,long param_2,long param_3,int param_4,int param_5,int param_6)
{
long lVar1;
ulong uVar2;
int iVar3;
int *piVar4;
char *pcVar5;
int1 *puVar6;
ulong uVar7;
ulong uVar8;
int1 *puVar9;
int1 *puVar10;
int *piVar11;
long in_FS_OFFSET;
int1 auStack_c8 [4];
int local_c4;
ulong local_c0;
int1 *local_b8;
int1 *local_b0;
ulong local_a8;
long local_a0;
long local_98;
long local_90;
long local_88;
ulong local_80;
long local_78;
long local_70;
ulong local_68;
int local_60;
int local_5c;
ulong local_58;
int1 *local_50;
long local_40;
local_78 = param_3;
local_c4 = param_4;
local_60 = param_5;
local_5c = param_6;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = (long)(param_6 + 1) * 4;
lVar1 = (long)(param_5 + 1) * (long)(param_6 + 1);
local_c0 = lVar1 * 4;
uVar8 = lVar1 * (param_4 + 1) * 4 + 0xf;
for (puVar6 = auStack_c8; puVar6 != auStack_c8 + -(uVar8 & 0xfffffffffffff000);
puVar6 = puVar6 + -0x1000) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
uVar8 = (ulong)((uint)uVar8 & 0xff0);
lVar1 = -uVar8;
if (uVar8 != 0) {
*(int8 *)(puVar6 + -8) = *(int8 *)(puVar6 + -8);
}
if (-1 < local_c4) {
local_80 = local_c0 >> 2;
local_90 = -local_80;
pcVar5 = (char *)(param_1 + -1);
local_a8 = (ulong)(local_c4 + 1);
local_b8 = puVar6 + (lVar1 - local_58);
local_a0 = 0;
local_98 = -1;
local_88 = 0;
uVar8 = 0;
local_68 = (ulong)(local_60 + 1);
local_70 = (local_80 + (local_58 >> 2)) * 4;
do {
if (-1 < local_60) {
puVar9 = puVar6 + local_88 * 4 + lVar1;
puVar10 = local_b8 + local_90 * 4;
piVar11 = (int *)(puVar6 + local_a0 * 4 + lVar1);
uVar7 = 0;
do {
local_50 = puVar10 + local_70;
uVar2 = 0;
piVar4 = piVar11;
if (-1 < local_5c) {
do {
if (((int)uVar8 == 0 || (int)uVar7 == 0) || ((int)uVar2 == 0)) {
*(int4 *)(puVar9 + uVar2 * 4) = 0;
}
else if ((*pcVar5 == *(char *)(param_2 + -1 + uVar7)) &&
(*pcVar5 == *(char *)(local_78 + -1 + uVar2))) {
*(int *)(local_50 + uVar2 * 4) = *(int *)(puVar10 + uVar2 * 4 + -4) + 1;
}
else {
iVar3 = piVar4[-(local_58 >> 2)];
if (piVar4[-(local_58 >> 2)] < piVar4[(local_98 - uVar8) * local_80]) {
iVar3 = piVar4[(local_98 - uVar8) * local_80];
}
if (iVar3 < piVar4[-1]) {
iVar3 = piVar4[-1];
}
*piVar4 = iVar3;
}
uVar2 = uVar2 + 1;
piVar4 = piVar4 + 1;
} while (uVar2 != local_5c + 1);
}
uVar7 = uVar7 + 1;
puVar9 = puVar9 + local_58;
puVar10 = puVar10 + local_58;
piVar11 = (int *)((long)piVar11 + local_58);
} while (uVar7 != local_68);
}
uVar8 = uVar8 + 1;
local_88 = local_88 + local_80;
local_90 = local_90 + local_80;
local_98 = local_98 + 1;
pcVar5 = pcVar5 + 1;
local_a0 = local_a0 + local_80;
} while (uVar8 != local_a8);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
local_b0 = puVar6 + lVar1;
*(code **)(puVar6 + lVar1 + -8) = main;
__stack_chk_fail();
}
return *(int4 *)
(puVar6 + ((long)local_5c + (long)local_c4 * (local_c0 >> 2) +
(long)local_60 * (local_58 >> 2)) * 4 + lVar1);
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.