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 && ... | 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 ... | 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, xm... | 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 ... | 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
M... | 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 <= (doubl... |
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 && ... | 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 ... | 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_... | 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 ... | 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... | 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... |
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, -... | 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),%e... | 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]
mo... | 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... | 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, -... | 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 ... | 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:... | 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 );
}
... | 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,EC... | 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;
} w... |
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, -... | 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 ... | 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
mo... | 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... |
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, -... | 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,%... | 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 ... | 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;
... | 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
... | 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... |
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... | 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(%... | 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+v... | 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] [r... | 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 d... | 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 = ... |
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... | 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... | 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... | 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... | 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:
... | 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 {
... |
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... | 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
l... | 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, ... | 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]; // [r... | 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... | 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_O... |
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... | 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 ... | 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 rd... | 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; ... | 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 R9... | 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_... |
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 &&... | 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 = fun... | 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 ... | 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 ra... | _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 )... | 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... | 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;
... |
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 &&... | 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 = fun... | 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+0... | 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 sh... | 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
{
i... | 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... | 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_... |
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 &&... | 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 = fun... | 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+0x4... | 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_14... | 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 v1... | 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 0x0010... | 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 ) {
... |
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 &&... | 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 = fun... | 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+0x4... | 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 shor... | _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
l... | 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 0x001... | 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... |
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... | 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(... | 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[ra... | _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 [... | 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... | 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_... |
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... | 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(%... | 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 ... | _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_001... | 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_... |
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... | 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(%... | 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 ... | __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_... | 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_001... | 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_... |
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),%e... | 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 ... | _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 ... | 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) {
res... |
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,... | 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
m... | _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 )
re... | 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 p... | 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... |
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,%... | 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 sho... | _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 * v... | 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 ... | 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)iVar... |
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 ... | 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 s... | _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++;
... | ||
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};
i... | 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),%... | 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]... | 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);
... | 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,RD... | 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};
i... | 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};
i... | 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};
i... | 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 ... | 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 r... | 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 l... | 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
... | 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) |... |
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... | 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),%... | 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]... | 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);
... | 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,RD... | 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... | 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... | 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... | 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 ... | 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 r... | 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 l... | 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
... | 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) |... |
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++]... | 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, 1... | 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 -... | 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
... | _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] )
{
... | 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 p... | 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... |
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++]... | 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, 1... | 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 ... | 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 sho... | 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;
... | 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
C... | 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... |
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++]... | 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, 1... | 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(%rb... | 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 d... | 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
{
v... | 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... | 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;
... |
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++]... | 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, 1... | 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(%rb... | 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 * 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
{
v1... | 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... | 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;
... |
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... | 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 ... | 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 qwor... | 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... | 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, ... | __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;
retur... | 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:
MO... | /* 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_0010200... |
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... | 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
c... | __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.... | 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,q... | /* 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 * _... |
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... | 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(te... | 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),%ra... | 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... | 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 R... | 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;
}
... |
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(te... | 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 ... | 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 ... | 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... | 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 0x001011a... | 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(te... | 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... | 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:
movz... | 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... | 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_0... | 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 = ... |
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(te... | 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 <fu... | 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:
movz... | 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... | 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_0... | 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 = ... |
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;
... | 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,%e... | 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+... | 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) ... | 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 ... | 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)) {
... |
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;
... | 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
... | 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, ... | 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 *... | 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... | 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);
... |
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;
... | 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 ... | 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 ... | 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 )
... | 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... | 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);
... |
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;
... | 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 ... | 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 ... | 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) )
... | 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... | 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);
... |
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,%ra... | 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_1... | 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]... | 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... |
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;
... | 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 + -... |
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
... | 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... | 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)l... |
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
... | 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)l... |
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,... | 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
... | 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) | ((... | 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,... | 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
sa... | 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 | (a... | 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,... | 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
sa... | 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 | (a... | 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... | 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 ... | 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... | 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 ... |
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>
mo... | 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 lo... | 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+0x... | 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+0x... | 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... | 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 {
... | 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>
... | 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... | 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 )
ret... | 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,qwo... | 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) {... |
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 {
... | 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... | 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, ... | 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";
re... | 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... | 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 = "Val... |
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 {
... | 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 ... | 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,... | 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";
re... | 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 0x0010... | 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 = "Val... |
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 {
... | 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 ... | 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
xo... | 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);
res... | 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... | 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 = "Inv... |
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 %... | 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,... | 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... | 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),%xm... | 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_2... | 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
DIV... | 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 xm... | __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; // [rs... | 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 ... | 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 ... |
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... | 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, [r... | 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 ( a... | 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... | 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;
dVar... |
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 ... | 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 ... | 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 ... | 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 <roun... | 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 ... | 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
cv... | 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 ... | 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
cv... | 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);
... | 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:
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 ... | _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_... | 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)pvV... |
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);
... | 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,%... | 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
sa... | 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 *... | 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... | 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 = *(... |
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);
... | 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 ... | 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... | 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 = *(_DW... | 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... | 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);
lVar... |
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);
... | 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 ... | 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, e... | _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;
}
whi... | 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... | 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 =... |
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),%e... | 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 pt... | 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,RD... | 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 ... | 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 ... | 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
JM... | 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,(%r... | 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... | 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:... | 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,(%r... | 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... | 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:... | 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];
}
retu... | 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... | 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 ... | 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+... | _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... | 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 + -0... | 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 *)(... |
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];
}
retu... | 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... | 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
mo... | 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 r... | 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) +... | 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,... | 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... |
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];
}
retu... | 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... | 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 ... | 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... | 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 )
m... | 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... | 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(... |
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];
}
retu... | 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... | 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... | 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 ... | 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... | 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... | 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 ... |
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 1... | 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... | 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,0x... | 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 ... | 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 ... | 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) {
... | 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, re... | 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(%r... | 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+... | 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... | 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... | 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... |
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) {
... | 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, re... | 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,%rs... | 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_119... | 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 * ... | 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... | 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 < iVar... |
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) {
... | 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, re... | 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),%... | 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 ... | 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));
v... | 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,... | 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 {
i... |
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) {
... | 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, re... | 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
... | 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 ... | 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
{
... | 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 0x001014... | 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 =... |
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
cvtsi... | 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 xmm... | 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 ... | 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,%r... | 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,%r... | 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;
... | 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 %e... | 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 ... | 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+1... | 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 + -0x... | 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;
... |
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;
... | 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 ... | 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, ea... | 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
... | 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
LE... | 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;
... |
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.