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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
5,782 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <stdlib.h>
| bool func0(int *l, int size) {
int *sorted = malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
sorted[i] = l[i];
}
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (sorted[i] > sorted[j]) {
int temp = sorted[i];
... | int main() {
int arr1[] = {1, 2, 3, 4, 5};
int arr2[] = {1, 2, 3, 5, 6};
int arr3[] = {1, 2, 1};
assert(func0(arr1, sizeof(arr1) / sizeof(arr1[0])) == true);
assert(func0(arr2, sizeof(arr2) / sizeof(arr2[0])) == false);
assert(func0(arr3, sizeof(arr3) / sizeof(arr3[0])) == false);
... | O2 | c | func0:
endbr64
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r9
test %ebx,%ebx
jle 1396 <func0+0xc6>
lea -0x1(%rbx),%ecx
xor %eax,%eax
lea 0x1(%rcx),%rsi
xchg %ax,%ax
mov 0x0(%rbp,%rax,4),%edx
mov %edx,... | func0:
endbr64
push r13
mov r13, rdi
movsxd rdi, esi
push r12
mov r12, rdi
shl rdi, 2
push rbp
push rbx
sub rsp, 8
call _malloc
mov r9, rax
test r12d, r12d
jle loc_13B8
mov ebp, r12d
mov rsi, r13
lea ebx, [r12-1]
mov rdi, rax
lea rdx, ds:0[rbp*4]
call _m... | long long func0(long long a1, _DWORD *a2)
{
int v2; // r12d
long long v3; // rax
long long v4; // rdx
unsigned long long v5; // rcx
long long v6; // r8
_DWORD *v7; // r9
long long v8; // rbx
long long v9; // rax
long long v10; // r8
long long i; // r10
_DWORD *v12; // rax
_DWORD *v13; // rax
... | func0:
ENDBR64
PUSH R13
MOV R13,RDI
MOVSXD RDI,ESI
PUSH R12
MOV R12,RDI
SHL RDI,0x2
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x001010d0
MOV R9,RAX
TEST R12D,R12D
JLE 0x001013b8
MOV EBP,R12D
MOV RSI,R13
LEA EBX,[R12 + -0x1]
MOV RDI,RAX
LEA RDX,[RBP*0x4]
CALL 0x001010c0
MOV R8D,0x1
MOV R9,RAX
LEA RSI,[RAX + 0x4]
LEA R10,[RAX +... | int8 func0(void *param_1,uint param_2)
{
int iVar1;
int *__dest;
int *piVar2;
int *piVar3;
ulong uVar4;
ulong uVar5;
int8 uVar6;
__dest = (int *)malloc((long)(int)param_2 << 2);
if (0 < (int)param_2) {
uVar4 = (ulong)param_2;
__dest = (int *)memcpy(__dest,param_1,uVar4 * 4);
uVar5 = 1;... |
5,783 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <stdlib.h>
| bool func0(int *l, int size) {
int *sorted = malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
sorted[i] = l[i];
}
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (sorted[i] > sorted[j]) {
int temp = sorted[i];
... | int main() {
int arr1[] = {1, 2, 3, 4, 5};
int arr2[] = {1, 2, 3, 5, 6};
int arr3[] = {1, 2, 1};
assert(func0(arr1, sizeof(arr1) / sizeof(arr1[0])) == true);
assert(func0(arr2, sizeof(arr2) / sizeof(arr2[0])) == false);
assert(func0(arr3, sizeof(arr3) / sizeof(arr3[0])) == false);
... | O3 | c | func0:
endbr64
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rdi
test %ebx,%ebx
jle 1394 <func0+0xb4>
lea -0x1(%rbx),%eax
mov %rbp,%rsi
lea 0x4(,%rax,4),%rdx
callq 10c0 <memcpy@plt>
mov %rax,%rdi
cmp $0x... | func0:
endbr64
push r12
mov r12, rdi
movsxd rdi, esi
push rbp
push rbx
mov rbx, rdi
shl rdi, 2; size
call _malloc
mov rdi, rax; ptr
test ebx, ebx
jle loc_1392
mov ebp, ebx
mov rsi, r12; src
lea rdx, ds:0[rbp*4]; n
call _memcpy
mov rdi, rax; ptr
cmp ebx, 1
jz ... | long long func0(void *src, int a2)
{
int *v4; // rdi
int *v5; // rax
int *v6; // rsi
long long v7; // r8
long long v8; // rax
int v9; // edx
int v10; // ecx
int v11; // ecx
int *v12; // rdx
int v13; // eax
v4 = (int *)malloc(4LL * a2);
if ( a2 <= 0 || (v5 = (int *)memcpy(v4, src, 4LL * (unsign... | func0:
ENDBR64
PUSH R12
MOV R12,RDI
MOVSXD RDI,ESI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SHL RDI,0x2
CALL 0x001010d0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x00101392
MOV EBP,EBX
MOV RSI,R12
LEA RDX,[RBP*0x4]
CALL 0x001010c0
MOV RDI,RAX
CMP EBX,0x1
JZ 0x00101392
LEA R9D,[RBX + -0x2]
MOV RSI,RAX
MOV R8D,0x1
NOP dword ptr [RAX]
LAB_001013... | int8 func0(void *param_1,uint param_2)
{
int iVar1;
int *__dest;
int iVar2;
int *piVar3;
ulong uVar4;
ulong uVar5;
__dest = (int *)malloc((long)(int)param_2 << 2);
if (0 < (int)param_2) {
__dest = (int *)memcpy(__dest,param_1,(ulong)param_2 * 4);
if (param_2 != 1) {
uVar4 = 1;
uV... |
5,784 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} tuple;
// Compare two tuples for qsort and bsearch
int tuple_compare(const void *a, const void *b) {
tuple *t1 = (tuple *)a;
tuple *t2 = (tuple *)b;
if (t1->first != t2->first)
... | tuple* func0(tuple *list1, int size1, tuple *list2, int size2, int *res_size) {
// Sort individual tuples
for(int i = 0; i < size1; i++) {
if(list1[i].first > list1[i].second){
int temp = list1[i].first;
list1[i].first = list1[i].second;
list1[i].second = temp;
... | int main() {
// First test
tuple list1_1[] = { {3,4}, {5,6}, {9,10}, {4,5} };
int size1_1 = 4;
tuple list2_1[] = { {5,4}, {3,4}, {6,5}, {9,11} };
int size2_1 = 4;
int res_size_1;
tuple *res1 = func0(list1_1, size1_1, list2_1, size2_1, &res_size_1);
tuple expected1[] = { {3,4}, {4... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x60,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %rdx,-0x58(%rbp)
mov %ecx,-0x50(%rbp)
mov %r8,-0x60(%rbp)
movl $0x0,-0x38(%rbp)
jmpq 12df <func0+0xc0>
mov -0x38(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x48(%rbp),%rax
add %rdx,... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+base], rdi
mov [rbp+var_4C], esi
mov [rbp+var_58], rdx
mov [rbp+var_50], ecx
mov [rbp+var_60], r8
mov [rbp+var_38], 0
jmp loc_12DF
loc_1249:
mov eax, [rbp+var_38]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+base]
a... | _QWORD * func0(_DWORD *a1, int a2, _DWORD *a3, int a4, _DWORD *a5)
{
int v5; // eax
int v6; // eax
int v7; // eax
int v8; // eax
int i; // [rsp+28h] [rbp-38h]
int j; // [rsp+2Ch] [rbp-34h]
int v15; // [rsp+30h] [rbp-30h]
int k; // [rsp+34h] [rbp-2Ch]
int v17; // [rsp+38h] [rbp-28h]
int m; // [rsp+3C... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV qword ptr [RBP + -0x58],RDX
MOV dword ptr [RBP + -0x50],ECX
MOV qword ptr [RBP + -0x60],R8
MOV dword ptr [RBP + -0x38],0x0
JMP 0x001012df
LAB_00101249:
MOV EAX,dword ptr [RBP + -0x38]
CDQE
LEA RDX,[RAX*0... | void * func0(void *param_1,int param_2,void *param_3,int param_4,int *param_5)
{
int4 uVar1;
int iVar2;
void *pvVar3;
int local_40;
int local_3c;
int local_38;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
int local_20;
for (local_40 = 0; local_40 < param_2; local_4... |
5,785 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} tuple;
// Compare two tuples for qsort and bsearch
int tuple_compare(const void *a, const void *b) {
tuple *t1 = (tuple *)a;
tuple *t2 = (tuple *)b;
if (t1->first != t2->first)
... | tuple* func0(tuple *list1, int size1, tuple *list2, int size2, int *res_size) {
// Sort individual tuples
for(int i = 0; i < size1; i++) {
if(list1[i].first > list1[i].second){
int temp = list1[i].first;
list1[i].first = list1[i].second;
list1[i].second = temp;
... | int main() {
// First test
tuple list1_1[] = { {3,4}, {5,6}, {9,10}, {4,5} };
int size1_1 = 4;
tuple list2_1[] = { {5,4}, {3,4}, {6,5}, {9,11} };
int size2_1 = 4;
int res_size_1;
tuple *res1 = func0(list1_1, size1_1, list2_1, size2_1, &res_size_1);
tuple expected1[] = { {3,4}, {4... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r14
mov %esi,%r13d
mov %rdx,(%rsp)
mov %ecx,%r15d
mov %r8,0x18(%rsp)
test %esi,%esi
jle 122d <func0+0x4e>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x8(%rdi,%rdx,8),%rsi
jmp 121... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_58], rdi
mov r13d, esi
mov r14, rdx
mov r15d, ecx
mov [rsp+58h+var_40], r8
test esi, esi
jle short loc_122D
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*8+8]... | long long func0(int *a1, int a2, int *a3, int a4, _DWORD *a5)
{
int *v8; // rax
long long v9; // rsi
int v10; // edx
int v11; // ecx
int *v12; // rax
int v13; // edx
int v14; // ecx
int v15; // r12d
int v16; // ebx
int *v17; // rbp
int *v18; // rbp
int v19; // ebx
int v20; // r13d
int v21; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP],RDI
MOV R13D,ESI
MOV R14,RDX
MOV R15D,ECX
MOV qword ptr [RSP + 0x18],R8
TEST ESI,ESI
JLE 0x0010122d
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x8 + 0x8]
JMP 0x0010121d
LAB_00101214:
ADD RAX,0x8
CMP RAX,RSI
JZ... | void * func0(int *param_1,int param_2,int *param_3,int param_4,int *param_5)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int iVar5;
int iVar6;
int local_4c;
void *local_48;
if (0 < param_2) {
piVar4 = param_1;
do {
iVar6 = *piVar4;
if (piVar4[1] < iVar6) {
*piVar4 =... |
5,786 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} tuple;
// Compare two tuples for qsort and bsearch
int tuple_compare(const void *a, const void *b) {
tuple *t1 = (tuple *)a;
tuple *t2 = (tuple *)b;
if (t1->first != t2->first)
... | tuple* func0(tuple *list1, int size1, tuple *list2, int size2, int *res_size) {
// Sort individual tuples
for(int i = 0; i < size1; i++) {
if(list1[i].first > list1[i].second){
int temp = list1[i].first;
list1[i].first = list1[i].second;
list1[i].second = temp;
... | int main() {
// First test
tuple list1_1[] = { {3,4}, {5,6}, {9,10}, {4,5} };
int size1_1 = 4;
tuple list2_1[] = { {5,4}, {3,4}, {6,5}, {9,11} };
int size2_1 = 4;
int res_size_1;
tuple *res1 = func0(list1_1, size1_1, list2_1, size2_1, &res_size_1);
tuple expected1[] = { {3,4}, {4... | O2 | c | func0:
endbr64
push %r15
push %r14
mov %ecx,%r14d
push %r13
mov %esi,%r13d
push %r12
mov %rdi,%r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %r8,%rbx
sub $0x8,%rsp
test %esi,%esi
jle 1637 <func0+0x47>
lea -0x1(%rsi),%edx
mov %rdi,%rax
lea 0x8(%rdi,%rdx,8),%rsi
mov (%rax),%edx
... | func0:
endbr64
push r15
push r14
mov r14d, ecx
push r13
mov r13d, esi
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
mov rbx, r8
sub rsp, 8
test esi, esi
jle short loc_1637
lea edx, [rsi-1]
mov rax, rdi
lea rsi, [rdi+rdx*8+8]
loc_1620:
mov edx, [rax... | long long func0(int *a1, int a2, int *a3, int a4, _DWORD *a5)
{
int *v10; // rax
long long v11; // rsi
int v12; // edx
int v13; // ecx
int *v14; // rax
int v15; // edx
int v16; // ecx
long long v17; // r15
long long v18; // rax
int v19; // r13d
long long v20; // rcx
long long v21; // rdx
long... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,ECX
PUSH R13
MOV R13D,ESI
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,R8
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101637
LEA EDX,[RSI + -0x1]
MOV RAX,RDI
LEA RSI,[RDI + RDX*0x8 + 0x8]
LAB_00101620:
MOV EDX,dword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4]
CMP EDX,ECX
JLE 0x0... | void * func0(int *param_1,int param_2,int *param_3,uint param_4,int *param_5)
{
int iVar1;
int *piVar2;
long lVar3;
ulong uVar4;
void *pvVar5;
int iVar6;
int iVar7;
long lVar8;
long lVar9;
int iVar10;
int iVar11;
int iVar12;
if (0 < param_2) {
piVar2 = param_1;
do {
iVar11 = ... |
5,787 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} tuple;
// Compare two tuples for qsort and bsearch
int tuple_compare(const void *a, const void *b) {
tuple *t1 = (tuple *)a;
tuple *t2 = (tuple *)b;
if (t1->first != t2->first)
... | tuple* func0(tuple *list1, int size1, tuple *list2, int size2, int *res_size) {
// Sort individual tuples
for(int i = 0; i < size1; i++) {
if(list1[i].first > list1[i].second){
int temp = list1[i].first;
list1[i].first = list1[i].second;
list1[i].second = temp;
... | int main() {
// First test
tuple list1_1[] = { {3,4}, {5,6}, {9,10}, {4,5} };
int size1_1 = 4;
tuple list2_1[] = { {5,4}, {3,4}, {6,5}, {9,11} };
int size2_1 = 4;
int res_size_1;
tuple *res1 = func0(list1_1, size1_1, list2_1, size2_1, &res_size_1);
tuple expected1[] = { {3,4}, {4... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %ecx,%r14d
push %r13
mov %esi,%r13d
push %r12
mov %rdi,%r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %r8,%rbx
sub $0x8,%rsp
test %esi,%esi
jle 1587 <func0+0x47>
lea -0x1(%rsi),%edx
mov %rdi,%rax
lea 0x8(%rdi,%rdx,8),%rsi
mov (%rax),%edx
... | func0:
endbr64
push r15
push r14
mov r14d, esi
push r13
mov r13d, ecx
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov [rsp+48h+var_48], r8
test esi, esi
jle loc_1748
movsxd r15, esi
mov rax, rdi
lea rsi, [rdi+r15*8]
nop dword ptr [rax+0... | _QWORD * func0(__m128i *base, int a2, __m128i *a3, int a4, _DWORD *a5)
{
size_t v9; // r15
__m128i *v10; // rax
__m128i *v11; // rsi
__m128i v12; // xmm0
size_t v13; // rbx
__m128i *v14; // rax
__m128i v15; // xmm0
long long v16; // rax
int v17; // edx
long long v18; // rsi
long long v19; // rcx
... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,ESI
PUSH R13
MOV R13D,ECX
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],R8
TEST ESI,ESI
JLE 0x00101748
MOVSXD R15,ESI
MOV RAX,RDI
LEA RSI,[RDI + R15*0x8]
NOP dword ptr [RAX]
LAB_00101558:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD... | void * func0(int8 *param_1,int param_2,int8 *param_3,int param_4,int *param_5)
{
int *piVar1;
int iVar2;
int8 *puVar3;
size_t sVar4;
void *pvVar5;
int iVar6;
long lVar7;
int iVar8;
size_t __nmemb;
int iVar9;
int iVar10;
int iVar11;
size_t __nmemb_00;
if (param_2 < 1) {
if (0 < param_... |
5,788 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1, char ch, char newch) {
static char str2[100];
strcpy(str2, str1);
for (int i = 0; i < strlen(str2); i++) {
if (str2[i] == ch) {
str2[i] = newch;
}
}
return str2;
}
| int main() {
assert(strcmp(func0("polygon", 'y', 'l'), "pollgon") == 0);
assert(strcmp(func0("character", 'c', 'a'), "aharaater") == 0);
assert(strcmp(func0("python", 'l', 'a'), "python") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,%ecx
mov %edx,%eax
mov %ecx,%edx
mov %dl,-0x2c(%rbp)
mov %al,-0x30(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rsi
lea 0x2e6c(%rip),%rdi
callq 1080 <strcpy@plt>
movl $0x0,-0x14(%rbp)
jmp 120... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+src], rdi
mov ecx, esi
mov eax, edx
mov edx, ecx
mov [rbp+var_2C], dl
mov [rbp+var_30], al
mov rax, [rbp+src]
mov rsi, rax; src
lea rax, str2_1
mov rdi, rax; dest
call _strcpy
mov [rbp+var_14... | char * func0(const char *a1, char a2, char a3)
{
int i; // [rsp+1Ch] [rbp-14h]
strcpy(str2_1, a1);
for ( i = 0; i < strlen(str2_1); ++i )
{
if ( a2 == str2_1[i] )
str2_1[i] = a3;
}
return str2_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV ECX,ESI
MOV EAX,EDX
MOV EDX,ECX
MOV byte ptr [RBP + -0x2c],DL
MOV byte ptr [RBP + -0x30],AL
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RAX
LEA RAX,[0x104040]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101... | int1 * func0(char *param_1,char param_2,int param_3)
{
size_t sVar1;
int local_1c;
strcpy(str2_1,param_1);
local_1c = 0;
while( true ) {
sVar1 = strlen(str2_1);
if (sVar1 <= (ulong)(long)local_1c) break;
if (param_2 == str2_1[local_1c]) {
str2_1[local_1c] = param_3;
}
local_1c = ... |
5,789 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1, char ch, char newch) {
static char str2[100];
strcpy(str2, str1);
for (int i = 0; i < strlen(str2); i++) {
if (str2[i] == ch) {
str2[i] = newch;
}
}
return str2;
}
| int main() {
assert(strcmp(func0("polygon", 'y', 'l'), "pollgon") == 0);
assert(strcmp(func0("character", 'c', 'a'), "aharaater") == 0);
assert(strcmp(func0("python", 'l', 'a'), "python") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %esi,%ebx
mov %edx,%ebp
mov $0x64,%edx
mov %rdi,%rsi
lea 0x2eba(%rip),%rdi
callq 1070 <__strcpy_chk@plt>
mov $0x0,%edx
lea 0x2ea9(%rip),%rsi
mov $0xffffffffffffffff,%r8
mov $0x0,%eax
jmp 11a9 <func0+0x40>
add $0x1,%rdx
mov ... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12d, esi
mov r13d, edx
mov edx, 64h ; 'd'
mov rsi, rdi
lea rdi, str2_1
call ___strcpy_chk
mov ebx, 0
lea rbp, str2_1
jmp short loc_11E3
loc_11DF:
add rbx, 1
loc_11E3:
mov rdi, rbp
call _strle... | _BYTE * func0(long long a1, char a2, char a3)
{
unsigned long long i; // rbx
__strcpy_chk(str2_1, a1, 100LL);
for ( i = 0LL; strlen(str2_1) > i; ++i )
{
if ( str2_1[i] == a2 )
str2_1[i] = a3;
}
return str2_1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12D,ESI
MOV R13D,EDX
MOV EDX,0x64
MOV RSI,RDI
LEA RDI,[0x104040]
CALL 0x001010b0
MOV EBX,0x0
LEA RBP,[0x104040]
JMP 0x001011e3
LAB_001011df:
ADD RBX,0x1
LAB_001011e3:
MOV RDI,RBP
CALL 0x00101080
CMP RAX,RBX
JBE 0x001011fe
CMP byte ptr [RBP + RBX*0x1],R... | int1 * func0(int8 param_1,char param_2,int1 param_3)
{
size_t sVar1;
ulong uVar2;
__strcpy_chk(&str2_1,param_1,100);
uVar2 = 0;
while( true ) {
sVar1 = strlen(&str2_1);
if (sVar1 <= uVar2) break;
if ((&str2_1)[uVar2] == param_2) {
(&str2_1)[uVar2] = param_3;
}
uVar2 = uVar2 + 1;
... |
5,790 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1, char ch, char newch) {
static char str2[100];
strcpy(str2, str1);
for (int i = 0; i < strlen(str2); i++) {
if (str2[i] == ch) {
str2[i] = newch;
}
}
return str2;
}
| int main() {
assert(strcmp(func0("polygon", 'y', 'l'), "pollgon") == 0);
assert(strcmp(func0("character", 'c', 'a'), "aharaater") == 0);
assert(strcmp(func0("python", 'l', 'a'), "python") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %edx,%ebp
mov $0x64,%edx
push %rbx
mov %esi,%ebx
mov %rdi,%rsi
lea 0x2db7(%rip),%rdi
sub $0x8,%rsp
callq 1070 <__stpcpy_chk@plt>
lea 0x2da7(%rip),%rdi
xor %esi,%esi
sub %rdi,%rax
mov %rdi,%r8
jmp 12ac <func0+0x3c>
nopl 0x0(%rax,%rax,1)
add $0x1,%rs... | func0:
endbr64
push r13
mov r13d, edx
mov edx, 64h ; 'd'
push r12
lea r12, str2_1
push rbp
mov ebp, esi
mov rsi, rdi
mov rdi, r12
push rbx
xor ebx, ebx
sub rsp, 8
call ___strcpy_chk
jmp short loc_12CE
loc_12C0:
cmp [r12+rbx], bpl
jnz short loc_12CA
mov [r12... | _BYTE * func0(long long a1, char a2, char a3)
{
unsigned long long v4; // rbx
v4 = 0LL;
__strcpy_chk(str2_1, a1, 100LL);
while ( strlen(str2_1) > v4 )
{
if ( str2_1[v4] == a2 )
str2_1[v4] = a3;
++v4;
}
return str2_1;
} | func0:
ENDBR64
PUSH R13
MOV R13D,EDX
MOV EDX,0x64
PUSH R12
LEA R12,[0x104040]
PUSH RBP
MOV EBP,ESI
MOV RSI,RDI
MOV RDI,R12
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
CALL 0x001010b0
JMP 0x001012ce
LAB_001012c0:
CMP byte ptr [R12 + RBX*0x1],BPL
JNZ 0x001012ca
MOV byte ptr [R12 + RBX*0x1],R13B
LAB_001012ca:
ADD RBX,0x1
LAB_001012c... | int1 * func0(int8 param_1,char param_2,int1 param_3)
{
size_t sVar1;
ulong uVar2;
uVar2 = 0;
__strcpy_chk(&str2_1,param_1,100);
while( true ) {
sVar1 = strlen(&str2_1);
if (sVar1 <= uVar2) break;
if ((&str2_1)[uVar2] == param_2) {
(&str2_1)[uVar2] = param_3;
}
uVar2 = uVar2 + 1;
... |
5,791 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(char* str1, char ch, char newch) {
static char str2[100];
strcpy(str2, str1);
for (int i = 0; i < strlen(str2); i++) {
if (str2[i] == ch) {
str2[i] = newch;
}
}
return str2;
}
| int main() {
assert(strcmp(func0("polygon", 'y', 'l'), "pollgon") == 0);
assert(strcmp(func0("character", 'c', 'a'), "aharaater") == 0);
assert(strcmp(func0("python", 'l', 'a'), "python") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %edx,%ebp
mov $0x64,%edx
push %rbx
mov %esi,%ebx
mov %rdi,%rsi
lea 0x2db7(%rip),%rdi
sub $0x8,%rsp
callq 1070 <__stpcpy_chk@plt>
lea 0x2da7(%rip),%rdi
sub %rdi,%rax
je 12b6 <func0+0x46>
xor %esi,%esi
mov %rdi,%r8
nopl 0x0(%rax,%rax,1)
cmp %bl,(%rd... | func0:
endbr64
push r13
mov r13d, edx
mov edx, 64h ; 'd'
push r12
mov r12d, esi
mov rsi, rdi
push rbp
lea rbp, str2_1
push rbx
mov rdi, rbp
xor ebx, ebx
sub rsp, 8
call ___strcpy_chk
jmp short loc_12D0
loc_12C0:
cmp [rbp+rbx+0], r12b
jnz short loc_12CC
mov ... | char * func0(long long a1, char a2, char a3)
{
size_t v4; // rbx
v4 = 0LL;
__strcpy_chk(str2_1, a1, 100LL);
while ( v4 < strlen(str2_1) )
{
if ( str2_1[v4] == a2 )
str2_1[v4] = a3;
++v4;
}
return str2_1;
} | func0:
ENDBR64
PUSH R13
MOV R13D,EDX
MOV EDX,0x64
PUSH R12
MOV R12D,ESI
MOV RSI,RDI
PUSH RBP
LEA RBP,[0x104040]
PUSH RBX
MOV RDI,RBP
XOR EBX,EBX
SUB RSP,0x8
CALL 0x001010b0
JMP 0x001012d0
LAB_001012c0:
CMP byte ptr [RBP + RBX*0x1],R12B
JNZ 0x001012cc
MOV byte ptr [RBP + RBX*0x1],R13B
LAB_001012cc:
ADD RBX,0x1
LAB_00101... | int1 * func0(int8 param_1,char param_2,int param_3)
{
size_t sVar1;
ulong uVar2;
uVar2 = 0;
__strcpy_chk(&str2_1,param_1,100);
while( true ) {
sVar1 = strlen(&str2_1);
if (sVar1 <= uVar2) break;
if ((&str2_1)[uVar2] == param_2) {
(&str2_1)[uVar2] = param_3;
}
uVar2 = uVar2 + 1;
... |
5,792 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
typedef struct {
char key[50];
int value;
} Item;
int cmp(const void *a, const void *b) {
Item *itemA = (Item *)a;
Item *itemB = (Item *)b;
return (itemB->value - itemA->value);
}
| Item* func0(char keys[][50], int values[], int length) {
Item *items = malloc(length * sizeof(Item));
for (int i = 0; i < length; i++) {
strcpy(items[i].key, keys[i]);
items[i].value = values[i];
}
qsort(items, length, sizeof(Item), cmp);
return items;
}
| int main() {
char keys1[][50] = {"Math", "Physics", "Chemistry"};
int values1[] = {81, 83, 87};
Item *result1 = func0(keys1, values1, 3);
assert(strcmp(result1[0].key, "Chemistry") == 0 && result1[0].value == 87);
assert(strcmp(result1[1].key, "Physics") == 0 && result1[1].value == 83);
as... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x3,%rax
sub %rdx,%rax
shl $0x3,%rax
mov %rax,%rdi
callq 1110 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, rdx
shl rax, 3
sub rax, rdx
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+base], rax
mov [rb... | char * func0(long long a1, long long a2, int a3)
{
int i; // [rsp+24h] [rbp-Ch]
char *base; // [rsp+28h] [rbp-8h]
base = (char *)malloc(56LL * a3);
for ( i = 0; i < a3; ++i )
{
strcpy(&base[56 * i], (const char *)(50LL * i + a1));
*(_DWORD *)&base[56 * i + 52] = *(_DWORD *)(4LL * i + a2);
}
qsort... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,RDX
SHL RAX,0x3
SUB RAX,RDX
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101110
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + ... | void * func0(long param_1,long param_2,int param_3)
{
void *__base;
int local_14;
__base = malloc((long)param_3 * 0x38);
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
strcpy((char *)((long)__base + (long)local_14 * 0x38),(char *)((long)local_14 * 0x32 + param_1))
;
*(int4 *)(... |
5,793 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
typedef struct {
char key[50];
int value;
} Item;
int cmp(const void *a, const void *b) {
Item *itemA = (Item *)a;
Item *itemB = (Item *)b;
return (itemB->value - itemA->value);
}
| Item* func0(char keys[][50], int values[], int length) {
Item *items = malloc(length * sizeof(Item));
for (int i = 0; i < length; i++) {
strcpy(items[i].key, keys[i]);
items[i].value = values[i];
}
qsort(items, length, sizeof(Item), cmp);
return items;
}
| int main() {
char keys1[][50] = {"Math", "Physics", "Chemistry"};
int values1[] = {81, 83, 87};
Item *result1 = func0(keys1, values1, 3);
assert(strcmp(result1[0].key, "Chemistry") == 0 && result1[0].value == 87);
assert(strcmp(result1[1].key, "Physics") == 0 && result1[1].value == 83);
as... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r12
mov %rsi,%rbx
mov %edx,%r14d
movslq %edx,%r15
lea 0x0(,%r15,8),%rdi
sub %r15,%rdi
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r13
test %r14d,%r14d
jle 1260 <func0+0x6c>
mo... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
mov rbx, rsi
mov r14d, edx
movsxd r15, edx
lea rdi, ds:0[r15*8]
sub rdi, r15
shl rdi, 3
call _malloc
mov r13, rax
test r14d, r14d
jle short loc_1280
mov rbp, rax
... | long long func0(long long a1, _DWORD *a2, int a3)
{
_DWORD *v4; // rbx
long long v6; // r15
long long v7; // rax
long long v8; // r13
long long v9; // rbp
long long v10; // r14
v4 = a2;
v6 = a3;
v7 = malloc(56LL * a3);
v8 = v7;
if ( a3 > 0 )
{
v9 = v7;
v10 = (long long)&a2[a3 - 1 + 1];... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV RBX,RSI
MOV R14D,EDX
MOVSXD R15,EDX
LEA RDI,[R15*0x8]
SUB RDI,R15
SHL RDI,0x3
CALL 0x00101100
MOV R13,RAX
TEST R14D,R14D
JLE 0x00101280
MOV RBP,RAX
LEA EAX,[R14 + -0x1]
LEA R14,[RBX + RAX*0x4 + 0x4]
LAB_0010125a:
MOV EDX,0x... | void * func0(long param_1,int4 *param_2,int param_3)
{
int4 *puVar1;
void *__base;
void *pvVar2;
__base = malloc((long)param_3 * 0x38);
if (0 < param_3) {
puVar1 = param_2 + (ulong)(param_3 - 1) + 1;
pvVar2 = __base;
do {
__strcpy_chk(pvVar2,param_1,0x32);
*(int4 *)((long)pvVar2 + ... |
5,794 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
typedef struct {
char key[50];
int value;
} Item;
int cmp(const void *a, const void *b) {
Item *itemA = (Item *)a;
Item *itemB = (Item *)b;
return (itemB->value - itemA->value);
}
| Item* func0(char keys[][50], int values[], int length) {
Item *items = malloc(length * sizeof(Item));
for (int i = 0; i < length; i++) {
strcpy(items[i].key, keys[i]);
items[i].value = values[i];
}
qsort(items, length, sizeof(Item), cmp);
return items;
}
| int main() {
char keys1[][50] = {"Math", "Physics", "Chemistry"};
int values1[] = {81, 83, 87};
Item *result1 = func0(keys1, values1, 3);
assert(strcmp(result1[0].key, "Chemistry") == 0 && result1[0].value == 87);
assert(strcmp(result1[1].key, "Physics") == 0 && result1[1].value == 83);
as... | O2 | c | func0:
endbr64
push %r14
push %r13
movslq %edx,%r13
push %r12
push %rbp
mov %rdi,%rbp
lea 0x0(,%r13,8),%rdi
push %rbx
sub %r13,%rdi
mov %rsi,%rbx
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r12
test %r13d,%r13d
jle 16fa <func0+0x6a>
mov %rax,%rcx
lea -0x1(%r13),%eax
lea 0x... | func0:
endbr64
push r14
push r13
movsxd r13, edx
push r12
push rbp
mov rbp, rdi
lea rdi, ds:0[r13*8]
push rbx
sub rdi, r13
mov rbx, rsi
shl rdi, 3
call _malloc
mov r12, rax
test r13d, r13d
jle short loc_178A
mov rcx, rax
lea eax, [r13-1]
lea r14, [rbx+rax*4+... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // r13
long long v5; // rbx
long long v6; // rax
long long v7; // r12
long long v8; // rcx
long long v9; // rax
v3 = a3;
v5 = a2;
v6 = malloc(56LL * a3);
v7 = v6;
if ( (int)v3 > 0 )
{
v8 = v6;
do
{
v5 += 4LL;... | func0:
ENDBR64
PUSH R14
PUSH R13
MOVSXD R13,EDX
PUSH R12
PUSH RBP
MOV RBP,RDI
LEA RDI,[R13*0x8]
PUSH RBX
SUB RDI,R13
MOV RBX,RSI
SHL RDI,0x3
CALL 0x00101100
MOV R12,RAX
TEST R13D,R13D
JLE 0x0010178a
MOV RCX,RAX
LEA EAX,[R13 + -0x1]
LEA R14,[RBX + RAX*0x4 + 0x4]
NOP dword ptr [RAX]
LAB_00101760:
MOV RSI,RBP
MOV RDI,RCX
... | void * func0(long param_1,int4 *param_2,int param_3)
{
void *__base;
long lVar1;
void *pvVar2;
int4 *puVar3;
int4 *puVar4;
__base = malloc((long)param_3 * 0x38);
if (0 < param_3) {
pvVar2 = __base;
puVar3 = param_2;
do {
puVar4 = puVar3 + 1;
lVar1 = __strcpy_chk(pvVar2,param_1,... |
5,795 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
typedef struct {
char key[50];
int value;
} Item;
int cmp(const void *a, const void *b) {
Item *itemA = (Item *)a;
Item *itemB = (Item *)b;
return (itemB->value - itemA->value);
}
| Item* func0(char keys[][50], int values[], int length) {
Item *items = malloc(length * sizeof(Item));
for (int i = 0; i < length; i++) {
strcpy(items[i].key, keys[i]);
items[i].value = values[i];
}
qsort(items, length, sizeof(Item), cmp);
return items;
}
| int main() {
char keys1[][50] = {"Math", "Physics", "Chemistry"};
int values1[] = {81, 83, 87};
Item *result1 = func0(keys1, values1, 3);
assert(strcmp(result1[0].key, "Chemistry") == 0 && result1[0].value == 87);
assert(strcmp(result1[1].key, "Physics") == 0 && result1[1].value == 83);
as... | O3 | c | func0:
endbr64
push %r14
push %r13
movslq %edx,%r13
push %r12
push %rbp
mov %rdi,%rbp
lea 0x0(,%r13,8),%rdi
push %rbx
sub %r13,%rdi
mov %rsi,%rbx
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r12
test %r13d,%r13d
jle 16fa <func0+0x6a>
mov %rax,%rcx
lea -0x1(%r13),%eax
lea 0x... | func0:
endbr64
push r15
mov r15, rsi
push r14
push r13
movsxd r13, edx
push r12
mov r12, rdi
push rbp
push rbx
lea rbx, ds:0[r13*8]
sub rbx, r13
shl rbx, 3
sub rsp, 18h
mov rdi, rbx; size
call _malloc
mov [rsp+48h+base], rax
test r13d, r13d
jle short loc_1743... | void * func0(long long a1, long long a2, int a3)
{
long long v3; // r15
size_t v4; // r13
size_t v6; // rbx
void *v7; // rax
void *v8; // rcx
size_t v9; // rbp
size_t v10; // r14
size_t v11; // rdx
long long v12; // rsi
unsigned long long v13; // rdx
long long v14; // rax
void *base; // [rsp+8h]... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
MOVSXD R13,EDX
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
LEA RBX,[R13*0x8]
SUB RBX,R13
SHL RBX,0x3
SUB RSP,0x18
MOV RDI,RBX
CALL 0x00101100
MOV qword ptr [RSP + 0x8],RAX
TEST R13D,R13D
JLE 0x00101743
MOV RCX,RAX
LEA RBP,[R15 + R13*0x4]
XOR R14D,R14D
NOP word ptr CS:[RA... | void * func0(long param_1,int4 *param_2,int param_3)
{
void *__base;
long lVar1;
void *pvVar2;
ulong uVar3;
size_t __size;
size_t __nmemb;
ulong uVar4;
int4 *puVar5;
int4 *puVar6;
__nmemb = (size_t)param_3;
__size = __nmemb * 0x38;
__base = malloc(__size);
if (0 < param_3) {
uVar4 = 0;... |
5,796 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_num = INT_MIN;
int min_num = INT_MAX;
for(int i = 0; i < size; i++) {
if(nums[i] > max_num) {
max_num = nums[i];
}
if(nums[i] < min_num) {
min_num = nums[i];
}
}
return max_num + min_num;
}
... | int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {-1, 2, 3, 4};
int arr3[] = {2, 3, 6};
assert(func0(arr1, 3) == 4);
assert(func0(arr2, 4) == 3);
assert(func0(arr3, 3) == 8);
printf("All test cases passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x80000000,-0xc(%rbp)
movl $0x7fffffff,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 121b <func0+0x92>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 80000000h
mov [rbp+var_8], 7FFFFFFFh
mov [rbp+var_4], 0
jmp short loc_121B
loc_11AF:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ... | long long func0(long long a1, int a2)
{
signed int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0x80000000;
v4 = 0x7FFFFFFF;
for ( i = 0; i < a2; ++i )
{
if ( v3 < *(_DWORD *)(4LL * i + a1) )
v3 = *(_DWORD *)(4LL * i + a1);
if ( v4 > *(_DWORD *)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x80000000
MOV dword ptr [RBP + -0x8],0x7fffffff
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010121b
LAB_001011af:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18... | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = -0x80000000;
local_10 = 0x7fffffff;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (local_14 < *(int *)(param_1 + (long)local_c * 4)) {
local_14 = *(int *)(param_1 + (long)local_c * 4... |
5,797 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_num = INT_MIN;
int min_num = INT_MAX;
for(int i = 0; i < size; i++) {
if(nums[i] > max_num) {
max_num = nums[i];
}
if(nums[i] < min_num) {
min_num = nums[i];
}
}
return max_num + min_num;
}
... | int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {-1, 2, 3, 4};
int arr3[] = {2, 3, 6};
assert(func0(arr1, 3) == 4);
assert(func0(arr2, 4) == 3);
assert(func0(arr3, 3) == 8);
printf("All test cases passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11be <func0+0x35>
mov %rdi,%rcx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdi
mov $0x7fffffff,%esi
mov $0x80000000,%eax
mov (%rcx),%edx
cmp %edx,%eax
cmovl %edx,%eax
cmp %edx,%esi
cmovg %edx,%esi
add $0x4,%rcx
cmp %rdi,%rcx
jne 11a6 <func0+0x1d>
... | func0:
endbr64
test esi, esi
jle short loc_11BE
mov rcx, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax*4+4]
mov esi, 7FFFFFFFh
mov eax, 80000000h
loc_11A6:
mov edx, [rcx]
cmp eax, edx
cmovl eax, edx
cmp esi, edx
cmovg esi, edx
add rcx, 4
cmp rcx, rdi
jnz short loc_11A6
lo... | long long func0(signed int *a1, int a2)
{
signed int *v2; // rcx
long long v3; // rdi
int v4; // esi
signed int v5; // eax
if ( a2 <= 0 )
{
v4 = 0x7FFFFFFF;
v5 = 0x80000000;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0x7FFFFFFF;
v5 = 0x80000000;
do
{
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011be
MOV RCX,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x4 + 0x4]
MOV ESI,0x7fffffff
MOV EAX,0x80000000
LAB_001011a6:
MOV EDX,dword ptr [RCX]
CMP EAX,EDX
CMOVL EAX,EDX
CMP ESI,EDX
CMOVG ESI,EDX
ADD RCX,0x4
CMP RCX,RDI
JNZ 0x001011a6
LAB_001011bb:
ADD EAX,ESI
RET
LAB_001011be:
MOV... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_2 < 1) {
iVar4 = 0x7fffffff;
iVar3 = -0x80000000;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar4 = 0x7fffffff;
iVar3 = -0x80000000;
do {
iVar2 = *param_1;
if (... |
5,798 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_num = INT_MIN;
int min_num = INT_MAX;
for(int i = 0; i < size; i++) {
if(nums[i] > max_num) {
max_num = nums[i];
}
if(nums[i] < min_num) {
min_num = nums[i];
}
}
return max_num + min_num;
}
... | int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {-1, 2, 3, 4};
int arr3[] = {2, 3, 6};
assert(func0(arr1, 3) == 4);
assert(func0(arr2, 4) == 3);
assert(func0(arr3, 3) == 8);
printf("All test cases passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 11b0 <func0+0x40>
lea -0x1(%rsi),%eax
mov $0x80000000,%ecx
lea 0x4(%rdi,%rax,4),%rsi
mov $0x7fffffff,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdi),%edx
cmp %edx,%ecx
cmovl %edx,%ecx
cmp %edx,%eax
cmovg %edx,%eax
add $0x4,%rdi
cmp %rsi,%rdi
jne 1190 <func0... | func0:
endbr64
test esi, esi
jle short loc_11B0
lea eax, [rsi-1]
mov ecx, 80000000h
lea rsi, [rdi+rax*4+4]
mov eax, 7FFFFFFFh
nop word ptr [rax+rax+00h]
loc_1190:
mov edx, [rdi]
cmp ecx, edx
cmovl ecx, edx
cmp eax, edx
cmovg eax, edx
add rdi, 4
cmp rdi, rsi
jnz sho... | long long func0(signed int *a1, int a2)
{
signed int v2; // ecx
long long v3; // rsi
int v4; // eax
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v2 = 0x80000000;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0x7FFFFFFF;
do
{
if ( v2 < *a1 )
v2 = *a1;
if ( v4 > *a1 )
v4 = *a1;
++a1;
}
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011b0
LEA EAX,[RSI + -0x1]
MOV ECX,0x80000000
LEA RSI,[RDI + RAX*0x4 + 0x4]
MOV EAX,0x7fffffff
NOP word ptr [RAX + RAX*0x1]
LAB_00101190:
MOV EDX,dword ptr [RDI]
CMP ECX,EDX
CMOVL ECX,EDX
CMP EAX,EDX
CMOVG EAX,EDX
ADD RDI,0x4
CMP RDI,RSI
JNZ 0x00101190
ADD EAX,ECX
RET
LAB_001011b0:
... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
if (0 < param_2) {
iVar4 = -0x80000000;
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0x7fffffff;
do {
iVar2 = *param_1;
if (iVar4 < iVar2) {
iVar4 = iVar2;
}
if (iVar... |
5,799 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
| int func0(int nums[], int size) {
int max_num = INT_MIN;
int min_num = INT_MAX;
for(int i = 0; i < size; i++) {
if(nums[i] > max_num) {
max_num = nums[i];
}
if(nums[i] < min_num) {
min_num = nums[i];
}
}
return max_num + min_num;
}
... | int main() {
int arr1[] = {1, 2, 3};
int arr2[] = {-1, 2, 3, 4};
int arr3[] = {2, 3, 6};
assert(func0(arr1, 3) == 4);
assert(func0(arr2, 4) == 3);
assert(func0(arr3, 3) == 8);
printf("All test cases passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 12c8 <func0+0x158>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 12ce <func0+0x15e>
mov %esi,%edx
movdqa 0xe8e(%rip),%xmm4
movdqa 0xe96(%rip),%xmm1
mov %rdi,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
movdqa %xmm1,%xmm... | func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_12C8
lea eax, [rsi-1]
cmp eax, 2
jbe loc_12CE
mov edx, esi
movdqa xmm3, cs:xmmword_2020
movdqa xmm1, cs:xmmword_2030
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00000000h]
loc_11B0:
movdqu xmm0, xm... | long long func0(const __m128i *a1, int a2)
{
__m128i si128; // xmm3
__m128i v4; // xmm1
const __m128i *v5; // rax
__m128i v6; // xmm0
__m128i v7; // xmm2
__m128i v8; // xmm2
__m128i v9; // xmm0
signed int v10; // esi
__m128i v11; // xmm2
__m128i v12; // xmm2
__m128i v13; // xmm3
__m128i v14; //... | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x001012c8
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001012ce
MOV EDX,ESI
MOVDQA XMM3,xmmword ptr [0x00102020]
MOVDQA XMM1,xmmword ptr [0x00102030]
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_001011b0:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM2,XMM1
AD... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint *param_1,uint param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
uint uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
... |
5,800 | func0 |
#include <assert.h>
#include <ctype.h>
#include <string.h>
| void func0(char* input, char* output) {
int i = 0;
while (input[i]) {
output[i] = tolower((unsigned char) input[i]);
i++;
}
output[i] = '\0';
}
| int main() {
char result[100];
func0("InValid", result);
assert(strcmp(result, "invalid") == 0);
func0("TruE", result);
assert(strcmp(result, "true") == 0);
func0("SenTenCE", result);
assert(strcmp(result, "sentence") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11f7 <func0+0x4e>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movzbl %al,%eax
mov %eax,%edi
callq 10b0 <tolower@plt>
mov... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_4], 0
jmp short loc_11F7
loc_11C6:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
movzx eax, al
mov edi, eax; c
ca... | _BYTE * func0(long long a1, long long a2)
{
_BYTE *result; // rax
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; *(_BYTE *)(i + a1); ++i )
*(_BYTE *)(i + a2) = tolower(*(unsigned __int8 *)(i + a1));
result = (_BYTE *)(i + a2);
*result = 0;
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011f7
LAB_001011c6:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AL
MOV EDI,EAX
CALL 0x... | void func0(long param_1,long param_2)
{
int iVar1;
int4 local_c;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
iVar1 = tolower((uint)*(byte *)(param_1 + local_c));
*(char *)(param_2 + local_c) = (char)iVar1;
}
*(int *)(param_2 + local_c) = 0;
return;
} |
5,801 | func0 |
#include <assert.h>
#include <ctype.h>
#include <string.h>
| void func0(char* input, char* output) {
int i = 0;
while (input[i]) {
output[i] = tolower((unsigned char) input[i]);
i++;
}
output[i] = '\0';
}
| int main() {
char result[100];
func0("InValid", result);
assert(strcmp(result, "invalid") == 0);
func0("TruE", result);
assert(strcmp(result, "true") == 0);
func0("SenTenCE", result);
assert(strcmp(result, "sentence") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rsi,%rbp
movzbl (%rdi),%ebx
test %bl,%bl
je 11cc <func0+0x43>
mov %rdi,%r12
callq 1090 <__ctype_tolower_loc@plt>
mov $0x0,%edx
movzbl %bl,%ebx
mov (%rax),%rcx
mov (%rcx,%rbx,4),%ecx
mov %cl,0x0(%rbp,%rdx,1)
add $0x1,%rdx
movzbl (%r12,%r... | func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rsi
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_11EC
mov r12, rdi
call ___ctype_tolower_loc
mov edx, 0
loc_11C8:
movzx ebx, bl
mov rcx, [rax]
mov ecx, [rcx+rbx*4]
mov [rbp+rdx+0], cl
add rdx, 1
movzx ebx, byt... | void func0(unsigned __int8 *a1, long long a2)
{
unsigned __int8 v2; // bl
_QWORD *v3; // rax
long long v4; // rdx
v2 = *a1;
if ( *a1 )
{
v3 = (_QWORD *)__ctype_tolower_loc();
v4 = 0LL;
do
{
*(_BYTE *)(a2 + v4++) = *(_DWORD *)(*v3 + 4LL * v2);
v2 = a1[v4];
}
while ( v2 )... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RSI
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001011ec
MOV R12,RDI
CALL 0x001010b0
MOV EDX,0x0
LAB_001011c8:
MOVZX EBX,BL
MOV RCX,qword ptr [RAX]
MOV ECX,dword ptr [RCX + RBX*0x4]
MOV byte ptr [RBP + RDX*0x1],CL
ADD RDX,0x1
MOVZX EBX,byte ptr [R12 + RDX*0x1]
TEST BL,BL
J... | void func0(byte *param_1,long param_2)
{
__int32_t **pp_Var1;
long lVar2;
byte bVar3;
bVar3 = *param_1;
if (bVar3 == 0) {
lVar2 = 0;
}
else {
pp_Var1 = __ctype_tolower_loc();
lVar2 = 0;
do {
*(char *)(param_2 + lVar2) = (char)(*pp_Var1)[bVar3];
lVar2 = lVar2 + 1;
bVar... |
5,802 | func0 |
#include <assert.h>
#include <ctype.h>
#include <string.h>
| void func0(char* input, char* output) {
int i = 0;
while (input[i]) {
output[i] = tolower((unsigned char) input[i]);
i++;
}
output[i] = '\0';
}
| int main() {
char result[100];
func0("InValid", result);
assert(strcmp(result, "invalid") == 0);
func0("TruE", result);
assert(strcmp(result, "true") == 0);
func0("SenTenCE", result);
assert(strcmp(result, "sentence") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
movzbl (%rdi),%ebx
test %bl,%bl
je 12cd <func0+0x3d>
mov %rdi,%r12
callq 1090 <__ctype_tolower_loc@plt>
xor %edx,%edx
nopl 0x0(%rax)
mov (%rax),%rcx
movzbl %bl,%ebx
mov (%rcx,%rbx,4),%ecx
mov %cl,0x0(%rbp,%rdx,1)
add $0x1,%rd... | func0:
endbr64
push r12
push rbp
mov rbp, rsi
push rbx
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_12CA
mov r12, rdi
call ___ctype_tolower_loc
xor edx, edx
nop dword ptr [rax+00h]
loc_12B0:
mov rcx, [rax]
mov ecx, [rcx+rbx*4]
mov [rbp+rdx+0], cl
add rdx, 1
mo... | void func0(unsigned __int8 *a1, _BYTE *a2)
{
_BYTE *v2; // rbp
long long v3; // rbx
_QWORD *v4; // rax
long long v5; // rdx
v2 = a2;
v3 = *a1;
if ( (_BYTE)v3 )
{
v4 = (_QWORD *)__ctype_tolower_loc();
v5 = 0LL;
do
{
a2[v5++] = *(_DWORD *)(*v4 + 4 * v3);
v3 = a1[v5];
}
... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001012ca
MOV R12,RDI
CALL 0x00101090
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_001012b0:
MOV RCX,qword ptr [RAX]
MOV ECX,dword ptr [RCX + RBX*0x4]
MOV byte ptr [RBP + RDX*0x1],CL
ADD RDX,0x1
MOVZX EBX,byte ptr [R12 + RDX*0x1]
TEST ... | void func0(byte *param_1,int1 *param_2)
{
byte bVar1;
__int32_t **pp_Var2;
long lVar3;
bVar1 = *param_1;
if (bVar1 != 0) {
pp_Var2 = __ctype_tolower_loc();
lVar3 = 0;
do {
param_2[lVar3] = (char)(*pp_Var2)[bVar1];
lVar3 = lVar3 + 1;
bVar1 = param_1[lVar3];
} while (bVar1 ... |
5,803 | func0 |
#include <assert.h>
#include <ctype.h>
#include <string.h>
| void func0(char* input, char* output) {
int i = 0;
while (input[i]) {
output[i] = tolower((unsigned char) input[i]);
i++;
}
output[i] = '\0';
}
| int main() {
char result[100];
func0("InValid", result);
assert(strcmp(result, "invalid") == 0);
func0("TruE", result);
assert(strcmp(result, "true") == 0);
func0("SenTenCE", result);
assert(strcmp(result, "sentence") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
movzbl (%rdi),%ebx
test %bl,%bl
je 12cd <func0+0x3d>
mov %rdi,%r12
callq 1090 <__ctype_tolower_loc@plt>
xor %edx,%edx
nopl 0x0(%rax)
mov (%rax),%rcx
movzbl %bl,%ebx
mov (%rcx,%rbx,4),%ecx
mov %cl,0x0(%rbp,%rdx,1)
add $0x1,%rd... | func0:
endbr64
push r12
push rbp
mov rbp, rsi
push rbx
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_12CA
mov r12, rdi
call ___ctype_tolower_loc
xor edx, edx
nop dword ptr [rax+00h]
loc_12B0:
mov rcx, [rax]
mov ecx, [rcx+rbx*4]
mov [rbp+rdx+0], cl
add rdx, 1
mo... | void func0(unsigned __int8 *a1, _BYTE *a2)
{
_BYTE *v2; // rbp
long long v3; // rbx
const __int32_t **v4; // rax
long long v5; // rdx
v2 = a2;
v3 = *a1;
if ( (_BYTE)v3 )
{
v4 = __ctype_tolower_loc();
v5 = 0LL;
do
{
a2[v5++] = (*v4)[v3];
v3 = a1[v5];
}
while ( (_BYTE... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001012ca
MOV R12,RDI
CALL 0x00101090
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_001012b0:
MOV RCX,qword ptr [RAX]
MOV ECX,dword ptr [RCX + RBX*0x4]
MOV byte ptr [RBP + RDX*0x1],CL
ADD RDX,0x1
MOVZX EBX,byte ptr [R12 + RDX*0x1]
TEST ... | void func0(byte *param_1,int *param_2)
{
byte bVar1;
__int32_t **pp_Var2;
long lVar3;
bVar1 = *param_1;
if (bVar1 != 0) {
pp_Var2 = __ctype_tolower_loc();
lVar3 = 0;
do {
param_2[lVar3] = (char)(*pp_Var2)[bVar1];
lVar3 = lVar3 + 1;
bVar1 = param_1[lVar3];
} while (bVar1 !... |
5,804 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(char *str1) {
static char result[100];
int i, j = 0;
for (i = 0; str1[i] != '\0'; i++) {
if (!islower(str1[i])) {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("PYTHon"), "PYTH") == 0);
assert(strcmp(func0("FInD"), "FID") == 0);
assert(strcmp(func0("STRinG"), "STRG") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 1204 <func0+0x7b>
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x8(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_4], 0
mov [rbp+var_8], 0
jmp short loc_1204
loc_11A9:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_8]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]... | _BYTE * func0(long long a1)
{
int v1; // eax
int i; // [rsp+18h] [rbp-8h]
int v4; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( ((*__ctype_b_loc())[*(char *)(i + a1)] & 0x200) == 0 )
{
v1 = v4++;
result_1[v1] = *(_BYTE *)(i + a1);
}
}
result_1[v4] =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101204
LAB_001011a9:
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr... | int1 * func0(long param_1)
{
ushort **ppuVar1;
int local_10;
int local_c;
local_c = 0;
for (local_10 = 0; *(char *)(param_1 + local_10) != '\0'; local_10 = local_10 + 1) {
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[*(char *)(param_1 + local_10)] & 0x200) == 0) {
result_1[local_c] = *(int *)(... |
5,805 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(char *str1) {
static char result[100];
int i, j = 0;
for (i = 0; str1[i] != '\0'; i++) {
if (!islower(str1[i])) {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("PYTHon"), "PYTH") == 0);
assert(strcmp(func0("FInD"), "FID") == 0);
assert(strcmp(func0("STRinG"), "STRG") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 11ba <func0+0x51>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
mov $0x0,%esi
lea 0x2eae(%rip),%r8
jmp 11a0 <func0+0x37>
add $0x1,%rdi
movzbl -0x1(%rdi),%ebx
test %bl,%bl
je 11bf <... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_11DA
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
mov esi, 0
lea r8, result_1
jmp short loc_11C0
loc_11B4:
add rdi, 1
movzx ebx, byte ptr [rdi-1]
test bl, bl
jz sh... | _BYTE * func0(char *a1)
{
char v1; // bl
_QWORD *v2; // rax
char *v3; // rdi
int v4; // esi
_BYTE *result; // rax
v1 = *a1;
if ( *a1 )
{
v2 = (_QWORD *)__ctype_b_loc();
v3 = a1 + 1;
v4 = 0;
do
{
if ( (*(_BYTE *)(*v2 + 2LL * v1 + 1) & 2) == 0 )
result_1[v4++] = v1;
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001011da
MOV RBP,RDI
CALL 0x00101090
LEA RDI,[RBP + 0x1]
MOV ESI,0x0
LEA R8,[0x104040]
JMP 0x001011c0
LAB_001011b4:
ADD RDI,0x1
MOVZX EBX,byte ptr [RDI + -0x1]
TEST BL,BL
JZ 0x001011df
LAB_001011c0:
MOVSX RDX,BL
MOV RCX,qword ptr [RAX... | void func0(char *param_1)
{
ushort **ppuVar1;
char cVar2;
int iVar3;
char *pcVar4;
cVar2 = *param_1;
if (cVar2 == '\0') {
iVar3 = 0;
}
else {
ppuVar1 = __ctype_b_loc();
iVar3 = 0;
pcVar4 = param_1 + 1;
do {
if ((*(byte *)((long)*ppuVar1 + (long)cVar2 * 2 + 1) & 2) == 0) {
... |
5,806 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(char *str1) {
static char result[100];
int i, j = 0;
for (i = 0; str1[i] != '\0'; i++) {
if (!islower(str1[i])) {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("PYTHon"), "PYTH") == 0);
assert(strcmp(func0("FInD"), "FID") == 0);
assert(strcmp(func0("STRinG"), "STRG") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 12c0 <func0+0x70>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %esi,%esi
lea 0x2dca(%rip),%r8
nopw %cs:0x0(%rax,%rax,1)
mov (%rax),%rcx
movsbq %bl,%rdx
testb $0x2,0x1(%rcx,%rdx,2)
j... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_12C8
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor esi, esi
lea r8, result_1
nop word ptr [rax+rax+00000000h]
loc_1290:
mov rcx, [rax]
movsx rdx, bl
test byte ptr [r... | _BYTE * func0(char *a1)
{
char v1; // bl
_QWORD *v2; // rax
char *v3; // rdi
int v4; // esi
long long v5; // rdx
_BYTE *result; // rax
v1 = *a1;
if ( *a1 )
{
v2 = (_QWORD *)__ctype_b_loc();
v3 = a1 + 1;
v4 = 0;
do
{
if ( (*(_BYTE *)(*v2 + 2LL * v1 + 1) & 2) == 0 )
{
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001012c8
MOV RBP,RDI
CALL 0x00101090
LEA RDI,[RBP + 0x1]
XOR ESI,ESI
LEA R8,[0x104040]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101290:
MOV RCX,qword ptr [RAX]
MOVSX RDX,BL
TEST byte ptr [RCX + RDX*0x2 + 0x1],0x2
JNZ 0x001012a8
MOVSXD RD... | int1 * func0(char *param_1)
{
ushort **ppuVar1;
long lVar2;
char cVar3;
int iVar4;
cVar3 = *param_1;
if (cVar3 == '\0') {
iVar4 = 0;
}
else {
ppuVar1 = __ctype_b_loc();
param_1 = param_1 + 1;
iVar4 = 0;
do {
if ((*(byte *)((long)*ppuVar1 + (long)cVar3 * 2 + 1) & 2) == 0) {
... |
5,807 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| char* func0(char *str1) {
static char result[100];
int i, j = 0;
for (i = 0; str1[i] != '\0'; i++) {
if (!islower(str1[i])) {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("PYTHon"), "PYTH") == 0);
assert(strcmp(func0("FInD"), "FID") == 0);
assert(strcmp(func0("STRinG"), "STRG") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 12d8 <func0+0x88>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
xor %edx,%edx
lea 0x2dca(%rip),%r8
mov (%rax),%rsi
nopl 0x0(%rax)
movsbq %bl,%rcx
testb $0x2,0x1(%rsi,%rcx,2)
jne 12af ... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_12E0
mov rbp, rdi
call ___ctype_b_loc
lea rdi, [rbp+1]
xor edx, edx
lea r8, result_1
mov rsi, [rax]
nop dword ptr [rax+00000000h]
loc_1290:
movsx rcx, bl
test byte ptr [rsi+... | _BYTE * func0(char *a1)
{
char v1; // bl
const unsigned __int16 **v2; // rax
char *v3; // rdi
long long v4; // rdx
const unsigned __int16 *v5; // rsi
v1 = *a1;
if ( *a1 )
{
v2 = __ctype_b_loc();
v3 = a1 + 1;
v4 = 0LL;
v5 = *v2;
while ( (v5[v1] & 0x200) != 0 )
{
LABEL_6:
v1... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001012e0
MOV RBP,RDI
CALL 0x00101090
LEA RDI,[RBP + 0x1]
XOR EDX,EDX
LEA R8,[0x104040]
MOV RSI,qword ptr [RAX]
NOP dword ptr [RAX]
LAB_00101290:
MOVSX RCX,BL
TEST byte ptr [RSI + RCX*0x2 + 0x1],0x2
JNZ 0x001012bf
LAB_0010129b:
ADD RDI... | int1 * func0(char *param_1)
{
byte bVar1;
ushort **ppuVar2;
long lVar3;
char cVar4;
ushort *puVar5;
cVar4 = *param_1;
if (cVar4 == '\0') {
result_1 = 0;
return &result_1;
}
ppuVar2 = __ctype_b_loc();
param_1 = param_1 + 1;
lVar3 = 0;
puVar5 = *ppuVar2;
do {
bVar1 = *(byte *)((l... |
5,808 | func0 |
#include <assert.h>
| int func0(int n) {
while (n >= 10) {
n = n / 10;
}
return n;
}
| int main() {
assert(func0(123) == 1);
assert(func0(456) == 4);
assert(func0(12) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
jmp 1174 <func0+0x2b>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x4(%rbp)
cmpl $0x9,-0x4(%rbp)
jg 1156 <func0+0xd>
mo... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
jmp short loc_1174
loc_1156:
mov eax, [rbp+var_4]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_4], eax
loc_1174:
cmp [rbp+var_4], 9
jg ... | long long func0(int a1)
{
while ( a1 > 9 )
a1 /= 10;
return (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
JMP 0x00101174
LAB_00101156:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
LAB_00101174:
CMP dword ptr [RBP + -0x4],0x9
JG 0x00101156... | int func0(int param_1)
{
int4 local_c;
for (local_c = param_1; 9 < local_c; local_c = local_c / 10) {
}
return local_c;
} |
5,809 | func0 |
#include <assert.h>
| int func0(int n) {
while (n >= 10) {
n = n / 10;
}
return n;
}
| int main() {
assert(func0(123) == 1);
assert(func0(456) == 4);
assert(func0(12) == 1);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
cmp $0x9,%edi
jle 1150 <func0+0x27>
mov %eax,%ecx
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
cmp $0x63,%ecx
jg 1134 <func0+0xb>
retq
| func0:
endbr64
mov eax, edi
cmp edi, 9
jle short locret_1152
loc_1134:
mov ecx, eax
movsxd rdx, eax
imul rdx, 66666667h
sar rdx, 22h
sar eax, 1Fh
mov esi, eax
mov eax, edx
sub eax, esi
cmp ecx, 63h ; 'c'
jg short loc_1134
locret_1152:
retn | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = (unsigned int)a1;
if ( a1 > 9 )
{
do
{
v2 = result;
result = (unsigned int)((int)result / 10);
}
while ( v2 > 99 );
}
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,0x9
JLE 0x00101152
LAB_00101134:
MOV ECX,EAX
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
SAR EAX,0x1f
MOV ESI,EAX
MOV EAX,EDX
SUB EAX,ESI
CMP ECX,0x63
JG 0x00101134
LAB_00101152:
RET | void func0(int param_1)
{
bool bVar1;
if (9 < param_1) {
do {
bVar1 = 99 < param_1;
param_1 = param_1 / 10;
} while (bVar1);
}
return;
} |
5,810 | func0 |
#include <assert.h>
| int func0(int n) {
while (n >= 10) {
n = n / 10;
}
return n;
}
| int main() {
assert(func0(123) == 1);
assert(func0(456) == 4);
assert(func0(12) == 1);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
cmp $0x9,%edi
jle 1162 <func0+0x22>
mov $0xcccccccd,%ecx
mov %eax,%eax
mov %rax,%rdx
imul %rcx,%rax
shr $0x23,%rax
cmp $0x63,%edx
jg 1150 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov eax, edi
cmp edi, 9
jle short locret_1162
mov ecx, 0CCCCCCCDh
loc_1150:
mov eax, eax
mov rdx, rax
imul rax, rcx
shr rax, 23h
cmp edx, 63h ; 'c'
jg short loc_1150
locret_1162:
retn | unsigned long long func0(int a1)
{
unsigned long long result; // rax
int v2; // edx
result = (unsigned int)a1;
if ( a1 > 9 )
{
do
{
v2 = result;
result = (unsigned int)result / 0xAuLL;
}
while ( v2 > 99 );
}
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,0x9
JLE 0x00101162
MOV ECX,0xcccccccd
LAB_00101150:
MOV EAX,EAX
MOV RDX,RAX
IMUL RAX,RCX
SHR RAX,0x23
CMP EDX,0x63
JG 0x00101150
LAB_00101162:
RET | void func0(uint param_1)
{
bool bVar1;
if (9 < (int)param_1) {
do {
bVar1 = 99 < (int)param_1;
param_1 = param_1 / 10;
} while (bVar1);
}
return;
} |
5,811 | func0 |
#include <assert.h>
| int func0(int n) {
while (n >= 10) {
n = n / 10;
}
return n;
}
| int main() {
assert(func0(123) == 1);
assert(func0(456) == 4);
assert(func0(12) == 1);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
cmp $0x9,%edi
jle 1162 <func0+0x22>
mov $0xcccccccd,%ecx
mov %eax,%eax
mov %rax,%rdx
imul %rcx,%rax
shr $0x23,%rax
cmp $0x63,%edx
jg 1150 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
mov eax, edi
cmp edi, 9
jle short locret_1162
mov ecx, 0CCCCCCCDh
loc_1150:
mov eax, eax
mov rdx, rax
imul rax, rcx
shr rax, 23h
cmp edx, 63h ; 'c'
jg short loc_1150
locret_1162:
retn | unsigned long long func0(int a1)
{
unsigned long long result; // rax
int v2; // edx
result = (unsigned int)a1;
if ( a1 > 9 )
{
do
{
v2 = result;
result = (unsigned int)result / 0xAuLL;
}
while ( v2 > 99 );
}
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,0x9
JLE 0x00101162
MOV ECX,0xcccccccd
LAB_00101150:
MOV EAX,EAX
MOV RDX,RAX
IMUL RAX,RCX
SHR RAX,0x23
CMP EDX,0x63
JG 0x00101150
LAB_00101162:
RET | void func0(uint param_1)
{
ulong uVar1;
int iVar2;
uVar1 = (ulong)param_1;
if (9 < (int)param_1) {
do {
iVar2 = (int)uVar1;
uVar1 = uVar1 / 10;
} while (99 < iVar2);
}
return;
} |
5,812 | func0 |
#include <assert.h>
#include <string.h>
| char func0(const char* str1) {
int ASCII_SIZE = 256;
int ctr[256] = {0};
int max = -1;
char ch = '\0';
int length = strlen(str1);
for (int i = 0; i < length; i++) {
ctr[(int)str1[i]]++;
}
for (int i = 0; i < length; i++) {
if (max < ctr[(int)str1[i]]) {
max = ctr[(int)str1[i]]... | int main() {
assert(func0("data") == 'a');
assert(func0("create") == 'e');
assert(func0("brilliant girl") == 'i');
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x440,%rsp
mov %rdi,-0x438(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x100,-0x418(%rbp)
lea -0x410(%rbp),%rdx
mov $0x0,%eax
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0xffffffff,-0x424(%rbp)
movb $0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 440h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_418], 100h
lea rdx, [rbp+var_410]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mov [rbp+var_424], 0FFFFFFFFh
mov [rbp+var_425], 0
mo... | long long func0(const char *a1)
{
unsigned __int8 v2; // [rsp+1Bh] [rbp-425h]
int v3; // [rsp+1Ch] [rbp-424h]
int i; // [rsp+20h] [rbp-420h]
int j; // [rsp+24h] [rbp-41Ch]
int v6; // [rsp+2Ch] [rbp-414h]
_DWORD v7[258]; // [rsp+30h] [rbp-410h] BYREF
unsigned long long v8; // [rsp+438h] [rbp-8h]
v8 = _... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x440
MOV qword ptr [RBP + -0x438],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x418],0x100
LEA RDX,[RBP + -0x410]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x424],0xffffffff
MOV byte ptr [RBP... | char func0(char *param_1)
{
size_t sVar1;
long lVar2;
int *piVar3;
long in_FS_OFFSET;
char local_42d;
int local_42c;
int local_428;
int local_424;
int local_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = local_418;
for (lVar2 = 0x80; lVar2 != 0; lVar2 = lVar2... |
5,813 | func0 |
#include <assert.h>
#include <string.h>
| char func0(const char* str1) {
int ASCII_SIZE = 256;
int ctr[256] = {0};
int max = -1;
char ch = '\0';
int length = strlen(str1);
for (int i = 0; i < length; i++) {
ctr[(int)str1[i]]++;
}
for (int i = 0; i < length; i++) {
if (max < ctr[(int)str1[i]]) {
max = ctr[(int)str1[i]]... | int main() {
assert(func0("data") == 'a');
assert(func0("create") == 'e');
assert(func0("brilliant girl") == 'i');
return 0;
}
| O1 | c | func0:
endbr64
sub $0x418,%rsp
mov %rdi,%rdx
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x80,%ecx
rep stos %rax,%es:(%rdi)
mov $0xffffffffffffffff,%rcx
mov %rdx,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
test %ecx,%ecx
jle 11f6 <func0+0x8d>
m... | func0:
endbr64
push rbx
sub rsp, 410h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 80h
rep stosq
mov rdi, rbx
call _strlen
test eax, eax
jle short loc_120C
mov rdx, rbx
lea eax, [rax-1]
lea rsi, [rbx+rax+1]
mov ra... | long long func0(char *a1)
{
int v1; // eax
char *v2; // rdx
long long v3; // rsi
char *v4; // rax
unsigned int v5; // r8d
int v6; // edi
_DWORD v8[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v9; // [rsp+408h] [rbp-10h]
v9 = __readfsqword(0x28u);
memset(v8, 0, 0x400uLL);
v1 = strlen(a1)... | func0:
ENDBR64
PUSH RBX
SUB RSP,0x410
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x80
STOSQ.REP RDI
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JLE 0x0010120c
MOV RDX,RBX
LEA EAX,[RAX + -0x1]
LEA RSI,[RBX + RAX*0x1 + 0x1]
MOV RAX,RBX
LAB_001011d0:
MOVSX RCX,byte... | char func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
char *pcVar3;
long lVar4;
int iVar5;
int *piVar6;
char cVar7;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar6 = aiStack_418;
for (lVar4 = 0x80; lVar4 != 0; lVar4 = lVar4 + -1)... |
5,814 | func0 |
#include <assert.h>
#include <string.h>
| char func0(const char* str1) {
int ASCII_SIZE = 256;
int ctr[256] = {0};
int max = -1;
char ch = '\0';
int length = strlen(str1);
for (int i = 0; i < length; i++) {
ctr[(int)str1[i]]++;
}
for (int i = 0; i < length; i++) {
if (max < ctr[(int)str1[i]]) {
max = ctr[(int)str1[i]]... | int main() {
assert(func0("data") == 'a');
assert(func0("create") == 'e');
assert(func0("brilliant girl") == 'i');
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov $0x80,%ecx
mov %rdi,%rbx
sub $0x410,%rsp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
mov %rbx,%rdi
callq 1070 <strlen@plt>
test %eax,%eax
jle 12e0 <func0+0xb0>
sub $0x1,%eax
mov %rbx,%rdi
lea 0x1(%rbx,%... | func0:
endbr64
push rbx
mov ecx, 80h
mov rbx, rdi
sub rsp, 410h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov rdi, rbx
call _strlen
test eax, eax
jle short loc_12E0
sub eax, 1
mov rdi, rbx
lea rcx, [rbx+rax+1]
mov rax, rbx... | long long func0(char *a1)
{
int v1; // eax
long long v2; // rcx
char *v3; // rax
long long v4; // rdx
unsigned int v5; // r8d
int v6; // esi
long long v7; // rdx
_DWORD v9[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v10; // [rsp+408h] [rbp-10h]
v10 = __readfsqword(0x28u);
memset(v9, 0,... | func0:
ENDBR64
PUSH RBX
MOV ECX,0x80
MOV RBX,RDI
SUB RSP,0x410
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JLE 0x001012e0
SUB EAX,0x1
MOV RDI,RBX
LEA RCX,[RBX + RAX*0x1 + 0x1]
MOV RAX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_0010... | int func0(char *param_1)
{
char *pcVar1;
char cVar2;
size_t sVar3;
char *pcVar4;
long lVar5;
int iVar6;
int iVar7;
int *piVar8;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar8 = aiStack_418;
for (lVar5 = 0x80; lVar5 != 0; lVar5 =... |
5,815 | func0 |
#include <assert.h>
#include <string.h>
| char func0(const char* str1) {
int ASCII_SIZE = 256;
int ctr[256] = {0};
int max = -1;
char ch = '\0';
int length = strlen(str1);
for (int i = 0; i < length; i++) {
ctr[(int)str1[i]]++;
}
for (int i = 0; i < length; i++) {
if (max < ctr[(int)str1[i]]) {
max = ctr[(int)str1[i]]... | int main() {
assert(func0("data") == 'a');
assert(func0("create") == 'e');
assert(func0("brilliant girl") == 'i');
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov $0x80,%ecx
mov %rdi,%rbx
sub $0x410,%rsp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
mov %rbx,%rdi
callq 1070 <strlen@plt>
test %eax,%eax
jle 12e0 <func0+0xb0>
sub $0x1,%eax
mov %rbx,%rdi
lea 0x1(%rbx,%... | func0:
endbr64
push rbx
mov ecx, 80h
mov rbx, rdi
sub rsp, 410h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov rdi, rbx; s
call _strlen
test eax, eax
jle short loc_12E0
sub eax, 1
mov rdi, rbx
lea rcx, [rbx+rax+1]
mov rax, ... | long long func0(char *s)
{
int v1; // eax
char *v2; // rcx
char *v3; // rax
long long v4; // rdx
unsigned int v5; // r8d
int v6; // esi
long long v7; // rdx
_DWORD v9[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v10; // [rsp+408h] [rbp-10h]
v10 = __readfsqword(0x28u);
memset(v9, 0, 0x40... | func0:
ENDBR64
PUSH RBX
MOV ECX,0x80
MOV RBX,RDI
SUB RSP,0x410
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JLE 0x001012e0
SUB EAX,0x1
MOV RDI,RBX
LEA RCX,[RBX + RAX*0x1 + 0x1]
MOV RAX,RBX
NOP word ptr [RAX + RAX*0x1]
LAB_0010... | int func0(char *param_1)
{
char *pcVar1;
char cVar2;
size_t sVar3;
char *pcVar4;
long lVar5;
int iVar6;
int iVar7;
int *piVar8;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar8 = aiStack_418;
for (lVar5 = 0x80; lVar5 != 0; lVar5 =... |
5,816 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int set[], int n, int sum) {
if (sum == 0)
return true;
if (n == 0)
return false;
if (set[n - 1] > sum)
return func0(set, n - 1, sum);
return func0(set, n - 1, sum) || func0(set, n - 1, sum - set[n - 1]);
}
| int main() {
int set1[] = {3, 34, 4, 12, 5, 2};
int set2[] = {3, 34, 4, 12, 5, 2};
int set3[] = {3, 34, 4, 12, 5, 2};
assert(func0(set1, 6, 9) == true);
assert(func0(set2, 6, 30) == false);
assert(func0(set3, 6, 15) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov %edx,-0x10(%rbp)
cmpl $0x0,-0x10(%rbp)
jne 118f <func0+0x26>
mov $0x1,%eax
jmpq 1230 <func0+0xc7>
cmpl $0x0,-0xc(%rbp)
jne 119f <func0+0x36>
mov $0x0,%eax
jmpq 1230 <func0+0xc7>
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
cmp [rbp+var_10], 0
jnz short loc_118F
mov eax, 1
jmp locret_1230
loc_118F:
cmp [rbp+var_C], 0
jnz short loc_119F
mov eax, 0
jmp locret_1230
loc_119F:
... | long long func0(long long a1, int a2, unsigned int a3)
{
if ( !a3 )
return 1LL;
if ( !a2 )
return 0LL;
if ( (signed int)a3 < *(_DWORD *)(4LL * a2 - 4 + a1) )
return func0(a1, (unsigned int)(a2 - 1), a3);
return (unsigned __int8)func0(a1, (unsigned int)(a2 - 1), a3)
|| (unsigned __int8)func0(a... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x0010118f
MOV EAX,0x1
JMP 0x00101230
LAB_0010118f:
CMP dword ptr [RBP + -0xc],0x0
JNZ 0x0010119f
MOV EAX,0x0
JMP 0x00101230
LAB_0010119f:
MO... | ulong func0(long param_1,int param_2,int param_3)
{
char cVar1;
uint uVar2;
ulong uVar3;
if (param_3 == 0) {
return 1;
}
if (param_2 != 0) {
if (*(int *)(param_1 + (long)param_2 * 4 + -4) <= param_3) {
cVar1 = func0(param_1,param_2 + -1,param_3);
if ((cVar1 == '\0') &&
(cVar... |
5,817 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int set[], int n, int sum) {
if (sum == 0)
return true;
if (n == 0)
return false;
if (set[n - 1] > sum)
return func0(set, n - 1, sum);
return func0(set, n - 1, sum) || func0(set, n - 1, sum - set[n - 1]);
}
| int main() {
int set1[] = {3, 34, 4, 12, 5, 2};
int set2[] = {3, 34, 4, 12, 5, 2};
int set3[] = {3, 34, 4, 12, 5, 2};
assert(func0(set1, 6, 9) == true);
assert(func0(set2, 6, 30) == false);
assert(func0(set3, 6, 15) == true);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%eax
test %edx,%edx
je 11dc <func0+0x73>
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r12
mov %edx,%ebp
mov $0x0,%eax
test %esi,%esi
je 11b3 <func0+0x4a>
movslq %esi,%rax
mov -0x4(%rdi,%rax,4),%r13d
cmp %edx,%r13d
jg 11be <func0+0x5... | func0:
endbr64
mov eax, 1
test edx, edx
jz short locret_11DC
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
mov ebp, edx
mov eax, 0
test esi, esi
jz short loc_11B3
movsxd rax, esi
mov r13d, [rdi+rax*4-4]
cmp r13d, edx
jg short loc_11BE
lea e... | long long func0(long long a1, int a2, int a3)
{
long long result; // rax
char v4; // dl
char v5; // al
result = 1LL;
if ( a3 )
{
result = 0LL;
if ( a2 )
{
if ( *(_DWORD *)(a1 + 4LL * a2 - 4) > a3 )
{
return func0(a1, (unsigned int)(a2 - 1));
}
else
{
... | func0:
ENDBR64
MOV EAX,0x1
TEST EDX,EDX
JZ 0x001011dc
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV EBP,EDX
MOV EAX,0x0
TEST ESI,ESI
JZ 0x001011b3
MOVSXD RAX,ESI
MOV R13D,dword ptr [RDI + RAX*0x4 + -0x4]
CMP R13D,EDX
JG 0x001011be
LEA EBX,[RSI + -0x1]
MOV ESI,EBX
CALL 0x00101169
MOV EDX,EAX
MOV EAX,0x... | ulong func0(long param_1,int param_2,int param_3)
{
int iVar1;
char cVar2;
byte bVar3;
uint uVar4;
ulong uVar5;
if (param_3 != 0) {
uVar5 = 0;
if (param_2 != 0) {
iVar1 = *(int *)(param_1 + -4 + (long)param_2 * 4);
if (param_3 < iVar1) {
uVar5 = func0(param_1,param_2 + -1);
... |
5,818 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int set[], int n, int sum) {
if (sum == 0)
return true;
if (n == 0)
return false;
if (set[n - 1] > sum)
return func0(set, n - 1, sum);
return func0(set, n - 1, sum) || func0(set, n - 1, sum - set[n - 1]);
}
| int main() {
int set1[] = {3, 34, 4, 12, 5, 2};
int set2[] = {3, 34, 4, 12, 5, 2};
int set3[] = {3, 34, 4, 12, 5, 2};
assert(func0(set1, 6, 9) == true);
assert(func0(set2, 6, 30) == false);
assert(func0(set3, 6, 15) == true);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %rdi,%r13
push %r12
mov %edx,%r12d
push %rbp
movslq %esi,%rbp
push %rbx
sub $0x8,%rsp
test %r12d,%r12d
je 1325 <func0+0x85>
test %ebp,%ebp
je 1310 <func0+0x70>
lea -0x1(%rbp),%edx
lea -0x2(%rbp),%rax
movslq %edx,%rsi
mov %edx,%edx
sub %rdx,%rax
jmp ... | func0:
endbr64
push r13
mov r13, rdi
push r12
mov r12d, edx
push rbp
movsxd rbp, esi
push rbx
sub rsp, 8
loc_12B7:
test r12d, r12d
jz short loc_1325
test ebp, ebp
jz short loc_1310
lea ecx, [rbp-1]
lea rdx, [rbp-2]
movsxd rax, ecx
mov ecx, ecx
sub rdx, rcx
jmp ... | long long func0(long long a1, int a2, unsigned int a3)
{
long long v4; // rbp
long long v5; // rax
long long v6; // rdx
int v7; // ebx
long long result; // rax
v4 = a2;
while ( a3 )
{
if ( !(_DWORD)v4 )
return 0LL;
v5 = (int)v4 - 1;
v6 = v4 - 2 - (unsigned int)(v4 - 1);
while ( 1... | func0:
ENDBR64
PUSH R13
MOV R13,RDI
PUSH R12
MOV R12D,EDX
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
SUB RSP,0x8
LAB_001012b7:
TEST R12D,R12D
JZ 0x00101325
TEST EBP,EBP
JZ 0x00101310
LEA ECX,[RBP + -0x1]
LEA RDX,[RBP + -0x2]
MOVSXD RAX,ECX
MOV ECX,ECX
SUB RDX,RCX
JMP 0x001012e1
LAB_001012d8:
SUB RAX,0x1
CMP RDX,RAX
JZ 0x00101310... | int8 func0(long param_1,int param_2,int param_3)
{
long lVar1;
int iVar2;
ulong uVar3;
int8 uVar4;
uint uVar5;
long lVar6;
lVar6 = (long)param_2;
while( true ) {
if (param_3 == 0) {
return 1;
}
if ((int)lVar6 == 0) break;
uVar5 = (int)lVar6 - 1;
lVar1 = lVar6 + -2;
uVar... |
5,819 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int set[], int n, int sum) {
if (sum == 0)
return true;
if (n == 0)
return false;
if (set[n - 1] > sum)
return func0(set, n - 1, sum);
return func0(set, n - 1, sum) || func0(set, n - 1, sum - set[n - 1]);
}
| int main() {
int set1[] = {3, 34, 4, 12, 5, 2};
int set2[] = {3, 34, 4, 12, 5, 2};
int set3[] = {3, 34, 4, 12, 5, 2};
assert(func0(set1, 6, 9) == true);
assert(func0(set2, 6, 30) == false);
assert(func0(set3, 6, 15) == true);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
mov %rdi,%r13
push %r12
mov %edx,%r12d
push %rbp
movslq %esi,%rbp
push %rbx
sub $0x8,%rsp
test %r12d,%r12d
je 1305 <func0+0x85>
test %ebp,%ebp
je 12f0 <func0+0x70>
lea -0x1(%rbp),%edx
lea -0x2(%rbp),%rax
movslq %edx,%rsi
mov %edx,%edx
sub %rdx,%rax
jmp ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov ebp, edx
push rbx
mov ebx, esi
sub rsp, 18h
loc_1286:
test ebp, ebp
jz loc_13D1
test ebx, ebx
jz loc_13C0
movsxd rax, ebx
lea rax, [rdi+rax*4]
jmp short loc_12AC
loc_12A0:
sub rax, 4
test ebx, e... | char func0(long long a1, int a2, signed int a3)
{
long long v4; // rbx
long long i; // rax
int v6; // r12d
int v7; // r14d
long long v8; // r15
long long v9; // rax
int v10; // r13d
int v11; // edx
unsigned int v12; // edx
long long v13; // rax
char result; // al
unsigned int v15; // ebp
int ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV EBX,ESI
SUB RSP,0x18
LAB_00101286:
TEST EBP,EBP
JZ 0x001013d1
TEST EBX,EBX
JZ 0x001013c0
MOVSXD RAX,EBX
LEA RAX,[RDI + RAX*0x4]
JMP 0x001012ac
LAB_001012a0:
SUB RAX,0x4
TEST EBX,EBX
JZ 0x001013c0
LAB_001012ac:
MOV R12D,dword ptr [RAX +... | int8 func0(long param_1,ulong param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
long lVar4;
ulong uVar5;
int8 uVar6;
int iVar7;
uint uVar8;
int iVar9;
uint uVar10;
param_2 = param_2 & 0xffffffff;
LAB_00101286:
if (param_3 == 0) {
return 1;
}
if ((int)param_2 == 0) {
return ... |
5,820 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| char* func0(char* text) {
regex_t regex;
int result;
char* pattern = "[A-Z]+[a-z]+$";
regcomp(®ex, pattern, REG_EXTENDED);
result = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if(result == 0) {
return "Yes";
} else {
return "No";
}
}... | int main() {
assert(func0("Geeks") == "Yes");
assert(func0("geeksforGeeks") == "Yes");
assert(func0("geeks") == "No");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe19(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 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, aAZAZ; "[A-Z]+[a-z]+$"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov ... | 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, "[A-Z]+[a-z]+$", 1);
v2 = regexec(&preg, a1, 0LL, 0LL, 0);
regfree(&preg);
if ( v2 )
return "No";
e... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010c0
MOV RSI,qwo... | int * func0(char *param_1)
{
int iVar1;
int *puVar2;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&local_58,"[A-Z]+[a-z]+$",1);
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if (iVar1 == 0) {
puVar2 = &... |
5,821 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| char* func0(char* text) {
regex_t regex;
int result;
char* pattern = "[A-Z]+[a-z]+$";
regcomp(®ex, pattern, REG_EXTENDED);
result = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if(result == 0) {
return "Yes";
} else {
return "No";
}
}... | int main() {
assert(func0("Geeks") == "Yes");
assert(func0("geeksforGeeks") == "Yes");
assert(func0("geeks") == "No");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov $0x1,%edx
lea 0xe16(%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, 1
lea rsi, aAZAZ; "[A-Z]+[a-z]+$"
mov rdi, rbp
call _regcomp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
mov rdi, rbp
ca... | void * func0(long long a1)
{
int v1; // ebx
void *result; // rax
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "[A-Z]+[a-z]+$", 1LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
result = &unk_2004;
if ( v1 )
return &unk_2008;
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV EDX,0x1
LEA RSI,[0x10200b]
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... | int * func0(char *param_1)
{
int iVar1;
int *puVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"[A-Z]+[a-z]+$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
puVar2 = &DAT_00102004;
if... |
5,822 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| char* func0(char* text) {
regex_t regex;
int result;
char* pattern = "[A-Z]+[a-z]+$";
regcomp(®ex, pattern, REG_EXTENDED);
result = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if(result == 0) {
return "Yes";
} else {
return "No";
}
}... | int main() {
assert(func0("Geeks") == "Yes");
assert(func0("geeksforGeeks") == "Yes");
assert(func0("geeks") == "No");
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xd76(%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, 1
mov r12, rdi
lea rsi, aAZAZ; "[A-Z]+[a-z]+$"
push rbp
push rbx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
xor edx, edx
xor r8d, r8d
xor ecx, ecx
mov rsi, r12
m... | void * func0(long long a1)
{
int v1; // ebx
void *result; // rax
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "[A-Z]+[a-z]+$", 1LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
result = &unk_2004;
if ( v1 )
return &unk_2008;
return result;
} | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
MOV R12,RDI
LEA RSI,[0x10200b]
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... | int * func0(char *param_1)
{
int iVar1;
int *puVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"[A-Z]+[a-z]+$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
puVar2 = &DAT_00102004;
if... |
5,823 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| char* func0(char* text) {
regex_t regex;
int result;
char* pattern = "[A-Z]+[a-z]+$";
regcomp(®ex, pattern, REG_EXTENDED);
result = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if(result == 0) {
return "Yes";
} else {
return "No";
}
}... | int main() {
assert(func0("Geeks") == "Yes");
assert(func0("geeksforGeeks") == "Yes");
assert(func0("geeks") == "No");
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xd76(%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, 1; cflags
lea rsi, pattern; "[A-Z]+[a-z]+$"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
xor edx, edx; nmatch
xor r8d, r8d; eflags
xor ecx, ec... | void * func0(char *string)
{
int v1; // ebx
void *result; // rax
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
regcomp(&_0, "[A-Z]+[a-z]+$", 1);
v1 = regexec(&_0, string, 0LL, 0LL, 0);
regfree(&_0);
result = &unk_2008;
if ( !... | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x10200b]
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... | int * func0(char *param_1)
{
int iVar1;
int *puVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"[A-Z]+[a-z]+$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
puVar2 = &DAT_00102008;
if... |
5,824 | func0 |
#include <assert.h>
| int func0(int x) {
int i = 1;
int fact = 1;
for (i = 1; i < x; i++) {
fact = fact * i;
if (fact % x == 0) {
return i;
}
}
return i - 1;
}
| int main() {
assert(func0(10) == 5);
assert(func0(15) == 5);
assert(func0(5) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
movl $0x1,-0x8(%rbp)
jmp 118b <func0+0x42>
mov -0x4(%rbp),%eax
imul -0x8(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltd
idivl -0x14(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 1
mov [rbp+var_4], 1
mov [rbp+var_8], 1
jmp short loc_118B
loc_116B:
mov eax, [rbp+var_4]
imul eax, [rbp+var_8]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cdq
idiv [rbp+var_14]
mov eax, edx
test ... | long long func0(int a1)
{
int i; // [rsp+Ch] [rbp-8h]
int v3; // [rsp+10h] [rbp-4h]
v3 = 1;
for ( i = 1; i < a1; ++i )
{
v3 *= i;
if ( !(v3 % a1) )
return (unsigned int)i;
}
return (unsigned int)(i - 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x1
MOV dword ptr [RBP + -0x8],0x1
JMP 0x0010118b
LAB_0010116b:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQ
I... | int func0(int param_1)
{
int local_10;
int local_c;
local_c = 1;
local_10 = 1;
while( true ) {
if (param_1 <= local_10) {
return local_10 + -1;
}
local_c = local_c * local_10;
if (local_c % param_1 == 0) break;
local_10 = local_10 + 1;
}
return local_10;
} |
5,825 | func0 |
#include <assert.h>
| int func0(int x) {
int i = 1;
int fact = 1;
for (i = 1; i < x; i++) {
fact = fact * i;
if (fact % x == 0) {
return i;
}
}
return i - 1;
}
| int main() {
assert(func0(10) == 5);
assert(func0(15) == 5);
assert(func0(5) == 4);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%edi
jle 1177 <func0+0x2e>
mov $0x1,%eax
cltd
idiv %edi
mov %edx,%esi
test %edx,%edx
je 1182 <func0+0x39>
mov %edx,%ecx
add $0x1,%esi
cmp %esi,%edi
je 117c <func0+0x33>
imul %esi,%ecx
mov %ecx,%eax
cltd
idiv %edi
test %edx,%edx
jne 1162 <func0+0x19>
j... | func0:
endbr64
cmp edi, 1
jle short loc_1177
mov eax, 1
cdq
idiv edi
mov esi, edx
test edx, edx
jz short loc_1182
mov ecx, edx
loc_1162:
add esi, 1
cmp edi, esi
jz short loc_117C
imul ecx, esi
mov eax, ecx
cdq
idiv edi
test edx, edx
jnz short loc_1162
jmp ... | long long func0(int a1)
{
unsigned int v1; // esi
int v2; // ecx
if ( a1 <= 1 )
{
a1 = 1;
}
else
{
v1 = 1 % a1;
if ( !(1 % a1) )
return 1;
v2 = 1 % a1;
while ( a1 != ++v1 )
{
v2 *= v1;
if ( !(v2 % a1) )
return v1;
}
}
return (unsigned int)(a1 - 1... | func0:
ENDBR64
CMP EDI,0x1
JLE 0x00101177
MOV EAX,0x1
CDQ
IDIV EDI
MOV ESI,EDX
TEST EDX,EDX
JZ 0x00101182
MOV ECX,EDX
LAB_00101162:
ADD ESI,0x1
CMP EDI,ESI
JZ 0x0010117c
IMUL ECX,ESI
MOV EAX,ECX
CDQ
IDIV EDI
TEST EDX,EDX
JNZ 0x00101162
JMP 0x0010117f
LAB_00101177:
MOV EDI,0x1
LAB_0010117c:
LEA ESI,[RDI + -0x1]
LAB_0010... | ulong func0(uint param_1)
{
ulong uVar1;
uint uVar2;
ulong uVar3;
if ((int)param_1 < 2) {
param_1 = 1;
LAB_0010117c:
uVar3 = (ulong)(param_1 - 1);
}
else {
uVar1 = 1 % (long)(int)param_1;
uVar3 = uVar1 & 0xffffffff;
if ((int)uVar1 == 0) {
uVar3 = 1;
}
else {
uVar1... |
5,826 | func0 |
#include <assert.h>
| int func0(int x) {
int i = 1;
int fact = 1;
for (i = 1; i < x; i++) {
fact = fact * i;
if (fact % x == 0) {
return i;
}
}
return i - 1;
}
| int main() {
assert(func0(10) == 5);
assert(func0(15) == 5);
assert(func0(5) == 4);
return 0;
}
| O2 | c | func0:
endbr64
mov $0x1,%ecx
mov $0x1,%r8d
xor %eax,%eax
cmp $0x1,%edi
jg 123d <func0+0x2d>
jmp 1249 <func0+0x39>
nopl 0x0(%rax,%rax,1)
imul %r8d,%ecx
mov %ecx,%eax
cltd
idiv %edi
test %edx,%edx
je 124c <func0+0x3c>
mov %r8d,%eax
add $0x1,%r8d
cmp %r8d,%edi
jne 1230 <func0+... | func0:
endbr64
mov ecx, 1
mov r8d, 1
xor eax, eax
cmp edi, 1
jg short loc_123D
jmp short loc_1249
loc_1230:
imul ecx, r8d
mov eax, ecx
cdq
idiv edi
test edx, edx
jz short loc_124C
loc_123D:
mov eax, r8d
add r8d, 1
cmp edi, r8d
jnz short loc_1230
loc_1249:
mov ... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // r8d
unsigned int v3; // eax
v1 = 1;
v2 = 1;
v3 = 0;
if ( a1 > 1 )
{
while ( 1 )
{
v3 = v2++;
if ( a1 == v2 )
break;
v1 *= v2;
if ( !(v1 % a1) )
return v2;
}
}
return v3;
} | func0:
ENDBR64
MOV ECX,0x1
MOV R8D,0x1
XOR EAX,EAX
CMP EDI,0x1
JG 0x0010123d
JMP 0x00101249
LAB_00101230:
IMUL ECX,R8D
MOV EAX,ECX
CDQ
IDIV EDI
TEST EDX,EDX
JZ 0x0010124c
LAB_0010123d:
MOV EAX,R8D
ADD R8D,0x1
CMP EDI,R8D
JNZ 0x00101230
LAB_00101249:
MOV R8D,EAX
LAB_0010124c:
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar1 = 1;
iVar3 = 0;
iVar2 = 1;
if (1 < param_1) {
do {
iVar3 = iVar2 + 1;
if (param_1 == iVar3) {
return iVar2;
}
iVar1 = iVar1 * iVar3;
iVar2 = iVar3;
} while (iVar1 % param_1 != 0);
}
return... |
5,827 | func0 |
#include <assert.h>
| int func0(int x) {
int i = 1;
int fact = 1;
for (i = 1; i < x; i++) {
fact = fact * i;
if (fact % x == 0) {
return i;
}
}
return i - 1;
}
| int main() {
assert(func0(10) == 5);
assert(func0(15) == 5);
assert(func0(5) == 4);
return 0;
}
| O3 | c | func0:
endbr64
mov $0x1,%ecx
mov $0x1,%r8d
xor %eax,%eax
cmp $0x1,%edi
jg 116d <func0+0x2d>
jmp 1179 <func0+0x39>
nopl 0x0(%rax,%rax,1)
imul %r8d,%ecx
mov %ecx,%eax
cltd
idiv %edi
test %edx,%edx
je 117c <func0+0x3c>
mov %r8d,%eax
add $0x1,%r8d
cmp %r8d,%edi
jne 1160 <func0+... | func0:
endbr64
mov esi, 1
mov ecx, 1
xor eax, eax
cmp edi, 1
jg short loc_116C
jmp short loc_1175
loc_1160:
imul esi, ecx
mov eax, esi
cdq
idiv edi
test edx, edx
jz short loc_1177
loc_116C:
mov eax, ecx
add ecx, 1
cmp edi, ecx
jnz short loc_1160
loc_1175:
mov ... | long long func0(int a1)
{
int v1; // esi
unsigned int v2; // ecx
unsigned int v3; // eax
v1 = 1;
v2 = 1;
v3 = 0;
if ( a1 > 1 )
{
while ( 1 )
{
v3 = v2++;
if ( a1 == v2 )
break;
v1 *= v2;
if ( !(v1 % a1) )
return v2;
}
}
return v3;
} | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
XOR EAX,EAX
CMP EDI,0x1
JG 0x0010116c
JMP 0x00101175
LAB_00101160:
IMUL ESI,ECX
MOV EAX,ESI
CDQ
IDIV EDI
TEST EDX,EDX
JZ 0x00101177
LAB_0010116c:
MOV EAX,ECX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x00101160
LAB_00101175:
MOV ECX,EAX
LAB_00101177:
MOV EAX,ECX
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar2 = 0;
iVar1 = 1;
if (1 < param_1) {
do {
iVar2 = iVar1 + 1;
if (param_1 == iVar2) {
return iVar1;
}
iVar3 = iVar3 * iVar2;
iVar1 = iVar2;
} while (iVar3 % param_1 != 0);
}
return... |
5,828 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char* first;
char* second;
} Tuple;
| Tuple* func0(Tuple* test_list1, int size1, Tuple* test_list2, int size2, int* res_size) {
Tuple* res = malloc(size1 * sizeof(Tuple));
int count = 0;
for(int i = 0; i < size1; i++) {
int found = 0;
for(int j = 0; j < size2; j++) {
if(strcmp(test_list1[i].first, test_list2[j]... | int main(){
// Test case 1
Tuple test1_1[] = { {"Hello", "dude"}, {"How", "are"}, {"you", "?"} };
Tuple test2_1[] = { {"Hello", "dude"}, {"How", "are"} };
int res_size1;
Tuple* res1 = func0(test1_1, 3, test2_1, 2, &res_size1);
Tuple expected1[] = { {"you", "?"} };
assert(res_size1 == ... | 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 %ecx,-0x30(%rbp)
mov %r8,-0x40(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x18(%rbp)
movl... | 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 [rbp+var_30], ecx
mov [rbp+var_40], r8
mov eax, [rbp+var_2C]
cdqe
shl rax, 4
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_18]... | char * func0(long long a1, int a2, long long a3, int a4, _DWORD *a5)
{
_QWORD *v5; // rsi
int v6; // eax
char *v7; // rcx
long long v8; // rdx
int v14; // [rsp+28h] [rbp-18h]
int i; // [rsp+2Ch] [rbp-14h]
int v16; // [rsp+30h] [rbp-10h]
int j; // [rsp+34h] [rbp-Ch]
char *v18; // [rsp+38h] [rbp-8h]
... | 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 dword ptr [RBP + -0x30],ECX
MOV qword ptr [RBP + -0x40],R8
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x4
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV ... | void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
int8 *puVar1;
int8 *puVar2;
int8 uVar3;
bool bVar4;
int iVar5;
void *pvVar6;
int local_20;
int local_1c;
int local_14;
pvVar6 = malloc((long)param_2 << 4);
local_20 = 0;
local_1c = 0;
do {
if (param_2 <= loc... |
5,829 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char* first;
char* second;
} Tuple;
| Tuple* func0(Tuple* test_list1, int size1, Tuple* test_list2, int size2, int* res_size) {
Tuple* res = malloc(size1 * sizeof(Tuple));
int count = 0;
for(int i = 0; i < size1; i++) {
int found = 0;
for(int j = 0; j < size2; j++) {
if(strcmp(test_list1[i].first, test_list2[j]... | int main(){
// Test case 1
Tuple test1_1[] = { {"Hello", "dude"}, {"How", "are"}, {"you", "?"} };
Tuple test2_1[] = { {"Hello", "dude"}, {"How", "are"} };
int res_size1;
Tuple* res1 = func0(test1_1, 3, test2_1, 2, &res_size1);
Tuple expected1[] = { {"you", "?"} };
assert(res_size1 == ... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r12
mov %esi,%ebp
mov %rdx,%rbx
mov %ecx,%r15d
mov %ecx,0xc(%rsp)
mov %r8,0x28(%rsp)
movslq %esi,%rdi
shl $0x4,%rdi
callq 10d0 <malloc@plt>
mov %rax,0x20(%rsp)
test %ebp,%ebp
jle... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov rbp, rdi
mov ebx, esi
mov r13, rdx
mov [rsp+68h+var_50], rdx
mov r15d, ecx
mov [rsp+68h+var_5C], ecx
mov [rsp+68h+var_40], r8
movsxd rdi, esi
shl rdi, 4
call _malloc
mov [r... | long long func0(const __m128i *a1, int a2, _QWORD *a3, int a4, _DWORD *a5)
{
const __m128i *v7; // r14
long long v8; // r12
int v9; // r15d
_QWORD *v10; // rbx
long long v12; // rbp
long long v15; // [rsp+20h] [rbp-48h]
v15 = malloc(16LL * a2);
if ( a2 <= 0 )
{
v9 = 0;
}
else
{
v7 = a1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RBP,RDI
MOV EBX,ESI
MOV R13,RDX
MOV qword ptr [RSP + 0x18],RDX
MOV R15D,ECX
MOV dword ptr [RSP + 0xc],ECX
MOV qword ptr [RSP + 0x28],R8
MOVSXD RDI,ESI
SHL RDI,0x4
CALL 0x001010d0
MOV qword ptr [RSP + 0x20],RAX
TEST EBX,EBX
JLE 0x00101... | void * func0(int8 *param_1,int param_2,int8 *param_3,int param_4,int *param_5)
{
int8 *puVar1;
char *__s1;
int8 uVar2;
int iVar3;
void *pvVar4;
int8 *puVar5;
int iVar6;
pvVar4 = malloc((long)param_2 << 4);
if (param_2 < 1) {
iVar6 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) *... |
5,830 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char* first;
char* second;
} Tuple;
| Tuple* func0(Tuple* test_list1, int size1, Tuple* test_list2, int size2, int* res_size) {
Tuple* res = malloc(size1 * sizeof(Tuple));
int count = 0;
for(int i = 0; i < size1; i++) {
int found = 0;
for(int j = 0; j < size2; j++) {
if(strcmp(test_list1[i].first, test_list2[j]... | int main(){
// Test case 1
Tuple test1_1[] = { {"Hello", "dude"}, {"How", "are"}, {"you", "?"} };
Tuple test2_1[] = { {"Hello", "dude"}, {"How", "are"} };
int res_size1;
Tuple* res1 = func0(test1_1, 3, test2_1, 2, &res_size1);
Tuple expected1[] = { {"you", "?"} };
assert(res_size1 == ... | O2 | c | func0:
endbr64
push %r15
mov %rdx,%r15
push %r14
mov %ecx,%r14d
push %r13
push %r12
mov %rdi,%r12
movslq %esi,%rdi
push %rbp
push %rbx
mov %rdi,%rbx
shl $0x4,%rdi
sub $0x28,%rsp
mov %rdx,0x8(%rsp)
mov %r8,0x18(%rsp)
callq 10d0 <malloc@plt>
mov %rax,0x10(%rsp)
test %ebx,%ebx
jle... | func0:
endbr64
push r15
mov r15, rdx
push r14
mov r14d, ecx
push r13
push r12
mov r12, rdi
movsxd rdi, esi
push rbp
push rbx
mov rbx, rdi
shl rdi, 4
sub rsp, 28h
mov [rsp+58h+var_50], rdx
mov [rsp+58h+var_40], r8
call _malloc
mov [rsp+58h+var_48], rax
test eb... | long long func0(const __m128i *a1, int a2, _QWORD *a3, int a4, _DWORD *a5)
{
const __m128i *v7; // r12
int v8; // r13d
long long v9; // rbp
long long v10; // rbx
_QWORD *v11; // r15
long long v12; // rax
long long v15; // [rsp+10h] [rbp-48h]
v7 = a1;
v15 = malloc(16LL * a2);
if ( a2 <= 0 )
{
... | func0:
ENDBR64
PUSH R15
MOV R15,RDX
PUSH R14
MOV R14D,ECX
PUSH R13
PUSH R12
MOV R12,RDI
MOVSXD RDI,ESI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SHL RDI,0x4
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP + 0x18],R8
CALL 0x001010d0
MOV qword ptr [RSP + 0x10],RAX
TEST EBX,EBX
JLE 0x0010172a
LEA EAX,[RBX + -0x1]
XOR R1... | void * func0(int8 *param_1,int param_2,int8 *param_3,int param_4,int *param_5)
{
int8 *puVar1;
char *__s1;
int8 uVar2;
int iVar3;
void *pvVar4;
long lVar5;
int iVar6;
int8 *puVar7;
pvVar4 = malloc((long)param_2 << 4);
if (param_2 < 1) {
iVar6 = 0;
}
else {
iVar6 = 0;
puVar1 = par... |
5,831 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
char* first;
char* second;
} Tuple;
| Tuple* func0(Tuple* test_list1, int size1, Tuple* test_list2, int size2, int* res_size) {
Tuple* res = malloc(size1 * sizeof(Tuple));
int count = 0;
for(int i = 0; i < size1; i++) {
int found = 0;
for(int j = 0; j < size2; j++) {
if(strcmp(test_list1[i].first, test_list2[j]... | int main(){
// Test case 1
Tuple test1_1[] = { {"Hello", "dude"}, {"How", "are"}, {"you", "?"} };
Tuple test2_1[] = { {"Hello", "dude"}, {"How", "are"} };
int res_size1;
Tuple* res1 = func0(test1_1, 3, test2_1, 2, &res_size1);
Tuple expected1[] = { {"you", "?"} };
assert(res_size1 == ... | O3 | c | func0:
endbr64
push %r15
mov %rdx,%r15
push %r14
mov %ecx,%r14d
push %r13
push %r12
mov %rdi,%r12
movslq %esi,%rdi
push %rbp
push %rbx
mov %rdi,%rbx
shl $0x4,%rdi
sub $0x28,%rsp
mov %rdx,0x8(%rsp)
mov %r8,0x18(%rsp)
callq 10d0 <malloc@plt>
mov %rax,0x10(%rsp)
test %ebx,%ebx
jle... | func0:
endbr64
push r15
mov r15, rdx
push r14
movsxd r14, esi
push r13
push r12
mov r12, rdi
push rbp
movsxd rbp, ecx
push rbx
mov rbx, r14
shl r14, 4
mov rdi, r14; size
sub rsp, 28h
mov [rsp+58h+var_44], ebp
mov [rsp+58h+var_40], r8
call _malloc
mov [rsp+58h+v... | __m128i * func0(long long a1, int a2, const char **a3, int a4, _DWORD *a5)
{
long long v6; // r12
long long v7; // rbp
long long v8; // r13
const char **v9; // rbp
const char *v10; // rbx
const char **v11; // r14
__m128i v12; // xmm0
int v13; // eax
long long v15; // [rsp+0h] [rbp-58h]
__m128i *v16;... | func0:
ENDBR64
PUSH R15
MOV R15,RDX
PUSH R14
MOVSXD R14,ESI
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOVSXD RBP,ECX
PUSH RBX
MOV RBX,R14
SHL R14,0x4
MOV RDI,R14
SUB RSP,0x28
MOV dword ptr [RSP + 0x14],EBP
MOV qword ptr [RSP + 0x18],R8
CALL 0x001010d0
MOV qword ptr [RSP + 0x8],RAX
TEST EBX,EBX
JLE 0x001017d0
LEA RAX,[R12 ... | void * func0(int8 *param_1,int param_2,int8 *param_3,int param_4,int *param_5)
{
int8 *puVar1;
char *__s1;
int8 uVar2;
int8 uVar3;
int iVar4;
int iVar5;
void *pvVar6;
long lVar7;
int8 *puVar8;
pvVar6 = malloc((long)param_2 * 0x10);
if (param_2 < 1) {
iVar5 = 0;
}
else {
puVar1 = pa... |
5,832 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
bool is_palindrome(int n) {
int divisor = 1;
while (n / divisor >= 10) {
divisor *= 10;
}
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing) {
... | int func0(int A[], int n) {
int i, j, temp;
// Sorting the array A
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (A[i] > A[j]) {
temp = A[j];
A[j] = A[i];
A[i] = temp;
}
}
}
// Finding ... | int main() {
int arr1[4] = {1, 232, 54545, 999991};
int arr2[6] = {1, 2, 3, 4, 5, 50};
int arr3[5] = {1, 3, 7, 9, 45};
assert(func0(arr1, 4) == 54545);
assert(func0(arr2, 6) == 5);
assert(func0(arr3, 5) == 9);
printf("All test cases passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1326 <func0+0xd0>
mov -0xc(%rbp),%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
jmpq 1316 <func0+0xc0>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
jmp loc_1324
loc_1273:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_8], eax
jmp loc_1314
loc_1281:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov ra... | long long func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-Ch]
int k; // [rsp+14h] [rbp-Ch]
int j; // [rsp+18h] [rbp-8h]
int v6; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) > *(_DWORD *)(4LL * j + a1) )
{
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101324
LAB_00101273:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101314
LAB_00101281:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,... | int4 func0(long param_1,int param_2)
{
int4 uVar1;
char cVar2;
int local_14;
int local_10;
for (local_14 = 0; local_10 = local_14, local_14 < param_2; local_14 = local_14 + 1) {
while (local_10 = local_10 + 1, local_10 < param_2) {
if (*(int *)(param_1 + (long)local_10 * 4) < *(int *)(param_1 + ... |
5,833 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
bool is_palindrome(int n) {
int divisor = 1;
while (n / divisor >= 10) {
divisor *= 10;
}
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing) {
... | int func0(int A[], int n) {
int i, j, temp;
// Sorting the array A
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (A[i] > A[j]) {
temp = A[j];
A[j] = A[i];
A[i] = temp;
}
}
}
// Finding ... | int main() {
int arr1[4] = {1, 232, 54545, 999991};
int arr2[6] = {1, 2, 3, 4, 5, 50};
int arr3[5] = {1, 3, 7, 9, 45};
assert(func0(arr1, 4) == 54545);
assert(func0(arr2, 6) == 5);
assert(func0(arr3, 5) == 9);
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
test %esi,%esi
jle 1295 <func0+0x49>
mov %rdi,%rbx
lea -0x1(%rsi),%r9d
add $0x1,%r9
mov $0x1,%r8d
jmp 128b <func0+0x3f>
add $0x1,%rax
cmp %eax,%esi
jle 1283 <func0+0x37>
mov (%rdi),%ecx
mov (%rbx,%rax,4),%edx
cmp %edx,%ecx
jle 1... | func0:
endbr64
push r12
push rbp
push rbx
test esi, esi
jle short loc_12AE
mov rbx, rdi
lea rdi, [rdi+4]
lea ebp, [rsi-1]
mov r10d, esi
mov r9d, 1
lea r11, [rbx+8]
jmp short loc_1296
loc_1275:
add rax, 4
cmp rax, r8
jz short loc_128E
loc_127E:
mov ecx, [rdi-4... | long long func0(long long a1, int a2)
{
int *v3; // rdi
long long i; // r9
int *v5; // rax
int v6; // ecx
int v7; // edx
unsigned int v8; // r12d
long long v9; // rbp
if ( a2 <= 0 )
{
return (unsigned int)-1;
}
else
{
v3 = (int *)(a1 + 4);
for ( i = 1LL; i != a2; ++i )
{
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x001012ae
MOV RBX,RDI
LEA RDI,[RDI + 0x4]
LEA EBP,[RSI + -0x1]
MOV R10D,ESI
MOV R9D,0x1
LEA R11,[RBX + 0x8]
JMP 0x00101296
LAB_00101275:
ADD RAX,0x4
CMP RAX,R8
JZ 0x0010128e
LAB_0010127e:
MOV ECX,dword ptr [RDI + -0x4]
MOV EDX,dword ptr [RAX]
CMP ECX,EDX
JLE 0... | int4 func0(long param_1,uint param_2)
{
int iVar1;
int4 uVar2;
char cVar3;
int *piVar4;
long lVar5;
int *piVar6;
ulong uVar7;
if (0 < (int)param_2) {
piVar6 = (int *)(param_1 + 4);
for (uVar7 = 1; uVar7 != param_2; uVar7 = uVar7 + 1) {
piVar4 = piVar6;
do {
iVar1 = *piVar... |
5,834 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
bool is_palindrome(int n) {
int divisor = 1;
while (n / divisor >= 10) {
divisor *= 10;
}
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing) {
... | int func0(int A[], int n) {
int i, j, temp;
// Sorting the array A
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (A[i] > A[j]) {
temp = A[j];
A[j] = A[i];
A[i] = temp;
}
}
}
// Finding ... | int main() {
int arr1[4] = {1, 232, 54545, 999991};
int arr2[6] = {1, 2, 3, 4, 5, 50};
int arr3[5] = {1, 3, 7, 9, 45};
assert(func0(arr1, 4) == 54545);
assert(func0(arr2, 6) == 5);
assert(func0(arr3, 5) == 9);
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
lea -0x1(%rsi),%r10d
test %esi,%esi
jle 14ee <func0+0x13e>
mov %r10d,%r11d
mov $0x1,%r9d
mov %rdi,%r8
add $0x1,%r11
cmp %r11,%r9
je 1405 <func0+0x55>
nopl (%rax)
mov %r9,%rax
nopl 0x0(%rax,%rax,1)
mov (%r8),%ecx
mov (%rdi,%rax,4),%edx
cmp %edx,%ecx
jle 13f0 <... | func0:
endbr64
push rbx
lea r10d, [rsi-1]
test esi, esi
jle loc_14EF
mov r11d, esi
mov r9d, 1
lea r8, [rdi+4]
lea rbx, [rdi+8]
cmp r9, r11
jz short loc_13FE
nop word ptr [rax+rax+00000000h]
loc_13C0:
mov eax, r10d
sub eax, r9d
lea rax, [r9+rax-1]
lea rsi, [rbx+... | long long func0(long long a1, int a2)
{
long long j; // r10
long long v3; // r9
int *i; // r8
int *v5; // rax
int v6; // ecx
int v7; // edx
int v8; // r8d
int v9; // ecx
int v10; // esi
long long v11; // rdx
unsigned long long v12; // rdx
LODWORD(j) = a2 - 1;
if ( a2 > 0 )
{
v3 = 1LL;
... | func0:
ENDBR64
PUSH RBX
LEA R10D,[RSI + -0x1]
TEST ESI,ESI
JLE 0x001014ef
MOV R11D,ESI
MOV R9D,0x1
LEA R8,[RDI + 0x4]
LEA RBX,[RDI + 0x8]
CMP R9,R11
JZ 0x001013fe
NOP word ptr [RAX + RAX*0x1]
LAB_001013c0:
MOV EAX,R10D
SUB EAX,R9D
LEA RAX,[R9 + RAX*0x1 + -0x1]
LEA RSI,[RBX + RAX*0x4]
MOV RAX,R8
NOP word ptr [RAX + RAX*... | uint func0(long param_1,uint param_2)
{
int iVar1;
uint uVar2;
uint uVar3;
int *piVar4;
uint uVar5;
ulong uVar6;
int *piVar7;
ulong uVar8;
int iVar9;
long lVar10;
iVar9 = param_2 - 1;
if ((int)param_2 < 1) {
if (iVar9 < 0) {
return 0xffffffff;
}
}
else {
uVar8 = 1;
... |
5,835 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
bool is_palindrome(int n) {
int divisor = 1;
while (n / divisor >= 10) {
divisor *= 10;
}
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing) {
... | int func0(int A[], int n) {
int i, j, temp;
// Sorting the array A
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (A[i] > A[j]) {
temp = A[j];
A[j] = A[i];
A[i] = temp;
}
}
}
// Finding ... | int main() {
int arr1[4] = {1, 232, 54545, 999991};
int arr2[6] = {1, 2, 3, 4, 5, 50};
int arr3[5] = {1, 3, 7, 9, 45};
assert(func0(arr1, 4) == 54545);
assert(func0(arr2, 6) == 5);
assert(func0(arr3, 5) == 9);
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rsi),%r10d
test %esi,%esi
jle 14be <func0+0x13e>
cmp $0x1,%esi
je 13d2 <func0+0x52>
lea -0x2(%rsi),%r9d
mov $0x1,%r8d
add $0x2,%r9
nopl 0x0(%rax,%rax,1)
mov -0x4(%rdi,%r8,4),%ecx
mov %r8,%rax
mov (%rdi,%rax,4),%edx
cmp %ecx,%edx
jge 13c1 <func0+0x41>
mov... | func0:
endbr64
mov r8, rdi
test esi, esi
jle loc_149D
cmp esi, 1
jz short loc_13D4
mov r9d, esi
mov edi, 1
nop dword ptr [rax+00h]
loc_13A0:
mov ecx, [r8+rdi*4-4]
mov rax, rdi
nop dword ptr [rax+rax+00000000h]
loc_13B0:
mov edx, [r8+rax*4]
cmp edx, ecx
jge short l... | long long func0(long long a1, int a2)
{
long long i; // rdi
int v4; // ecx
long long v5; // rax
int v6; // edx
long long v7; // r9
int v8; // edi
int v9; // esi
int v10; // eax
int v11; // ecx
int v12; // edx
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
if ( a2 != 1 )
{
for ( i = 1LL; i != a2... | func0:
ENDBR64
MOV R8,RDI
TEST ESI,ESI
JLE 0x0010149d
CMP ESI,0x1
JZ 0x001013d4
MOV R9D,ESI
MOV EDI,0x1
NOP dword ptr [RAX]
LAB_001013a0:
MOV ECX,dword ptr [R8 + RDI*0x4 + -0x4]
MOV RAX,RDI
NOP dword ptr [RAX + RAX*0x1]
LAB_001013b0:
MOV EDX,dword ptr [R8 + RAX*0x4]
CMP EDX,ECX
JGE 0x001013c3
MOV dword ptr [R8 + RAX*0x... | int func0(long param_1,uint param_2)
{
int iVar1;
ulong uVar2;
int iVar3;
int iVar4;
int iVar5;
ulong uVar6;
long lVar7;
if (0 < (int)param_2) {
if (param_2 != 1) {
uVar6 = 1;
do {
iVar3 = *(int *)(param_1 + -4 + uVar6 * 4);
uVar2 = uVar6;
do {
iVar5... |
5,836 | func0 | #include <assert.h>
#include <math.h>
| double func0(int n, int r, double p) {
int r0 = r;
if (r > n / 2) r = n - r;
double answer = 1.0;
for (int i = 1; i <= r; i++) {
answer *= (n - r + i);
answer /= i;
}
return answer * pow(p, r0) * pow(1 - p, n - r0);
}
| int main() {
assert(fabs(func0(10, 5, 1.0 / 3) - 0.13656454808718185) < 0.0000001);
assert(fabs(func0(11, 6, 2.0 / 4) - 0.2255859375) < 0.0000001);
assert(fabs(func0(12, 7, 3.0 / 5) - 0.227030335488) < 0.0000001);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movsd %xmm0,-0x20(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x18(%rbp)
jle 11a0 <func0+0x37>
m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
movsd [rbp+x], xmm0
mov eax, [rbp+var_18]
mov [rbp+var_C], eax
mov eax, [rbp+var_14]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_18], eax
jle short lo... | double func0(int a1, int a2, double a3)
{
double v4; // [rsp+8h] [rbp-28h]
int v6; // [rsp+18h] [rbp-18h]
int i; // [rsp+20h] [rbp-10h]
double v8; // [rsp+28h] [rbp-8h]
v6 = a2;
if ( a2 > a1 / 2 )
v6 = a1 - a2;
v8 = 1.0;
for ( i = 1; i <= v6; ++i )
v8 = (double)(a1 - v6 + i) * v8 / (double)i;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOVSD qword ptr [RBP + -0x20],XMM0
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x18],... | double func0(double param_1,int param_2,int param_3)
{
double dVar1;
double dVar2;
int4 local_20;
int4 local_18;
int8 local_10;
local_20 = param_3;
if (param_2 / 2 < param_3) {
local_20 = param_2 - param_3;
}
local_10 = DAT_001020e8;
for (local_18 = 1; local_18 <= local_20; local_18 = local_... |
5,837 | func0 | #include <assert.h>
#include <math.h>
| double func0(int n, int r, double p) {
int r0 = r;
if (r > n / 2) r = n - r;
double answer = 1.0;
for (int i = 1; i <= r; i++) {
answer *= (n - r + i);
answer /= i;
}
return answer * pow(p, r0) * pow(1 - p, n - r0);
}
| int main() {
assert(fabs(func0(10, 5, 1.0 / 3) - 0.13656454808718185) < 0.0000001);
assert(fabs(func0(11, 6, 2.0 / 4) - 0.2255859375) < 0.0000001);
assert(fabs(func0(12, 7, 3.0 / 5) - 0.227030335488) < 0.0000001);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x28,%rsp
mov %edi,%ebx
mov %esi,%ebp
movsd %xmm0,0x10(%rsp)
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
mov %edi,%edx
sub %esi,%edx
cmp %esi,%eax
mov %edx,%eax
cmovge %esi,%eax
test %eax,%eax
jle 122e <func0+0xc5>
lea 0x1(%ra... | func0:
endbr64
push r15
push r14
push rbp
push rbx
sub rsp, 18h
mov ebx, edi
mov ebp, esi
movq r14, xmm0
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
mov edx, edi
sub edx, esi
cmp eax, esi
cmovge edx, esi
test edx, edx
jle loc_1233
lea esi, [rdx+1]... | double func0(int a1, int a2, double a3)
{
int v4; // edx
int v5; // eax
double v6; // r15
double v8; // [rsp+8h] [rbp-30h]
v4 = a1 - a2;
if ( a1 / 2 >= a2 )
v4 = a2;
if ( v4 <= 0 )
{
v8 = 1.0;
}
else
{
v5 = 1;
v8 = 1.0;
do
{
v8 = (double)(a1 - v4 + v5) * v8 / (doubl... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV EBX,EDI
MOV EBP,ESI
MOVQ R14,XMM0
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
MOV EDX,EDI
SUB EDX,ESI
CMP EAX,ESI
CMOVGE EDX,ESI
TEST EDX,EDX
JLE 0x00101233
LEA ESI,[RDX + 0x1]
MOV EAX,0x1
MOVSD XMM5,qword ptr [0x001020e0]
MOVSD qword ptr [RSP + 0... | double func0(double param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
double dVar3;
double dVar4;
int8 local_30;
iVar2 = param_2 - param_3;
if (param_3 <= param_2 / 2) {
iVar2 = param_3;
}
if (iVar2 < 1) {
local_30 = DAT_001020e0;
}
else {
iVar1 = 1;
local_30 = DAT_00102... |
5,838 | func0 | #include <assert.h>
#include <math.h>
| double func0(int n, int r, double p) {
int r0 = r;
if (r > n / 2) r = n - r;
double answer = 1.0;
for (int i = 1; i <= r; i++) {
answer *= (n - r + i);
answer /= i;
}
return answer * pow(p, r0) * pow(1 - p, n - r0);
}
| int main() {
assert(fabs(func0(10, 5, 1.0 / 3) - 0.13656454808718185) < 0.0000001);
assert(fabs(func0(11, 6, 2.0 / 4) - 0.2255859375) < 0.0000001);
assert(fabs(func0(12, 7, 3.0 / 5) - 0.227030335488) < 0.0000001);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
push %rbx
mov %edi,%ebx
mov %esi,%ecx
shr $0x1f,%eax
sub %esi,%ebx
movapd %xmm0,%xmm3
add %edi,%eax
sar %eax
sub $0x20,%rsp
cmp %esi,%eax
cmovl %ebx,%ecx
test %ecx,%ecx
jle 1340 <func0+0xc0>
movsd 0xe4f(%rip),%xmm4
sub %ecx,%edi
mov $0x1,%eax
add ... | func0:
endbr64
mov eax, edi
push rbx
mov ebx, edi
mov ecx, esi
shr eax, 1Fh
sub ebx, esi
movapd xmm3, xmm0
add eax, edi
sar eax, 1
sub rsp, 20h
cmp eax, esi
cmovl ecx, ebx
test ecx, ecx
jle loc_1350
movsd xmm4, cs:qword_20E0
sub edi, ecx
mov eax, 1
add ecx,... | double func0(int a1, int a2, double a3)
{
int v3; // ecx
int v4; // ebx
int v5; // edi
int v6; // eax
int v7; // ecx
double v8; // xmm2_8
int v9; // edx
double v10; // xmm1_8
double v12; // [rsp+0h] [rbp-28h]
v3 = a2;
v4 = a1 - a2;
if ( a1 / 2 < a2 )
v3 = a1 - a2;
if ( v3 <= 0 )
{
... | func0:
ENDBR64
MOV EAX,EDI
PUSH RBX
MOV EBX,EDI
MOV ECX,ESI
SHR EAX,0x1f
SUB EBX,ESI
MOVAPD XMM3,XMM0
ADD EAX,EDI
SAR EAX,0x1
SUB RSP,0x20
CMP EAX,ESI
CMOVL ECX,EBX
TEST ECX,ECX
JLE 0x00101350
MOVSD XMM4,qword ptr [0x001020e0]
SUB EDI,ECX
MOV EAX,0x1
ADD ECX,0x1
MOVAPD XMM2,XMM4
NOP
LAB_001012c0:
LEA EDX,[RAX + RDI*0x1... | double func0(double param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
double dVar4;
double dVar5;
double dVar6;
dVar4 = DAT_001020e0;
iVar3 = param_3;
if (param_2 / 2 < param_3) {
iVar3 = param_2 - param_3;
}
dVar6 = DAT_001020e0;
if (0 < iVar3) {
iVar2 = 1;
do ... |
5,839 | func0 | #include <assert.h>
#include <math.h>
| double func0(int n, int r, double p) {
int r0 = r;
if (r > n / 2) r = n - r;
double answer = 1.0;
for (int i = 1; i <= r; i++) {
answer *= (n - r + i);
answer /= i;
}
return answer * pow(p, r0) * pow(1 - p, n - r0);
}
| int main() {
assert(fabs(func0(10, 5, 1.0 / 3) - 0.13656454808718185) < 0.0000001);
assert(fabs(func0(11, 6, 2.0 / 4) - 0.2255859375) < 0.0000001);
assert(fabs(func0(12, 7, 3.0 / 5) - 0.227030335488) < 0.0000001);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %edi,%eax
mov %edi,%ebx
shr $0x1f,%edi
add %eax,%edi
movapd %xmm0,%xmm3
sub %esi,%ebx
sar %edi
sub $0x20,%rsp
cmp %esi,%edi
jl 1350 <func0+0xd0>
mov %esi,%ecx
mov %ebx,%edi
test %ecx,%ecx
jle 135c <func0+0xdc>
movsd 0xe4a(%rip),%xmm4
add $0x1,%ec... | func0:
endbr64
mov eax, edi
push rbx
mov ebx, edi
movapd xmm3, xmm0
shr eax, 1Fh
sub ebx, esi
add eax, edi
sar eax, 1
sub rsp, 20h
cmp eax, esi
jl loc_1350
mov ecx, esi
mov edi, ebx
test ecx, ecx
jle loc_135C
loc_12AE:
movsd xmm4, cs:qword_20E0
add ecx, 1
mo... | double func0(int a1, int a2, double a3)
{
int v3; // ebx
int v4; // ecx
int v5; // edi
int v6; // ecx
int v7; // eax
double v8; // xmm2_8
int v9; // edx
double v10; // xmm1_8
double v12; // [rsp+0h] [rbp-28h]
v3 = a1 - a2;
if ( a1 / 2 >= a2 )
{
v4 = a2;
v5 = a1 - a2;
if ( a2 > 0 )
... | func0:
ENDBR64
MOV EAX,EDI
PUSH RBX
MOV EBX,EDI
MOVAPD XMM3,XMM0
SHR EAX,0x1f
SUB EBX,ESI
ADD EAX,EDI
SAR EAX,0x1
SUB RSP,0x20
CMP EAX,ESI
JL 0x00101350
MOV ECX,ESI
MOV EDI,EBX
TEST ECX,ECX
JLE 0x0010135c
LAB_001012ae:
MOVSD XMM4,qword ptr [0x001020e0]
ADD ECX,0x1
MOV EAX,0x1
MOVAPD XMM2,XMM4
NOP word ptr [RAX + RAX*0x... | double func0(double param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
double dVar6;
double dVar7;
double dVar8;
dVar6 = DAT_001020e0;
iVar4 = param_2 - param_3;
dVar8 = DAT_001020e0;
if (param_2 / 2 < param_3) {
iVar3 = iVar4;
iVar5 = param_3;
... |
5,840 | func0 |
#include <assert.h>
#include <string.h>
| void func0(int tuples[][2], int n) {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (tuples[j][1] > tuples[j + 1][1]) {
int temp0 = tuples[j][0], temp1 = tuples[j][1];
tuples[j][0] = tuples[j + 1][0];
tuples[j][... | int main() {
int t1[3][2] = {{1, 3}, {3, 2}, {2, 1}};
int r1[3][2] = {{2, 1}, {3, 2}, {1, 3}};
func0(t1, 3);
assert(memcmp(t1, r1, sizeof(t1)) == 0);
int t2[3][2] = {{2, 4}, {3, 3}, {1, 1}};
int r2[3][2] = {{1, 1}, {3, 3}, {2, 4}};
func0(t2, 3);
assert(memcmp(t2, r2, sizeof(t2)... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 12d6 <func0+0x14d>
movl $0x0,-0xc(%rbp)
jmpq 12c0 <func0+0x137>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov 0x4(%rax),%edx
mov -0xc(%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0
jmp loc_12D6
loc_11A4:
mov [rbp+var_C], 0
jmp loc_12C0
loc_11B0:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax+4]
mov ... | long long func0(long long a1, int a2)
{
long long result; // rax
unsigned int i; // [rsp+Ch] [rbp-10h]
int j; // [rsp+10h] [rbp-Ch]
int v5; // [rsp+14h] [rbp-8h]
int v6; // [rsp+18h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a2 )
break;
for ( j = 0; j < (int)(a2 - i - ... | 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
JMP 0x001012d6
LAB_001011a4:
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012c0
LAB_001011b0:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
M... | void func0(long param_1,int param_2)
{
int4 uVar1;
int4 uVar2;
int4 local_18;
int4 local_14;
for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
for (local_14 = 0; local_14 < (param_2 - local_18) + -1; local_14 = local_14 + 1) {
if (*(int *)(param_1 + ((long)local_14 + 1) * 8 + 4) ... |
5,841 | func0 |
#include <assert.h>
#include <string.h>
| void func0(int tuples[][2], int n) {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (tuples[j][1] > tuples[j + 1][1]) {
int temp0 = tuples[j][0], temp1 = tuples[j][1];
tuples[j][0] = tuples[j + 1][0];
tuples[j][... | int main() {
int t1[3][2] = {{1, 3}, {3, 2}, {2, 1}};
int r1[3][2] = {{2, 1}, {3, 2}, {1, 3}};
func0(t1, 3);
assert(memcmp(t1, r1, sizeof(t1)) == 0);
int t2[3][2] = {{2, 4}, {3, 3}, {1, 1}};
int r2[3][2] = {{1, 1}, {3, 3}, {2, 4}};
func0(t2, 3);
assert(memcmp(t2, r2, sizeof(t2)... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11ce <func0+0x45>
lea -0x1(%rsi),%r10d
lea 0x8(%rdi),%r11
jmp 11d3 <func0+0x4a>
add $0x8,%rax
cmp %rsi,%rax
je 11cf <func0+0x46>
mov 0x4(%rax),%edx
mov 0xc(%rax),%ecx
cmp %ecx,%edx
jle 119b <func0+0x12>
mov (%rax),%r8d
mov 0x8(%rax),%r9d
mov ... | func0:
endbr64
test esi, esi
jle short locret_11CE
lea r10d, [rsi-1]
lea r11, [rdi+8]
jmp short loc_11D3
loc_119B:
add rax, 8
cmp rax, rsi
jz short loc_11CF
loc_11A4:
mov edx, [rax+4]
mov ecx, [rax+0Ch]
cmp edx, ecx
jle short loc_119B
mov r8d, [rax]
mov r9d, [rax+... | void func0(int *a1, int a2)
{
int v2; // r10d
int *v3; // rax
int v4; // edx
int v5; // ecx
int v6; // r8d
if ( a2 > 0 )
{
v2 = a2 - 1;
do
{
while ( v2 > 0 )
{
v3 = a1;
do
{
v4 = v3[1];
v5 = v3[3];
if ( v4 > v5 )
{
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011ce
LEA R10D,[RSI + -0x1]
LEA R11,[RDI + 0x8]
JMP 0x001011d3
LAB_0010119b:
ADD RAX,0x8
CMP RAX,RSI
JZ 0x001011cf
LAB_001011a4:
MOV EDX,dword ptr [RAX + 0x4]
MOV ECX,dword ptr [RAX + 0xc]
CMP EDX,ECX
JLE 0x0010119b
MOV R8D,dword ptr [RAX]
MOV R9D,dword ptr [RAX + 0x8]
MOV dword ptr... | void func0(int4 *param_1,int param_2)
{
int iVar1;
int4 uVar2;
int4 *puVar3;
if (0 < param_2) {
param_2 = param_2 + -1;
do {
for (; 0 < param_2; param_2 = param_2 + -1) {
puVar3 = param_1;
do {
iVar1 = puVar3[1];
if ((int)puVar3[3] < iVar1) {
uVa... |
5,842 | func0 |
#include <assert.h>
#include <string.h>
| void func0(int tuples[][2], int n) {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (tuples[j][1] > tuples[j + 1][1]) {
int temp0 = tuples[j][0], temp1 = tuples[j][1];
tuples[j][0] = tuples[j + 1][0];
tuples[j][... | int main() {
int t1[3][2] = {{1, 3}, {3, 2}, {2, 1}};
int r1[3][2] = {{2, 1}, {3, 2}, {1, 3}};
func0(t1, 3);
assert(memcmp(t1, r1, sizeof(t1)) == 0);
int t2[3][2] = {{2, 4}, {3, 3}, {1, 1}};
int r2[3][2] = {{1, 1}, {3, 3}, {2, 4}};
func0(t2, 3);
assert(memcmp(t2, r2, sizeof(t2)... | O2 | c | func0:
endbr64
test %esi,%esi
jle 13d7 <func0+0x57>
lea -0x1(%rsi),%edx
lea 0x8(%rdi),%r11
test %edx,%edx
je 13d6 <func0+0x56>
nopl 0x0(%rax,%rax,1)
sub $0x1,%edx
mov %rdi,%rax
mov %rdx,%r10
lea (%r11,%rdx,8),%rsi
nopl (%rax)
mov 0x4(%rax),%edx
mov 0xc(%rax),%ecx
cmp %ecx,%edx
... | func0:
endbr64
test esi, esi
jle short locret_13D7
lea edx, [rsi-1]
lea r11, [rdi+8]
test edx, edx
jz short locret_13D6
nop dword ptr [rax+rax+00h]
loc_1398:
sub edx, 1
mov rax, rdi
mov r10, rdx
lea rsi, [r11+rdx*8]
nop dword ptr [rax]
loc_13A8:
mov edx, [rax+4]
mov ... | void func0(int *a1, int a2)
{
int v2; // edx
int *v3; // rax
int v4; // r10d
long long v5; // rsi
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
if ( a2 > 0 )
{
v2 = a2 - 1;
if ( a2 != 1 )
{
do
{
v3 = a1;
v4 = v2 - 1;
v5 = (long long)&a1... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013d7
LEA EDX,[RSI + -0x1]
LEA R11,[RDI + 0x8]
TEST EDX,EDX
JZ 0x001013d6
NOP dword ptr [RAX + RAX*0x1]
LAB_00101398:
SUB EDX,0x1
MOV RAX,RDI
MOV R10,RDX
LEA RSI,[R11 + RDX*0x8]
NOP dword ptr [RAX]
LAB_001013a8:
MOV EDX,dword ptr [RAX + 0x4]
MOV ECX,dword ptr [RAX + 0xc]
CMP EDX,ECX... | void func0(int4 *param_1,int param_2)
{
int iVar1;
int4 uVar2;
int4 *puVar3;
uint uVar4;
ulong uVar5;
if (param_2 < 1) {
return;
}
uVar4 = param_2 - 1;
uVar5 = (ulong)uVar4;
while (uVar4 != 0) {
uVar4 = (int)uVar5 - 1;
uVar5 = (ulong)uVar4;
puVar3 = param_1;
do {
iVar1 ... |
5,843 | func0 |
#include <assert.h>
#include <string.h>
| void func0(int tuples[][2], int n) {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n - i - 1; j++) {
if (tuples[j][1] > tuples[j + 1][1]) {
int temp0 = tuples[j][0], temp1 = tuples[j][1];
tuples[j][0] = tuples[j + 1][0];
tuples[j][... | int main() {
int t1[3][2] = {{1, 3}, {3, 2}, {2, 1}};
int r1[3][2] = {{2, 1}, {3, 2}, {1, 3}};
func0(t1, 3);
assert(memcmp(t1, r1, sizeof(t1)) == 0);
int t2[3][2] = {{2, 4}, {3, 3}, {1, 1}};
int r2[3][2] = {{1, 1}, {3, 3}, {2, 4}};
func0(t2, 3);
assert(memcmp(t2, r2, sizeof(t2)... | O3 | c | func0:
endbr64
test %esi,%esi
jle 13c7 <func0+0x57>
lea -0x1(%rsi),%edx
lea 0x8(%rdi),%r11
test %edx,%edx
je 13c6 <func0+0x56>
nopl 0x0(%rax,%rax,1)
sub $0x1,%edx
mov %rdi,%rax
mov %rdx,%r10
lea (%r11,%rdx,8),%rsi
nopl (%rax)
mov 0x4(%rax),%edx
mov 0xc(%rax),%ecx
cmp %ecx,%edx
... | func0:
endbr64
test esi, esi
jle short locret_13C8
lea r9, [rdi+8]
loc_136C:
cmp esi, 1
jle short loc_13C3
nop dword ptr [rax+00000000h]
loc_1378:
lea edx, [rsi-2]
mov rax, rdi
lea r8, [r9+rdx*8]
nop word ptr [rax+rax+00h]
loc_1388:
mov ecx, [rax+4]
mov edx, [rax+0Ch]
cmp ... | void func0(unsigned int *a1, int a2)
{
unsigned int *v2; // rax
signed int v3; // ecx
signed int v4; // edx
if ( a2 > 0 )
{
do
{
for ( ; a2 > 1; --a2 )
{
v2 = a1;
do
{
v3 = v2[1];
v4 = v2[3];
if ( v3 > v4 )
*(__m128i *)v2 ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013c8
LEA R9,[RDI + 0x8]
LAB_0010136c:
CMP ESI,0x1
JLE 0x001013c3
NOP dword ptr [RAX]
LAB_00101378:
LEA EDX,[RSI + -0x2]
MOV RAX,RDI
LEA R8,[R9 + RDX*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101388:
MOV ECX,dword ptr [RAX + 0x4]
MOV EDX,dword ptr [RAX + 0xc]
CMP ECX,EDX
JLE 0x001013b... | void func0(int8 *param_1,int param_2)
{
int4 uVar1;
int8 *puVar2;
if (0 < param_2) {
do {
for (; 1 < param_2; param_2 = param_2 + -1) {
puVar2 = param_1;
do {
if (*(int *)((long)puVar2 + 0xc) < *(int *)((long)puVar2 + 4)) {
uVar1 = *(int4 *)puVar2;
*... |
5,844 | func0 | #include <math.h>
#include <assert.h>
| double func0(double a) {
double area = (sqrt(5 * (5 + 2 * sqrt(5))) * pow(a, 2)) / 4.0;
return area;
}
| int main() {
assert(func0(5) == 43.01193501472417);
assert(func0(10) == 172.0477400588967);
assert(func0(15) == 387.10741513251753);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
movsd %xmm0,-0x18(%rbp)
movsd 0xf2e(%rip),%xmm0
mov -0x18(%rbp),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xf1c(%rip),%xmm1
mulsd %xmm1,%xmm0
movsd 0xf18(%rip),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
movsd [rbp+x], xmm0
movsd xmm0, cs:y
mov rax, [rbp+x]
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movsd xmm1, cs:qword_2098
mulsd xmm0, xmm1
movsd xmm1, cs:qword_20A0
divsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+va... | double func0(double a1)
{
return pow(a1, 2.0) * 6.881909602355868 / 4.0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM0,qword ptr [0x00102090]
MOV RAX,qword ptr [RBP + -0x18]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
MOVSD XMM1,qword ptr [0x00102098]
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x001020a0]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + ... | double func0(double param_1)
{
double dVar1;
dVar1 = pow(param_1,DAT_00102090);
return (dVar1 * DAT_00102098) / DAT_001020a0;
} |
5,845 | func0 | #include <math.h>
#include <assert.h>
| double func0(double a) {
double area = (sqrt(5 * (5 + 2 * sqrt(5))) * pow(a, 2)) / 4.0;
return area;
}
| int main() {
assert(func0(5) == 43.01193501472417);
assert(func0(10) == 172.0477400588967);
assert(func0(15) == 387.10741513251753);
return 0;
}
| O1 | c | func0:
endbr64
mulsd %xmm0,%xmm0
mulsd 0xecf(%rip),%xmm0
mulsd 0xecf(%rip),%xmm0
retq
| func0:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
mulsd xmm0, cs:qword_2010
retn | double func0(double a1)
{
return a1 * a1 * 6.881909602355868 * 0.25;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,qword ptr [0x00102010]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * param_1 * _DAT_00102008 * _DAT_00102010;
} |
5,846 | func0 | #include <math.h>
#include <assert.h>
| double func0(double a) {
double area = (sqrt(5 * (5 + 2 * sqrt(5))) * pow(a, 2)) / 4.0;
return area;
}
| int main() {
assert(func0(5) == 43.01193501472417);
assert(func0(10) == 172.0477400588967);
assert(func0(15) == 387.10741513251753);
return 0;
}
| O2 | c | func0:
endbr64
mulsd %xmm0,%xmm0
mulsd 0xeb8(%rip),%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopl 0x0(%rax)
| func0:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
mulsd xmm0, cs:qword_2010
retn | double func0(double a1)
{
return a1 * a1 * 6.881909602355868 * 0.25;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,qword ptr [0x00102010]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * param_1 * _DAT_00102008 * _DAT_00102010;
} |
5,847 | func0 | #include <math.h>
#include <assert.h>
| double func0(double a) {
double area = (sqrt(5 * (5 + 2 * sqrt(5))) * pow(a, 2)) / 4.0;
return area;
}
| int main() {
assert(func0(5) == 43.01193501472417);
assert(func0(10) == 172.0477400588967);
assert(func0(15) == 387.10741513251753);
return 0;
}
| O3 | c | func0:
endbr64
mulsd %xmm0,%xmm0
mulsd 0xeb8(%rip),%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopl 0x0(%rax)
| func0:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
mulsd xmm0, cs:qword_2010
retn | double func0(double a1)
{
return a1 * a1 * 6.881909602355868 * 0.25;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,qword ptr [0x00102010]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * param_1 * _DAT_00102008 * _DAT_00102010;
} |
5,848 | func0 | #include <assert.h>
| int func0(int n, int arr[]) {
int mn = arr[0];
int freq = 1;
for (int i = 1; i < n; i++) {
if (arr[i] > mn) {
mn = arr[i];
freq = 1;
} else if (arr[i] == mn) {
freq += 1;
}
}
return freq;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 4};
int arr2[] = {5, 6, 5};
int arr3[] = {2, 7, 7, 7};
assert(func0(5, arr1) == 2);
assert(func0(3, arr2) == 1);
assert(func0(4, arr3) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x20(%rbp),%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11f1 <func0+0x88>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%r... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_20], rsi
mov rax, [rbp+var_20]
mov eax, [rax]
mov [rbp+var_C], eax
mov [rbp+var_8], 1
mov [rbp+var_4], 1
jmp short loc_11F1
loc_1191:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+va... | long long func0(int a1, int *a2)
{
int v3; // [rsp+14h] [rbp-Ch]
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v3 = *a2;
v4 = 1;
for ( i = 1; i < a1; ++i )
{
if ( v3 >= a2[i] )
{
if ( v3 == a2[i] )
++v4;
}
else
{
v3 = a2[i];
v4 = 1;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011f1
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RD... | int func0(int param_1,int *param_2)
{
int local_14;
int local_10;
int local_c;
local_14 = *param_2;
local_10 = 1;
for (local_c = 1; local_c < param_1; local_c = local_c + 1) {
if (local_14 < param_2[local_c]) {
local_14 = param_2[local_c];
local_10 = 1;
}
else if (local_14 == par... |
5,849 | func0 | #include <assert.h>
| int func0(int n, int arr[]) {
int mn = arr[0];
int freq = 1;
for (int i = 1; i < n; i++) {
if (arr[i] > mn) {
mn = arr[i];
freq = 1;
} else if (arr[i] == mn) {
freq += 1;
}
}
return freq;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 4};
int arr2[] = {5, 6, 5};
int arr3[] = {2, 7, 7, 7};
assert(func0(5, arr1) == 2);
assert(func0(3, arr2) == 1);
assert(func0(4, arr3) == 3);
return 0;
}
| O1 | c | func0:
endbr64
mov (%rsi),%ecx
cmp $0x1,%edi
jle 11a7 <func0+0x3e>
lea 0x4(%rsi),%rax
lea -0x2(%rdi),%edx
lea 0x8(%rsi,%rdx,4),%rdi
mov $0x1,%esi
jmp 1197 <func0+0x2e>
mov %edx,%ecx
mov $0x1,%esi
add $0x4,%rax
cmp %rdi,%rax
je 11ac <func0+0x43>
mov (%rax),%edx
cmp %ecx,%edx... | func0:
endbr64
mov ecx, [rsi]
cmp edi, 1
jle short loc_11A7
lea rax, [rsi+4]
lea edx, [rdi-2]
lea rdi, [rsi+rdx*4+8]
mov esi, 1
jmp short loc_1197
loc_1187:
mov ecx, edx
mov esi, 1
loc_118E:
add rax, 4
cmp rax, rdi
jz short loc_11AC
loc_1197:
mov edx, [rax]
cmp ... | long long func0(int a1, int *a2)
{
int v2; // ecx
int *v3; // rax
long long v4; // rdi
unsigned int v5; // esi
v2 = *a2;
if ( a1 <= 1 )
{
return 1;
}
else
{
v3 = a2 + 1;
v4 = (long long)&a2[a1 - 2 + 2];
v5 = 1;
do
{
if ( *v3 > v2 )
{
v2 = *v3;
v5... | func0:
ENDBR64
MOV ECX,dword ptr [RSI]
CMP EDI,0x1
JLE 0x001011a7
LEA RAX,[RSI + 0x4]
LEA EDX,[RDI + -0x2]
LEA RDI,[RSI + RDX*0x4 + 0x8]
MOV ESI,0x1
JMP 0x00101197
LAB_00101187:
MOV ECX,EDX
MOV ESI,0x1
LAB_0010118e:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x001011ac
LAB_00101197:
MOV EDX,dword ptr [RAX]
CMP EDX,ECX
JG 0x00101187
SE... | int func0(int param_1,int *param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
iVar3 = *param_2;
if (param_1 < 2) {
iVar4 = 1;
}
else {
piVar2 = param_2 + 1;
iVar4 = 1;
do {
iVar1 = *piVar2;
if (iVar1 == iVar3 || iVar1 < iVar3) {
iVar4 = iVar4 + (uint)(iVar1 ... |
5,850 | func0 | #include <assert.h>
| int func0(int n, int arr[]) {
int mn = arr[0];
int freq = 1;
for (int i = 1; i < n; i++) {
if (arr[i] > mn) {
mn = arr[i];
freq = 1;
} else if (arr[i] == mn) {
freq += 1;
}
}
return freq;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 4};
int arr2[] = {5, 6, 5};
int arr3[] = {2, 7, 7, 7};
assert(func0(5, arr1) == 2);
assert(func0(3, arr2) == 1);
assert(func0(4, arr3) == 3);
return 0;
}
| O2 | c | func0:
endbr64
mov (%rsi),%ecx
cmp $0x1,%edi
jle 1280 <func0+0x50>
lea -0x2(%rdi),%edx
lea 0x4(%rsi),%rax
mov $0x1,%r8d
lea 0x8(%rsi,%rdx,4),%rsi
jmp 1262 <func0+0x32>
sete %dl
add $0x4,%rax
movzbl %dl,%edx
add %edx,%r8d
cmp %rsi,%rax
je 1279 <func0+0x49>
mov (%rax),%edx
cmp ... | func0:
endbr64
mov ecx, [rsi]
cmp edi, 1
jle short loc_12E0
lea edx, [rdi-2]
lea rax, [rsi+4]
mov r8d, 1
lea rsi, [rsi+rdx*4+8]
jmp short loc_12C2
loc_12B0:
setz dl
add rax, 4
movzx edx, dl
add r8d, edx
cmp rax, rsi
jz short loc_12D9
loc_12C2:
mov edx, [rax]
cmp... | long long func0(int a1, int *a2)
{
int v2; // ecx
int *v3; // rax
unsigned int v4; // r8d
long long v5; // rsi
int v6; // edx
bool v7; // zf
v2 = *a2;
if ( a1 <= 1 )
return 1LL;
v3 = a2 + 1;
v4 = 1;
v5 = (long long)&a2[a1 - 2 + 2];
do
{
while ( 1 )
{
v6 = *v3;
v7 = *v... | func0:
ENDBR64
MOV ECX,dword ptr [RSI]
CMP EDI,0x1
JLE 0x001012e0
LEA EDX,[RDI + -0x2]
LEA RAX,[RSI + 0x4]
MOV R8D,0x1
LEA RSI,[RSI + RDX*0x4 + 0x8]
JMP 0x001012c2
LAB_001012b0:
SETZ DL
ADD RAX,0x4
MOVZX EDX,DL
ADD R8D,EDX
CMP RAX,RSI
JZ 0x001012d9
LAB_001012c2:
MOV EDX,dword ptr [RAX]
CMP EDX,ECX
JLE 0x001012b0
ADD RA... | int func0(int param_1,int *param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
if (param_1 < 2) {
return 1;
}
piVar2 = param_2 + 1;
iVar4 = 1;
iVar3 = *param_2;
do {
while( true ) {
iVar1 = *piVar2;
if (iVar3 < iVar1) break;
piVar2 = piVar2 + 1;
iVar4 = iVar4... |
5,851 | func0 | #include <assert.h>
| int func0(int n, int arr[]) {
int mn = arr[0];
int freq = 1;
for (int i = 1; i < n; i++) {
if (arr[i] > mn) {
mn = arr[i];
freq = 1;
} else if (arr[i] == mn) {
freq += 1;
}
}
return freq;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 4};
int arr2[] = {5, 6, 5};
int arr3[] = {2, 7, 7, 7};
assert(func0(5, arr1) == 2);
assert(func0(3, arr2) == 1);
assert(func0(4, arr3) == 3);
return 0;
}
| O3 | c | func0:
endbr64
mov (%rsi),%ecx
cmp $0x1,%edi
jle 1290 <func0+0x50>
lea -0x2(%rdi),%edx
lea 0x4(%rsi),%rax
mov $0x1,%r8d
lea 0x8(%rsi,%rdx,4),%rsi
jmp 1272 <func0+0x32>
sete %dl
add $0x4,%rax
movzbl %dl,%edx
add %edx,%r8d
cmp %rax,%rsi
je 1289 <func0+0x49>
mov (%rax),%edx
cmp ... | func0:
endbr64
mov r8d, [rsi]
cmp edi, 1
jle short loc_1190
lea edx, [rdi-2]
lea rax, [rsi+4]
mov ecx, 1
lea rsi, [rsi+rdx*4+8]
jmp short loc_1171
loc_1160:
setz dl
add rax, 4
movzx edx, dl
add ecx, edx
cmp rsi, rax
jz short loc_1189
loc_1171:
mov edx, [rax]
cmp... | long long func0(int a1, int *a2)
{
int v2; // r8d
int *v3; // rax
unsigned int v4; // ecx
long long v5; // rsi
int v6; // edx
bool v7; // zf
v2 = *a2;
if ( a1 <= 1 )
return 1LL;
v3 = a2 + 1;
v4 = 1;
v5 = (long long)&a2[a1 - 2 + 2];
do
{
while ( 1 )
{
v6 = *v3;
v7 = v2... | func0:
ENDBR64
MOV R8D,dword ptr [RSI]
CMP EDI,0x1
JLE 0x00101190
LEA EDX,[RDI + -0x2]
LEA RAX,[RSI + 0x4]
MOV ECX,0x1
LEA RSI,[RSI + RDX*0x4 + 0x8]
JMP 0x00101171
LAB_00101160:
SETZ DL
ADD RAX,0x4
MOVZX EDX,DL
ADD ECX,EDX
CMP RSI,RAX
JZ 0x00101189
LAB_00101171:
MOV EDX,dword ptr [RAX]
CMP R8D,EDX
JGE 0x00101160
ADD RA... | int func0(int param_1,int *param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
if (param_1 < 2) {
return 1;
}
piVar2 = param_2 + 1;
iVar3 = 1;
iVar4 = *param_2;
do {
while( true ) {
iVar1 = *piVar2;
if (iVar4 < iVar1) break;
piVar2 = piVar2 + 1;
iVar3 = iVar3... |
5,852 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct Pair {
int first;
int second;
} Pair;
int pair_comparator(const void *v1, const void *v2) {
const Pair *p1 = (const Pair *)v1;
const Pair *p2 = (const Pair *)v2;
if (p1->first != p2->first)
... | Pair* func0(Pair test_list[], size_t size, size_t *result_size) {
Pair *res = malloc(size * sizeof(Pair));
if (!res) return NULL; // memory allocation check
int res_count = 0;
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
if (test_list[i].first == test_lis... | int main() {
Pair test1[] = {{6, 7}, {2, 3}, {7, 6}, {9, 8}, {10, 2}, {8, 9}};
Pair result1_exp[] = {{6, 7}, {8, 9}};
size_t res1_size;
Pair *result1 = func0(test1, 6, &res1_size);
qsort(result1, res1_size, sizeof(Pair), pair_comparator);
assert(res1_size == 2 && memcmp(result1, result1_ex... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %rdx,-0x38(%rbp)
mov -0x30(%rbp),%rax
shl $0x3,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
jne 127c <func0+0x3d>
mov $0x0,%eax
jmpq 139e <fu... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov rax, [rbp+var_30]
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jnz short loc_127C
mov eax, 0
jmp locret_... | _QWORD * func0(long long a1, unsigned long long a2, _QWORD *a3)
{
int v4; // eax
int v6; // [rsp+2Ch] [rbp-14h]
int i; // [rsp+30h] [rbp-10h]
int j; // [rsp+34h] [rbp-Ch]
_QWORD *v9; // [rsp+38h] [rbp-8h]
v9 = malloc(8 * a2);
if ( !v9 )
return 0LL;
v6 = 0;
for ( i = 0; i < a2; ++i )
{
for (... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV RAX,qword ptr [RBP + -0x30]
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0010127c
MOV EAX,0x0
JMP 0x0010139e... | void * func0(long param_1,ulong param_2,long *param_3)
{
void *pvVar1;
int4 local_1c;
int4 local_18;
int4 local_14;
pvVar1 = malloc(param_2 << 3);
if (pvVar1 == (void *)0x0) {
pvVar1 = (void *)0x0;
}
else {
local_1c = 0;
for (local_18 = 0; (ulong)(long)local_18 < param_2; local_18 = loca... |
5,853 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct Pair {
int first;
int second;
} Pair;
int pair_comparator(const void *v1, const void *v2) {
const Pair *p1 = (const Pair *)v1;
const Pair *p2 = (const Pair *)v2;
if (p1->first != p2->first)
... | Pair* func0(Pair test_list[], size_t size, size_t *result_size) {
Pair *res = malloc(size * sizeof(Pair));
if (!res) return NULL; // memory allocation check
int res_count = 0;
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
if (test_list[i].first == test_lis... | int main() {
Pair test1[] = {{6, 7}, {2, 3}, {7, 6}, {9, 8}, {10, 2}, {8, 9}};
Pair result1_exp[] = {{6, 7}, {8, 9}};
size_t res1_size;
Pair *result1 = func0(test1, 6, &res1_size);
qsort(result1, res1_size, sizeof(Pair), pair_comparator);
assert(res1_size == 2 && memcmp(result1, result1_ex... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %rsi,%r13
mov %rdx,%rbp
lea 0x0(,%rsi,8),%r12
mov %r12,%rdi
callq 10f0 <malloc@plt>
test %rax,%rax
je 128b <func0+0x8c>
test %r13,%r13
je 127e <func0+0x7f>
mov %rbx,%r11
lea (%rbx,%r12,1),... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov r13, rsi
mov rbp, rdx
lea r12, ds:0[rsi*8]
mov rdi, r12
call _malloc
test rax, rax
jz short loc_1288
test r13, r13
jz short loc_127B
lea rdi, [rbx+r12]
mov rcx, rbx
mov r10d,... | long long func0(_DWORD *a1, long long a2, _QWORD *a3)
{
long long result; // rax
_DWORD *v6; // rdi
_DWORD *v7; // rcx
int v8; // r10d
_DWORD *v9; // rdx
int v10; // r9d
result = malloc(8 * a2);
if ( result )
{
if ( a2 )
{
v6 = &a1[2 * a2];
v7 = a1;
v8 = 0;
do
{... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV R13,RSI
MOV RBP,RDX
LEA R12,[RSI*0x8]
MOV RDI,R12
CALL 0x001010f0
TEST RAX,RAX
JZ 0x00101288
TEST R13,R13
JZ 0x0010127b
LEA RDI,[RBX + R12*0x1]
MOV RCX,RBX
MOV R10D,0x0
JMP 0x00101276
LAB_0010123f:
ADD RDX,0x8
CMP RDI,RDX
JZ 0x0010126d
LAB_0... | void func0(int *param_1,long param_2,long *param_3)
{
void *pvVar1;
int *piVar2;
int *piVar3;
int iVar4;
pvVar1 = malloc(param_2 * 8);
if (pvVar1 != (void *)0x0) {
if (param_2 == 0) {
iVar4 = 0;
}
else {
iVar4 = 0;
piVar3 = param_1;
piVar2 = param_1;
do {
... |
5,854 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct Pair {
int first;
int second;
} Pair;
int pair_comparator(const void *v1, const void *v2) {
const Pair *p1 = (const Pair *)v1;
const Pair *p2 = (const Pair *)v2;
if (p1->first != p2->first)
... | Pair* func0(Pair test_list[], size_t size, size_t *result_size) {
Pair *res = malloc(size * sizeof(Pair));
if (!res) return NULL; // memory allocation check
int res_count = 0;
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
if (test_list[i].first == test_lis... | int main() {
Pair test1[] = {{6, 7}, {2, 3}, {7, 6}, {9, 8}, {10, 2}, {8, 9}};
Pair result1_exp[] = {{6, 7}, {8, 9}};
size_t res1_size;
Pair *result1 = func0(test1, 6, &res1_size);
qsort(result1, res1_size, sizeof(Pair), pair_comparator);
assert(res1_size == 2 && memcmp(result1, result1_ex... | O2 | c | func0:
endbr64
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
lea 0x0(,%rsi,8),%rbx
mov %rbx,%rdi
sub $0x8,%rsp
callq 10d0 <malloc@plt>
test %rax,%rax
je 158d <func0+0x9d>
test %rbp,%rbp
je 1589 <func0+0x99>
lea (%r12,%rbx,1),%r9
mov %r12,%... | func0:
endbr64
push r13
mov r13, rsi
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
lea rbx, ds:0[rsi*8]
mov rdi, rbx
sub rsp, 8
call _malloc
test rax, rax
jz short loc_1578
lea rdi, [rbp+rbx+0]
mov r8, rbp
xor r9d, r9d
test r13, r13
jz short loc_... | long long func0(int *a1, long long a2, _QWORD *a3)
{
long long v3; // r13
long long result; // rax
int *v7; // rdi
int *v8; // r8
int v9; // r9d
int v10; // ecx
int *v11; // rdx
int v12; // esi
long long v13; // rsi
v3 = a2;
result = malloc(8 * a2);
if ( result )
{
v7 = &a1[2 * a2];
... | func0:
ENDBR64
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
LEA RBX,[RSI*0x8]
MOV RDI,RBX
SUB RSP,0x8
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00101578
LEA RDI,[RBP + RBX*0x1]
MOV R8,RBP
XOR R9D,R9D
TEST R13,R13
JZ 0x00101574
NOP dword ptr [RAX]
LAB_00101520:
MOV ECX,dword ptr [R8]
MOV RDX,RBP
JMP 0... | void func0(int *param_1,long param_2,long *param_3)
{
int iVar1;
int *piVar2;
void *pvVar3;
int *piVar4;
long lVar5;
int *piVar6;
int iVar7;
pvVar3 = malloc(param_2 * 8);
if (pvVar3 != (void *)0x0) {
iVar7 = 0;
piVar6 = param_1;
if (param_2 != 0) {
do {
iVar1 = *piVar6;
... |
5,855 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct Pair {
int first;
int second;
} Pair;
int pair_comparator(const void *v1, const void *v2) {
const Pair *p1 = (const Pair *)v1;
const Pair *p2 = (const Pair *)v2;
if (p1->first != p2->first)
... | Pair* func0(Pair test_list[], size_t size, size_t *result_size) {
Pair *res = malloc(size * sizeof(Pair));
if (!res) return NULL; // memory allocation check
int res_count = 0;
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
if (test_list[i].first == test_lis... | int main() {
Pair test1[] = {{6, 7}, {2, 3}, {7, 6}, {9, 8}, {10, 2}, {8, 9}};
Pair result1_exp[] = {{6, 7}, {8, 9}};
size_t res1_size;
Pair *result1 = func0(test1, 6, &res1_size);
qsort(result1, res1_size, sizeof(Pair), pair_comparator);
assert(res1_size == 2 && memcmp(result1, result1_ex... | O3 | c | func0:
endbr64
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
lea 0x0(,%rsi,8),%rbx
mov %rbx,%rdi
sub $0x8,%rsp
callq 10d0 <malloc@plt>
test %rax,%rax
je 14ed <func0+0x9d>
test %rbp,%rbp
je 14e9 <func0+0x99>
lea (%r12,%rbx,1),%r9
mov %r12,%... | func0:
endbr64
push r13
mov r13, rsi
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
lea rbx, ds:0[rsi*8]
mov rdi, rbx; size
sub rsp, 8
call _malloc
test rax, rax
jz short loc_14E8
lea rdi, [rbp+rbx+0]
mov r8, rbp
xor r9d, r9d
test r13, r13
jz shor... | _QWORD * func0(int *a1, long long a2, _QWORD *a3)
{
long long v3; // r13
_QWORD *result; // rax
int *v7; // rdi
int *v8; // r8
int v9; // r9d
int v10; // ecx
int *v11; // rdx
int v12; // esi
long long v13; // rsi
v3 = a2;
result = malloc(8 * a2);
if ( result )
{
v7 = &a1[2 * a2];
v8 =... | func0:
ENDBR64
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
LEA RBX,[RSI*0x8]
MOV RDI,RBX
SUB RSP,0x8
CALL 0x001010d0
TEST RAX,RAX
JZ 0x001014e8
LEA RDI,[RBP + RBX*0x1]
MOV R8,RBP
XOR R9D,R9D
TEST R13,R13
JZ 0x001014e4
NOP dword ptr [RAX]
LAB_00101490:
MOV ECX,dword ptr [R8]
MOV RDX,RBP
JMP 0... | void func0(int *param_1,long param_2,long *param_3)
{
int iVar1;
int *piVar2;
void *pvVar3;
int *piVar4;
long lVar5;
int *piVar6;
int iVar7;
pvVar3 = malloc(param_2 * 8);
if (pvVar3 != (void *)0x0) {
iVar7 = 0;
piVar6 = param_1;
if (param_2 != 0) {
do {
iVar1 = *piVar6;
... |
5,856 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, int n, double r) {
double total = (a * (1 - pow(r, n))) / (1 - r);
return total;
}
| int main() {
assert(func0(1,5,2)==31);
assert(func0(1,5,4)==341);
assert(func0(2,6,3)==728);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
movsd %xmm0,-0x18(%rbp)
mov %edi,-0x1c(%rbp)
movsd %xmm1,-0x28(%rbp)
cvtsi2sdl -0x1c(%rbp),%xmm0
mov -0x28(%rbp),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xedf(%rip),%xmm1
subsd %xmm0,%xmm1
movapd %xmm1,%xmm0
mulsd -0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
movsd [rbp+var_18], xmm0
mov [rbp+var_1C], edi
movsd [rbp+x], xmm1
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_1C]
mov rax, [rbp+x]
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movapd xmm1, xmm0
movsd xmm0, cs:qword_2060
subsd xmm0,... | double func0(int a1, double a2, double a3)
{
return (1.0 - pow(a3, (double)a1)) * a2 / (1.0 - a3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOVSD qword ptr [RBP + -0x18],XMM0
MOV dword ptr [RBP + -0x1c],EDI
MOVSD qword ptr [RBP + -0x28],XMM1
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x28]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr... | double func0(double param_1,double param_2,int param_3)
{
double dVar1;
dVar1 = pow(param_2,(double)param_3);
return ((DAT_00102060 - dVar1) * param_1) / (DAT_00102060 - param_2);
} |
5,857 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, int n, double r) {
double total = (a * (1 - pow(r, n))) / (1 - r);
return total;
}
| int main() {
assert(func0(1,5,2)==31);
assert(func0(1,5,4)==341);
assert(func0(2,6,3)==728);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x18,%rsp
movsd %xmm0,(%rsp)
movapd %xmm1,%xmm3
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
movsd %xmm3,0x8(%rsp)
movapd %xmm3,%xmm0
callq 1060 <pow@plt>
movsd 0xee7(%rip),%xmm1
movapd %xmm1,%xmm2
subsd %xmm0,%xmm2
movapd %xmm2,%xmm0
mulsd (%rsp),%xmm0
subsd 0x8(%rsp),%xmm1
divsd %xmm1,%xmm0
a... | func0:
endbr64
push r14
push rbx
sub rsp, 8
movq r14, xmm0
movq rbx, xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
movq xmm0, rbx
call _pow
movapd xmm2, xmm0
movsd xmm1, cs:qword_2060
movapd xmm0, xmm1
subsd xmm0, xmm2
movq xmm3, r14
mulsd xmm0, xmm3
movq xmm4, rbx
subsd xmm1, xmm4
di... | double func0(int a1, double a2, double a3)
{
return (1.0 - pow(a3, (double)a1)) * a2 / (1.0 - a3);
} | func0:
ENDBR64
PUSH R14
PUSH RBX
SUB RSP,0x8
MOVQ R14,XMM0
MOVQ RBX,XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MOVQ XMM0,RBX
CALL 0x00101060
MOVAPD XMM2,XMM0
MOVSD XMM1,qword ptr [0x00102060]
MOVAPD XMM0,XMM1
SUBSD XMM0,XMM2
MOVQ XMM3,R14
MULSD XMM0,XMM3
MOVQ XMM4,RBX
SUBSD XMM1,XMM4
DIVSD XMM0,XMM1
ADD RSP,0x8
POP RBX
POP ... | double func0(double param_1,double param_2,int param_3)
{
double dVar1;
dVar1 = pow(param_2,(double)param_3);
return ((DAT_00102060 - dVar1) * param_1) / (DAT_00102060 - param_2);
} |
5,858 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, int n, double r) {
double total = (a * (1 - pow(r, n))) / (1 - r);
return total;
}
| int main() {
assert(func0(1,5,2)==31);
assert(func0(1,5,4)==341);
assert(func0(2,6,3)==728);
return 0;
}
| O2 | c | func0:
endbr64
movapd %xmm1,%xmm3
pxor %xmm1,%xmm1
sub $0x18,%rsp
cvtsi2sd %edi,%xmm1
movsd %xmm0,(%rsp)
movapd %xmm3,%xmm0
movsd %xmm3,0x8(%rsp)
callq 1050 <pow@plt>
movsd 0xe78(%rip),%xmm2
movsd 0x8(%rsp),%xmm3
movapd %xmm2,%xmm4
subsd %xmm3,%xmm2
subsd %xmm0,%xmm4
movsd (%rsp),%xmm0
add $0x18,%rsp
mu... | func0:
endbr64
movapd xmm3, xmm1
pxor xmm1, xmm1
sub rsp, 18h
cvtsi2sd xmm1, edi
movsd [rsp+18h+var_18], xmm0
movapd xmm0, xmm3
movsd [rsp+18h+var_10], xmm3
call _pow
movsd xmm2, cs:qword_2008
movsd xmm3, [rsp+18h+var_10]
movapd xmm4, xmm2
subsd xmm2, xmm3
subsd xmm4, xmm0
movsd xmm0, [rsp+18... | double func0(int a1, double a2, double a3)
{
return a2 * (1.0 - pow(a3, (double)a1)) / (1.0 - a3);
} | func0:
ENDBR64
MOVAPD XMM3,XMM1
PXOR XMM1,XMM1
SUB RSP,0x18
CVTSI2SD XMM1,EDI
MOVSD qword ptr [RSP],XMM0
MOVAPD XMM0,XMM3
MOVSD qword ptr [RSP + 0x8],XMM3
CALL 0x00101050
MOVSD XMM2,qword ptr [0x00102008]
MOVSD XMM3,qword ptr [RSP + 0x8]
MOVAPD XMM4,XMM2
SUBSD XMM2,XMM3
SUBSD XMM4,XMM0
MOVSD XMM0,qword ptr [RSP]
ADD RS... | double func0(double param_1,double param_2,int param_3)
{
double dVar1;
dVar1 = pow(param_2,(double)param_3);
return (param_1 * (DAT_00102008 - dVar1)) / (DAT_00102008 - param_2);
} |
5,859 | func0 |
#include <stdio.h>
#include <assert.h>
#include <math.h>
| double func0(double a, int n, double r) {
double total = (a * (1 - pow(r, n))) / (1 - r);
return total;
}
| int main() {
assert(func0(1,5,2)==31);
assert(func0(1,5,4)==341);
assert(func0(2,6,3)==728);
return 0;
}
| O3 | c | func0:
endbr64
movapd %xmm1,%xmm3
pxor %xmm1,%xmm1
sub $0x18,%rsp
cvtsi2sd %edi,%xmm1
movsd %xmm0,(%rsp)
movapd %xmm3,%xmm0
movsd %xmm3,0x8(%rsp)
callq 1050 <pow@plt>
movsd 0xe78(%rip),%xmm2
movsd 0x8(%rsp),%xmm3
movapd %xmm2,%xmm4
subsd %xmm3,%xmm2
subsd %xmm0,%xmm4
movsd (%rsp),%xmm0
add $0x18,%rsp
mu... | func0:
endbr64
movapd xmm3, xmm1
pxor xmm1, xmm1
sub rsp, 18h
cvtsi2sd xmm1, edi; y
movsd [rsp+18h+var_18], xmm0
movapd xmm0, xmm3; x
movsd [rsp+18h+var_10], xmm3
call _pow
movsd xmm2, cs:qword_2008
movsd xmm3, [rsp+18h+var_10]
movapd xmm4, xmm2
subsd xmm2, xmm3
subsd xmm4, xmm0
movsd xmm0, [... | double func0(int a1, double a2, double a3)
{
return a2 * (1.0 - pow(a3, (double)a1)) / (1.0 - a3);
} | func0:
ENDBR64
MOVAPD XMM3,XMM1
PXOR XMM1,XMM1
SUB RSP,0x18
CVTSI2SD XMM1,EDI
MOVSD qword ptr [RSP],XMM0
MOVAPD XMM0,XMM3
MOVSD qword ptr [RSP + 0x8],XMM3
CALL 0x00101050
MOVSD XMM2,qword ptr [0x00102008]
MOVSD XMM3,qword ptr [RSP + 0x8]
MOVAPD XMM4,XMM2
SUBSD XMM2,XMM3
SUBSD XMM4,XMM0
MOVSD XMM0,qword ptr [RSP]
ADD RS... | double func0(double param_1,double param_2,int param_3)
{
double dVar1;
dVar1 = pow(param_2,(double)param_3);
return (param_1 * (DAT_00102008 - dVar1)) / (DAT_00102008 - param_2);
} |
5,860 | func0 |
#include <assert.h>
| int func0(int item_list[], int size, int item) {
int first = 0;
int last = size - 1;
int found = 0;
while (first <= last && !found) {
int mid = (first + last) / 2;
if (item_list[mid] == item) {
found = 1;
} else {
if (item < item_list[mid]) {
... | int main() {
int list1[] = {1, 2, 3, 5, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
int list2[] = {7, 8, 9, 10, 13};
int size2 = sizeof(list2) / sizeof(list2[0]);
int list3[] = {11, 13, 14, 19, 22, 36};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list1, size1, 6... | 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 $0x0,-0x8(%rbp)
jmp 11fb <func0+0x92>
mov -0x10(%rbp),%edx
mov -0xc(%rbp),%eax
add %edx,%eax
mov ... | 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], 0
jmp short loc_11FB
loc_1194:
mov edx, [rbp+var_10]
mov eax, [rbp+var_C]
a... | 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 = 0;
while ( v4 <= v5 && !v6 )
{
v7 = (v4 + v5) / 2;
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],0x0
JMP 0x001011fb
LAB_00101194:
MOV EDX,dword ptr [RB... | 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 = 0;
while ((local_18 <= local_14 && (local_10 == 0))) {
iVar1 = (local_14 + local_18) / 2;
if (param_3 == *(int *)(param_1 + (long)iVar1 ... |
5,861 | func0 |
#include <assert.h>
| int func0(int item_list[], int size, int item) {
int first = 0;
int last = size - 1;
int found = 0;
while (first <= last && !found) {
int mid = (first + last) / 2;
if (item_list[mid] == item) {
found = 1;
} else {
if (item < item_list[mid]) {
... | int main() {
int list1[] = {1, 2, 3, 5, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
int list2[] = {7, 8, 9, 10, 13};
int size2 = sizeof(list2) / sizeof(list2[0]);
int list3[] = {11, 13, 14, 19, 22, 36};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list1, size1, 6... | O1 | c | func0:
endbr64
push %rbx
sub $0x1,%esi
mov $0x0,%r8d
mov $0x0,%ebx
mov $0x1,%r10d
lea (%r8,%rsi,1),%eax
mov %eax,%r11d
shr $0x1f,%r11d
add %eax,%r11d
sar %r11d
movslq %r11d,%rax
lea (%rdi,%rax,4),%r9
mov %ebx,%eax
cmp %esi,%r8d
jg 11bd <func0+0x54>
test %eax,%eax
jne 11bd ... | func0:
endbr64
push rbx
mov r11, rdi
sub esi, 1
mov edi, 0
mov ebx, 0
mov r9d, 1
loc_1184:
lea eax, [rdi+rsi]
mov r10d, eax
shr r10d, 1Fh
add r10d, eax
sar r10d, 1
movsxd rax, r10d
lea r8, [r11+rax*4]
mov eax, ebx
loc_119D:
cmp edi, esi
jg short loc_11BD
test... | long long func0(long long a1, int a2, int a3)
{
int v4; // esi
int v5; // edi
int v6; // r10d
long long result; // rax
int v8; // ecx
v4 = a2 - 1;
v5 = 0;
LABEL_2:
v6 = (v5 + v4) / 2;
result = 0LL;
while ( v5 <= v4 && !(_DWORD)result )
{
v8 = *(_DWORD *)(a1 + 4LL * v6);
result = 1LL;
... | func0:
ENDBR64
PUSH RBX
MOV R11,RDI
SUB ESI,0x1
MOV EDI,0x0
MOV EBX,0x0
MOV R9D,0x1
LAB_00101184:
LEA EAX,[RDI + RSI*0x1]
MOV R10D,EAX
SHR R10D,0x1f
ADD R10D,EAX
SAR R10D,0x1
MOVSXD RAX,R10D
LEA R8,[R11 + RAX*0x4]
MOV EAX,EBX
LAB_0010119d:
CMP EDI,ESI
JG 0x001011bd
TEST EAX,EAX
JNZ 0x001011bd
MOV ECX,dword ptr [R8]
MOV... | void func0(long param_1,int param_2,int param_3)
{
int iVar1;
bool bVar2;
int iVar3;
int iVar4;
param_2 = param_2 + -1;
iVar3 = 0;
do {
iVar4 = (iVar3 + param_2) / 2;
bVar2 = false;
do {
if ((param_2 < iVar3) || (bVar2)) {
return;
}
iVar1 = *(int *)(param_1 + (lon... |
5,862 | func0 |
#include <assert.h>
| int func0(int item_list[], int size, int item) {
int first = 0;
int last = size - 1;
int found = 0;
while (first <= last && !found) {
int mid = (first + last) / 2;
if (item_list[mid] == item) {
found = 1;
} else {
if (item < item_list[mid]) {
... | int main() {
int list1[] = {1, 2, 3, 5, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
int list2[] = {7, 8, 9, 10, 13};
int size2 = sizeof(list2) / sizeof(list2[0]);
int list3[] = {11, 13, 14, 19, 22, 36};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list1, size1, 6... | O2 | c | func0:
endbr64
lea -0x1(%rsi),%r9d
xor %r10d,%r10d
lea (%r10,%r9,1),%r8d
sar %r8d
cmp %r10d,%r9d
movslq %r8d,%rax
setge %cl
lea (%rdi,%rax,4),%rsi
xor %eax,%eax
nopl 0x0(%rax)
test %eax,%eax
jne 13b8 <func0+0x48>
test %cl,%cl
je 13b8 <func0+0x48>
mov $0x1,%eax
cmp %edx,(%rsi)
je... | func0:
endbr64
sub esi, 1
xor r10d, r10d
loc_12CA:
lea r9d, [rsi+r10]
sar r9d, 1
cmp r10d, esi
movsxd rax, r9d
setle cl
lea r8, [rdi+rax*4]
xor eax, eax
loc_12E0:
test eax, eax
jnz short locret_1300
test cl, cl
jz short locret_1300
mov eax, 1
cmp [r8], edx
jz s... | long long func0(long long a1, int a2, int a3)
{
int v3; // esi
int v4; // r10d
int v5; // r9d
_DWORD *v6; // r8
long long result; // rax
v3 = a2 - 1;
v4 = 0;
LABEL_2:
v5 = (v3 + v4) >> 1;
v6 = (_DWORD *)(a1 + 4LL * v5);
result = 0LL;
while ( !(_DWORD)result && v4 <= v3 )
{
result = 1LL;
... | func0:
ENDBR64
SUB ESI,0x1
XOR R10D,R10D
LAB_001012ca:
LEA R9D,[RSI + R10*0x1]
SAR R9D,0x1
CMP R10D,ESI
MOVSXD RAX,R9D
SETLE CL
LEA R8,[RDI + RAX*0x4]
XOR EAX,EAX
LAB_001012e0:
TEST EAX,EAX
JNZ 0x00101300
TEST CL,CL
JZ 0x00101300
MOV EAX,0x1
CMP dword ptr [R8],EDX
JZ 0x001012e0
JLE 0x00101308
LEA ESI,[R9 + -0x1]
JMP 0x... | void func0(long param_1,int param_2,int param_3)
{
int iVar1;
bool bVar2;
int iVar3;
int iVar4;
param_2 = param_2 + -1;
iVar4 = 0;
do {
iVar3 = param_2 + iVar4 >> 1;
bVar2 = false;
do {
if ((bVar2) || (param_2 < iVar4)) {
return;
}
bVar2 = true;
iVar1 = *(in... |
5,863 | func0 |
#include <assert.h>
| int func0(int item_list[], int size, int item) {
int first = 0;
int last = size - 1;
int found = 0;
while (first <= last && !found) {
int mid = (first + last) / 2;
if (item_list[mid] == item) {
found = 1;
} else {
if (item < item_list[mid]) {
... | int main() {
int list1[] = {1, 2, 3, 5, 8};
int size1 = sizeof(list1) / sizeof(list1[0]);
int list2[] = {7, 8, 9, 10, 13};
int size2 = sizeof(list2) / sizeof(list2[0]);
int list3[] = {11, 13, 14, 19, 22, 36};
int size3 = sizeof(list3) / sizeof(list3[0]);
assert(func0(list1, size1, 6... | O3 | c | func0:
endbr64
lea -0x1(%rsi),%r9d
xor %r10d,%r10d
lea (%r10,%r9,1),%r8d
sar %r8d
cmp %r10d,%r9d
movslq %r8d,%rax
setge %cl
lea (%rdi,%rax,4),%rsi
xor %eax,%eax
nopl 0x0(%rax)
test %eax,%eax
jne 1388 <func0+0x48>
test %cl,%cl
je 1388 <func0+0x48>
mov $0x1,%eax
cmp %edx,(%rsi)
je... | func0:
endbr64
sub esi, 1
xor r8d, r8d
loc_130A:
lea eax, [rsi+r8]
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
movsxd rax, ecx
lea rax, [rdi+rax*4]
cmp r8d, esi
jg short loc_1346
cmp [rax], edx
jnz short loc_1330
mov eax, 1
retn
loc_1330:
jle short loc_134... | long long func0(long long a1, int a2, int a3)
{
int v3; // esi
int v4; // r8d
int v5; // ecx
_DWORD *v6; // rax
v3 = a2 - 1;
v4 = 0;
while ( 1 )
{
v5 = (v3 + v4) / 2;
v6 = (_DWORD *)(a1 + 4LL * v5);
if ( v4 > v3 )
break;
if ( *v6 == a3 )
return 1LL;
if ( *v6 <= a3 )
... | func0:
ENDBR64
SUB ESI,0x1
XOR R8D,R8D
LAB_0010130a:
LEA EAX,[RSI + R8*0x1]
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
MOVSXD RAX,ECX
LEA RAX,[RDI + RAX*0x4]
CMP R8D,ESI
JG 0x00101346
CMP dword ptr [RAX],EDX
JNZ 0x00101330
MOV EAX,0x1
RET
LAB_00101330:
JLE 0x00101340
LEA ESI,[RCX + -0x1]
JMP 0x0010130a
LAB_001013... | int8 func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
param_2 = param_2 + -1;
iVar3 = 0;
while( true ) {
iVar2 = (param_2 + iVar3) / 2;
if (param_2 < iVar3) {
return 0;
}
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (iVar1 == param_3) break;
... |
5,864 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <stdlib.h>
| double** func0(double startx, double starty, double endx, double endy, double radius) {
double sl = (2 * radius) * tan(M_PI / 6);
double p = sl * 0.5;
double b = sl * cos(M_PI / 6);
double w = b * 2;
double h = 2 * sl;
startx = startx - w;
starty = starty - h;
endx = endx + w;
... | int main() {
double** res;
// Tests would compare the structures generated, which would require setup of expected values;
// for simplicity, I'm keeping the main just as a basic structure call.
res = func0(1, 1, 4, 4, 3);
// Assume a function `compare_polygons` to check if returned polygons a... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xa0,%rsp
movsd %xmm0,-0x78(%rbp)
movsd %xmm1,-0x80(%rbp)
movsd %xmm2,-0x88(%rbp)
movsd %xmm3,-0x90(%rbp)
movsd %xmm4,-0x98(%rbp)
movsd -0x98(%rbp),%xmm0
movapd %xmm0,%xmm1
addsd %xmm0,%xmm1
movsd 0xe76(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x58(%rbp)
m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0A0h
movsd [rbp+var_78], xmm0
movsd [rbp+var_80], xmm1
movsd [rbp+var_88], xmm2
movsd [rbp+var_90], xmm3
movsd [rbp+var_98], xmm4
movsd xmm0, [rbp+var_98]
movapd xmm1, xmm0
addsd xmm1, xmm0
movsd xmm0, cs:qword_2028
mulsd xmm0, xmm1
movsd [rb... | _QWORD * func0(double a1, double a2, double a3, double a4, double a5)
{
int v5; // eax
double v7; // [rsp+20h] [rbp-80h]
double v8; // [rsp+28h] [rbp-78h]
int v9; // [rsp+3Ch] [rbp-64h]
char v10; // [rsp+40h] [rbp-60h]
double v11; // [rsp+50h] [rbp-50h]
double v12; // [rsp+58h] [rbp-48h]
double v13; // ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOVSD qword ptr [RBP + -0x78],XMM0
MOVSD qword ptr [RBP + -0x80],XMM1
MOVSD qword ptr [RBP + -0x88],XMM2
MOVSD qword ptr [RBP + -0x90],XMM3
MOVSD qword ptr [RBP + -0x98],XMM4
MOVSD XMM0,qword ptr [RBP + -0x98]
MOVAPD XMM1,XMM0
ADDSD XMM1,XMM0
MOVSD XMM0,qword ptr [0x0010... | void * func0(double param_1,double param_2,double param_3,double param_4,double param_5)
{
bool bVar1;
void *pvVar2;
double *pdVar3;
double dVar4;
double dVar5;
double dVar6;
double dVar7;
double dVar8;
double local_88;
double local_80;
int local_6c;
dVar4 = DAT_00102028 * (param_5 + param_5... |
5,865 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <stdlib.h>
| double** func0(double startx, double starty, double endx, double endy, double radius) {
double sl = (2 * radius) * tan(M_PI / 6);
double p = sl * 0.5;
double b = sl * cos(M_PI / 6);
double w = b * 2;
double h = 2 * sl;
startx = startx - w;
starty = starty - h;
endx = endx + w;
... | int main() {
double** res;
// Tests would compare the structures generated, which would require setup of expected values;
// for simplicity, I'm keeping the main just as a basic structure call.
res = func0(1, 1, 4, 4, 3);
// Assume a function `compare_polygons` to check if returned polygons a... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
addsd %xmm4,%xmm4
mulsd 0xea5(%rip),%xmm4
movapd %xmm4,%xmm5
mulsd 0xea1(%rip),%xmm5
movsd %xmm5,0x28(%rsp)
movapd %xmm4,%xmm6
mulsd 0xe97(%rip),%xmm6
movsd %xmm6,0x20(%rsp)
addsd %xmm6,%xmm6
movsd %xmm6,0x30(%rsp)
addsd %xmm4,%xm... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
addsd xmm4, xmm4
mulsd xmm4, cs:qword_2028
movapd xmm5, xmm4
mulsd xmm5, cs:qword_2030
movsd [rsp+78h+var_58], xmm5
movapd xmm7, xmm4
mulsd xmm7, cs:qword_2038
movsd [rsp+78h+var_60], xmm7
addsd xmm7,... | long long func0(double a1, double a2, double a3, double a4, double a5)
{
double v5; // xmm4_8
double v6; // rbp
long long v7; // r13
double v8; // rbx
char v9; // r14
int v10; // edx
long long i; // r12
long long v12; // rax
double v13; // xmm1_8
double v14; // xmm3_8
double v16; // [rsp+8h] [rbp... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
ADDSD XMM4,XMM4
MULSD XMM4,qword ptr [0x00102028]
MOVAPD XMM5,XMM4
MULSD XMM5,qword ptr [0x00102030]
MOVSD qword ptr [RSP + 0x20],XMM5
MOVAPD XMM7,XMM4
MULSD XMM7,qword ptr [0x00102038]
MOVSD qword ptr [RSP + 0x18],XMM7
ADDSD XMM7,XMM7
MO... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void * func0(double param_1,double param_2,double param_3,double param_4,double param_5)
{
void *pvVar1;
double *pdVar2;
int iVar3;
long lVar4;
bool bVar5;
double dVar6;
double dVar7;
double dVar8;
double dVar9;
d... |
5,866 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <stdlib.h>
| double** func0(double startx, double starty, double endx, double endy, double radius) {
double sl = (2 * radius) * tan(M_PI / 6);
double p = sl * 0.5;
double b = sl * cos(M_PI / 6);
double w = b * 2;
double h = 2 * sl;
startx = startx - w;
starty = starty - h;
endx = endx + w;
... | int main() {
double** res;
// Tests would compare the structures generated, which would require setup of expected values;
// for simplicity, I'm keeping the main just as a basic structure call.
res = func0(1, 1, 4, 4, 3);
// Assume a function `compare_polygons` to check if returned polygons a... | O2 | c | func0:
endbr64
push %r12
addsd %xmm4,%xmm4
mov $0x320,%edi
push %rbp
mov $0x1,%ebp
push %rbx
sub $0x70,%rsp
movsd 0xde6(%rip),%xmm6
movsd 0xdd6(%rip),%xmm5
mulsd 0xdc6(%rip),%xmm4
mulsd %xmm4,%xmm6
mulsd %xmm4,%xmm5
addsd %xmm4,%xmm4
addsd %xmm4,%xmm3
subsd %xmm4,%xmm1
movsd %xmm4,0x68(%rsp)
mo... | func0:
endbr64
push r15
addsd xmm4, xmm4
mov edi, 320h
push r14
push r12
push rbp
push rbx
mov ebx, 1
sub rsp, 60h
movsd xmm6, cs:qword_2038
movsd xmm5, cs:qword_2030
mulsd xmm4, cs:qword_2028
mulsd xmm6, xmm4
mulsd xmm5, xmm4
addsd xmm4, xmm4
addsd xmm3, xmm4
subsd xmm1, xm... | long long func0(double a1, double a2, double a3, double a4, double a5)
{
char v5; // bl
double v6; // xmm4_8
double v7; // xmm2_8
long long v8; // rax
int v9; // edx
double v10; // xmm0_8
long long v11; // r12
long long v12; // rbp
long long v13; // rax
__int128 v15; // [rsp+0h] [rbp-88h]
double ... | func0:
ENDBR64
PUSH R15
ADDSD XMM4,XMM4
MOV EDI,0x320
PUSH R14
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,0x1
SUB RSP,0x60
MOVSD XMM6,qword ptr [0x00102038]
MOVSD XMM5,qword ptr [0x00102030]
MULSD XMM4,qword ptr [0x00102028]
MULSD XMM6,XMM4
MULSD XMM5,XMM4
ADDSD XMM4,XMM4
ADDSD XMM3,XMM4
SUBSD XMM1,XMM4
MOVSD qword ptr [RSP + ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void * func0(double param_1,double param_2,double param_3,double param_4,double param_5)
{
void *pvVar1;
double *pdVar2;
bool bVar3;
int iVar4;
long lVar5;
double dVar6;
double dVar7;
double dVar8;
double dVar9;
d... |
5,867 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <stdlib.h>
| double** func0(double startx, double starty, double endx, double endy, double radius) {
double sl = (2 * radius) * tan(M_PI / 6);
double p = sl * 0.5;
double b = sl * cos(M_PI / 6);
double w = b * 2;
double h = 2 * sl;
startx = startx - w;
starty = starty - h;
endx = endx + w;
... | int main() {
double** res;
// Tests would compare the structures generated, which would require setup of expected values;
// for simplicity, I'm keeping the main just as a basic structure call.
res = func0(1, 1, 4, 4, 3);
// Assume a function `compare_polygons` to check if returned polygons a... | O3 | c | func0:
endbr64
push %r12
addsd %xmm4,%xmm4
mov $0x320,%edi
push %rbp
mov $0x1,%ebp
push %rbx
sub $0x70,%rsp
movsd 0xde6(%rip),%xmm6
movsd 0xdd6(%rip),%xmm5
mulsd 0xdc6(%rip),%xmm4
mulsd %xmm4,%xmm6
mulsd %xmm4,%xmm5
addsd %xmm4,%xmm4
addsd %xmm4,%xmm3
subsd %xmm4,%xmm1
movsd %xmm4,0x68(%rsp)
mo... | func0:
endbr64
push r15
addsd xmm4, xmm4
mov edi, 320h; size
push r14
push r12
push rbp
push rbx
sub rsp, 60h
movsd xmm7, cs:qword_2038
movsd xmm5, cs:qword_2030
mulsd xmm4, cs:qword_2028
mulsd xmm7, xmm4
movapd xmm6, xmm4
mulsd xmm5, xmm4
addsd xmm6, xmm4
addsd xmm3, xmm6
subsd ... | _QWORD * func0(double a1, double a2, double a3, double a4, double a5)
{
double v5; // xmm4_8
double v6; // r14
_QWORD *v7; // rbx
char v8; // bp
int v9; // eax
__m128d v10; // xmm0
long long v11; // r12
double v12; // xmm4_8
double v13; // xmm3_8
__m128d *v14; // rax
__m128d v15; // xmm1
__m128d... | func0:
ENDBR64
PUSH R15
ADDSD XMM4,XMM4
MOV EDI,0x320
PUSH R14
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x60
MOVSD XMM7,qword ptr [0x00102038]
MOVSD XMM5,qword ptr [0x00102030]
MULSD XMM4,qword ptr [0x00102028]
MULSD XMM7,XMM4
MOVAPD XMM6,XMM4
MULSD XMM5,XMM4
ADDSD XMM6,XMM4
ADDSD XMM3,XMM6
SUBSD XMM1,XMM6
MOVSD qword ptr [R... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void * func0(double param_1,double param_2,double param_3,double param_4,double param_5)
{
long lVar1;
void *pvVar2;
long lVar3;
double *pdVar4;
byte bVar5;
double dVar6;
double dVar7;
double dVar8;
double dVar9;
... |
5,868 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <string.h>
| char* func0(int* test_tup, int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res += test_tup[i] * pow(2, size - 1 - i);
}
char* result_str = (char*) malloc(sizeof(char) * 12);
sprintf(result_str, "%d", res);
return result_str;
}
| int main() {
int arr1[] = {1, 1, 0, 1, 0, 0, 1};
int arr1_size = sizeof(arr1)/sizeof(arr1[0]);
char* result1 = func0(arr1, arr1_size);
assert(strcmp(result1, "105") == 0);
free(result1);
int arr2[] = {0, 1, 1, 0, 0, 1, 0, 1};
int arr2_size = sizeof(arr2)/sizeof(arr2[0]);
char* ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 128a <func0+0x81>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cvtsi2sd %eax,%xmm2
movsd... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp short loc_1296
loc_122C:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
pxor xm... | char * func0(long long a1, int a2)
{
double v3; // [rsp+8h] [rbp-28h]
int v4; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
char *s; // [rsp+28h] [rbp-8h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
v3 = (double)*(int *)(4LL * i + a1);
v4 = (int)((double)v4 + v3 * pow(2.0, (double)(a2 - 1 - i)));
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101296
LAB_0010122c:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr... | char * func0(long param_1,int param_2)
{
int iVar1;
char *__s;
double dVar2;
uint local_18;
int local_14;
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
iVar1 = *(int *)(param_1 + (long)local_14 * 4);
dVar2 = pow(DAT_00102090,(double)((param_2 + -1) - local_14)... |
5,869 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <string.h>
| char* func0(int* test_tup, int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res += test_tup[i] * pow(2, size - 1 - i);
}
char* result_str = (char*) malloc(sizeof(char) * 12);
sprintf(result_str, "%d", res);
return result_str;
}
| int main() {
int arr1[] = {1, 1, 0, 1, 0, 0, 1};
int arr1_size = sizeof(arr1)/sizeof(arr1[0]);
char* result1 = func0(arr1, arr1_size);
assert(strcmp(result1, "105") == 0);
free(result1);
int arr2[] = {0, 1, 1, 0, 0, 1, 0, 1};
int arr2_size = sizeof(arr2)/sizeof(arr2[0]);
char* ... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
test %esi,%esi
jle 12a5 <func0+0xbc>
mov %rdi,%r12
mov %esi,%r14d
lea -0x1(%rsi),%r13d
add $0x2,%r13
mov $0x1,%ebp
mov $0x0,%ebx
pxor %xmm2,%xmm2
cvtsi2sdl -0x4(%r12,%rbp,4),%xmm2
movsd %xmm2,0x8(%rsp)... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
test esi, esi
jle loc_12C5
mov r13, rdi
mov r12d, esi
lea r14d, [rsi+1]
mov ebx, 1
mov ebp, 0
loc_1235:
pxor xmm2, xmm2
cvtsi2sd xmm2, dword ptr [r13+rbx*4-4]
movsd [rsp+38h+var_30], xmm2
mov ... | long long func0(long long a1, int a2)
{
long long v2; // rbx
int v3; // ebp
long long v4; // rbx
double v6; // [rsp+8h] [rbp-30h]
if ( a2 <= 0 )
{
v3 = 0;
}
else
{
v2 = 1LL;
v3 = 0;
do
{
v6 = (double)*(int *)(a1 + 4 * v2 - 4);
v3 = (int)((double)v3 + pow(2.0, (double)... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
TEST ESI,ESI
JLE 0x001012c5
MOV R13,RDI
MOV R12D,ESI
LEA R14D,[RSI + 0x1]
MOV EBX,0x1
MOV EBP,0x0
LAB_00101235:
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [R13 + RBX*0x4 + -0x4]
MOVSD qword ptr [RSP + 0x8],XMM2
MOV EAX,R12D
SUB EAX,EBX
PXOR XMM1,XMM1
... | void * func0(long param_1,int param_2)
{
int iVar1;
void *pvVar2;
ulong uVar3;
int iVar4;
double dVar5;
if (param_2 < 1) {
iVar4 = 0;
}
else {
uVar3 = 1;
iVar4 = 0;
do {
iVar1 = *(int *)(param_1 + -4 + uVar3 * 4);
dVar5 = pow(DAT_00102088,(double)(param_2 - (int)uVar3));
... |
5,870 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <string.h>
| char* func0(int* test_tup, int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res += test_tup[i] * pow(2, size - 1 - i);
}
char* result_str = (char*) malloc(sizeof(char) * 12);
sprintf(result_str, "%d", res);
return result_str;
}
| int main() {
int arr1[] = {1, 1, 0, 1, 0, 0, 1};
int arr1_size = sizeof(arr1)/sizeof(arr1[0]);
char* result1 = func0(arr1, arr1_size);
assert(strcmp(result1, "105") == 0);
free(result1);
int arr2[] = {0, 1, 1, 0, 0, 1, 0, 1};
int arr2_size = sizeof(arr2)/sizeof(arr2[0]);
char* ... | O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
test %esi,%esi
jle 1418 <func0+0xa8>
mov %rdi,%r12
lea -0x1(%rsi),%ebp
xor %ebx,%ebx
nopl 0x0(%rax)
pxor %xmm2,%xmm2
pxor %xmm1,%xmm1
mov 0xd11(%rip),%rax
add $0x4,%r12
cvtsi2sd %ebp,%xmm1
sub $0x1,%ebp
cvtsi2sdl -0x4(%r12... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test esi, esi
jle loc_1440
mov rbp, rdi
lea ebx, [rsi-1]
xor r12d, r12d
nop
loc_13B0:
pxor xmm2, xmm2
pxor xmm1, xmm1
mov rax, cs:qword_2088
add rbp, 4
cvtsi2sd xmm2, dword ptr [rbp-4]
cvtsi2sd xmm1, ebx
mov... | long long func0(long long a1, int a2)
{
int v3; // ebx
int v4; // r12d
long long v6; // r13
double v8; // [rsp+8h] [rbp-30h]
if ( a2 <= 0 )
{
v4 = 0;
}
else
{
v3 = a2 - 1;
v4 = 0;
do
{
a1 += 4LL;
v8 = (double)*(int *)(a1 - 4);
v4 = (int)((double)v4 + pow(2.0, (d... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST ESI,ESI
JLE 0x00101440
MOV RBP,RDI
LEA EBX,[RSI + -0x1]
XOR R12D,R12D
NOP
LAB_001013b0:
PXOR XMM2,XMM2
PXOR XMM1,XMM1
MOV RAX,qword ptr [0x00102088]
ADD RBP,0x4
CVTSI2SD XMM2,dword ptr [RBP + -0x4]
CVTSI2SD XMM1,EBX
MOVQ XMM0,RAX
MOVSD qword ptr [RSP ... | void * func0(int *param_1,int param_2)
{
int iVar1;
void *pvVar2;
int iVar3;
bool bVar4;
double dVar5;
if (param_2 < 1) {
iVar3 = 0;
}
else {
param_2 = param_2 + -1;
iVar3 = 0;
do {
iVar1 = *param_1;
dVar5 = pow(DAT_00102088,(double)param_2);
iVar3 = (int)((double)i... |
5,871 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <string.h>
| char* func0(int* test_tup, int size) {
int res = 0;
for (int i = 0; i < size; i++) {
res += test_tup[i] * pow(2, size - 1 - i);
}
char* result_str = (char*) malloc(sizeof(char) * 12);
sprintf(result_str, "%d", res);
return result_str;
}
| int main() {
int arr1[] = {1, 1, 0, 1, 0, 0, 1};
int arr1_size = sizeof(arr1)/sizeof(arr1[0]);
char* result1 = func0(arr1, arr1_size);
assert(strcmp(result1, "105") == 0);
free(result1);
int arr2[] = {0, 1, 1, 0, 0, 1, 0, 1};
int arr2_size = sizeof(arr2)/sizeof(arr2[0]);
char* ... | O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
test %esi,%esi
jle 1418 <func0+0xa8>
mov %rdi,%r12
lea -0x1(%rsi),%ebp
xor %ebx,%ebx
nopl 0x0(%rax)
pxor %xmm2,%xmm2
pxor %xmm1,%xmm1
mov 0xd11(%rip),%rax
add $0x4,%r12
cvtsi2sd %ebp,%xmm1
sub $0x1,%ebp
cvtsi2sdl -0x4(%r12... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
test esi, esi
jle loc_1420
mov rbp, rdi
lea ebx, [rsi-1]
xor r12d, r12d
nop dword ptr [rax]
loc_13A0:
pxor xmm2, xmm2
pxor xmm1, xmm1
movsd xmm0, cs:x; x
add rbp, 4
cvtsi2sd xmm2, dword ptr [rbp-4]
cvtsi2sd xmm1, ebx;... | void * func0(long long a1, int a2)
{
int v3; // ebx
int v4; // r12d
void *v6; // rbx
double v8; // [rsp+8h] [rbp-20h]
if ( a2 <= 0 )
{
v4 = 0;
}
else
{
v3 = a2 - 1;
v4 = 0;
do
{
a1 += 4LL;
v8 = (double)*(int *)(a1 - 4);
v4 = (int)((double)v4 + pow(2.0, (double)v3... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
TEST ESI,ESI
JLE 0x00101420
MOV RBP,RDI
LEA EBX,[RSI + -0x1]
XOR R12D,R12D
NOP dword ptr [RAX]
LAB_001013a0:
PXOR XMM2,XMM2
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102088]
ADD RBP,0x4
CVTSI2SD XMM2,dword ptr [RBP + -0x4]
CVTSI2SD XMM1,EBX
MOVSD qword ptr [RSP + 0x... | void * func0(int *param_1,int param_2)
{
int iVar1;
void *pvVar2;
int iVar3;
bool bVar4;
double dVar5;
if (param_2 < 1) {
iVar3 = 0;
}
else {
param_2 = param_2 + -1;
iVar3 = 0;
do {
iVar1 = *param_1;
dVar5 = pow(DAT_00102088,(double)param_2);
iVar3 = (int)((double)i... |
5,872 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char* str1) {
static char result[100];
int i, j = 0;
for (i = 0; str1[i] != '\0'; i++) {
if (str1[i] < 'a' || str1[i] > 'z') {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("KDeoALOklOOHserfLoAJSIskdsf"), "KDALOOOHLAJSI") == 0);
assert(strcmp(func0("ProducTnamEstreAmIngMediAplAYer"), "PTEAIMAAY") == 0);
assert(strcmp(func0("maNufacTuredbYSheZenTechNolOGIes"), "NTYSZTNOGI") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d7 <func0+0x6e>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x60,%al
jle 11ad <func0+0x44>
mov -0x8(%rbp),%eax
movslq %eax,%rdx... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_4], 0
mov [rbp+var_8], 0
jmp short loc_11D7
loc_1185:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 60h ; '`'
jle short loc_11AD
mov eax, ... | _BYTE * func0(long long a1)
{
int v1; // eax
int i; // [rsp+10h] [rbp-8h]
int v4; // [rsp+14h] [rbp-4h]
v4 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
{
if ( *(char *)(i + a1) <= 96 || *(char *)(i + a1) > 122 )
{
v1 = v4++;
result_1[v1] = *(_BYTE *)(i + a1);
}
}
result_1[v4] = 0... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d7
LAB_00101185:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x60
JLE 0x001011ad
MOV EAX,dword ptr [... | int1 * func0(long param_1)
{
int local_10;
int local_c;
local_c = 0;
for (local_10 = 0; *(char *)(param_1 + local_10) != '\0'; local_10 = local_10 + 1) {
if ((*(char *)(param_1 + local_10) < 'a') || ('z' < *(char *)(param_1 + local_10))) {
result_1[local_c] = *(int *)(local_10 + param_1);
lo... |
5,873 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char* str1) {
static char result[100];
int i, j = 0;
for (i = 0; str1[i] != '\0'; i++) {
if (str1[i] < 'a' || str1[i] > 'z') {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("KDeoALOklOOHserfLoAJSIskdsf"), "KDALOOOHLAJSI") == 0);
assert(strcmp(func0("ProducTnamEstreAmIngMediAplAYer"), "PTEAIMAAY") == 0);
assert(strcmp(func0("maNufacTuredbYSheZenTechNolOGIes"), "NTYSZTNOGI") == 0);
return 0;
}
| O1 | c | func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 1185 <func0+0x3c>
add $0x1,%rdi
mov $0x0,%ecx
lea 0x2edc(%rip),%rsi
jmp 1172 <func0+0x29>
add $0x1,%rdi
movzbl -0x1(%rdi),%eax
test %al,%al
je 118a <func0+0x41>
lea -0x61(%rax),%edx
cmp $0x19,%dl
jbe 1166 <func0+0x1d>
movslq %ecx,%rdx... | func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jz short loc_11A5
add rdi, 1
mov ecx, 0
lea rsi, result_1
jmp short loc_1192
loc_1186:
add rdi, 1
movzx eax, byte ptr [rdi-1]
test al, al
jz short loc_11AA
loc_1192:
lea edx, [rax-61h]
cmp dl, 19h
jbe short loc_1186... | _BYTE * func0(char *a1)
{
char v1; // al
char *v2; // rdi
int v3; // ecx
_BYTE *result; // rax
v1 = *a1;
if ( *a1 )
{
v2 = a1 + 1;
v3 = 0;
do
{
if ( (unsigned __int8)(v1 - 97) > 0x19u )
result_1[v3++] = v1;
v1 = *v2++;
}
while ( v1 );
}
else
{
v3 = 0;... | func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001011a5
ADD RDI,0x1
MOV ECX,0x0
LEA RSI,[0x104040]
JMP 0x00101192
LAB_00101186:
ADD RDI,0x1
MOVZX EAX,byte ptr [RDI + -0x1]
TEST AL,AL
JZ 0x001011aa
LAB_00101192:
LEA EDX,[RAX + -0x61]
CMP DL,0x19
JBE 0x00101186
MOVSXD RDX,ECX
MOV byte ptr [RSI + RDX*0x1],AL
LEA ... | void func0(char *param_1)
{
char cVar1;
int iVar2;
char *pcVar3;
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar2 = 0;
}
else {
iVar2 = 0;
pcVar3 = param_1 + 1;
do {
if (0x19 < (byte)(cVar1 + 0x9fU)) {
(&result_1)[iVar2] = cVar1;
iVar2 = iVar2 + 1;
}
cVar1... |
5,874 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char* str1) {
static char result[100];
int i, j = 0;
for (i = 0; str1[i] != '\0'; i++) {
if (str1[i] < 'a' || str1[i] > 'z') {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("KDeoALOklOOHserfLoAJSIskdsf"), "KDALOOOHLAJSI") == 0);
assert(strcmp(func0("ProducTnamEstreAmIngMediAplAYer"), "PTEAIMAAY") == 0);
assert(strcmp(func0("maNufacTuredbYSheZenTechNolOGIes"), "NTYSZTNOGI") == 0);
return 0;
}
| O2 | c | func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 1330 <func0+0x50>
add $0x1,%rdi
xor %ecx,%ecx
lea 0x2d48(%rip),%rsi
nopl 0x0(%rax,%rax,1)
lea -0x61(%rax),%edx
cmp $0x19,%dl
jbe 1311 <func0+0x31>
movslq %ecx,%rdx
add $0x1,%ecx
mov %al,(%rsi,%rdx,1)
movzbl (%rdi),%eax
add $0x1,%rdi
te... | func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jz short loc_1290
add rdi, 1
xor ecx, ecx
lea r8, result_1
nop dword ptr [rax+rax+00000000h]
loc_1260:
lea edx, [rax-61h]
cmp dl, 19h
jbe short loc_1272
movsxd rdx, ecx
add ecx, 1
mov [r8+rdx], al
loc_1272:
movzx eax, ... | _BYTE * func0(char *a1)
{
char v1; // al
char *v2; // rdi
int v3; // ecx
long long v4; // rdx
_BYTE *result; // rax
v1 = *a1;
if ( *a1 )
{
v2 = a1 + 1;
v3 = 0;
do
{
if ( (unsigned __int8)(v1 - 97) > 0x19u )
{
v4 = v3++;
result_1[v4] = v1;
}
v1 = *... | func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101290
ADD RDI,0x1
XOR ECX,ECX
LEA R8,[0x104040]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101260:
LEA EDX,[RAX + -0x61]
CMP DL,0x19
JBE 0x00101272
MOVSXD RDX,ECX
ADD ECX,0x1
MOV byte ptr [R8 + RDX*0x1],AL
LAB_00101272:
MOVZX EAX,byte ptr [RDI]
ADD RDI,0x1
TEST AL,AL
... | int1 * func0(char *param_1)
{
char cVar1;
int iVar2;
long lVar3;
cVar1 = *param_1;
if (cVar1 != '\0') {
param_1 = param_1 + 1;
iVar2 = 0;
do {
if (0x19 < (byte)(cVar1 + 0x9fU)) {
lVar3 = (long)iVar2;
iVar2 = iVar2 + 1;
(&result_1)[lVar3] = cVar1;
}
cVa... |
5,875 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char* str1) {
static char result[100];
int i, j = 0;
for (i = 0; str1[i] != '\0'; i++) {
if (str1[i] < 'a' || str1[i] > 'z') {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
assert(strcmp(func0("KDeoALOklOOHserfLoAJSIskdsf"), "KDALOOOHLAJSI") == 0);
assert(strcmp(func0("ProducTnamEstreAmIngMediAplAYer"), "PTEAIMAAY") == 0);
assert(strcmp(func0("maNufacTuredbYSheZenTechNolOGIes"), "NTYSZTNOGI") == 0);
return 0;
}
| O3 | c | func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 1378 <func0+0x68>
add $0x1,%rdi
xor %edx,%edx
lea 0x2d18(%rip),%rsi
nopl 0x0(%rax,%rax,1)
lea -0x61(%rax),%ecx
cmp $0x19,%cl
jbe 1355 <func0+0x45>
add $0x1,%rdi
mov %al,(%rsi,%rdx,1)
lea 0x1(%rdx),%ecx
movzbl -0x1(%rdi),%eax
test %al... | func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jz short loc_1360
add rdi, 1
xor edx, edx
lea rsi, result_1
nop dword ptr [rax+rax+00000000h]
loc_1320:
lea ecx, [rax-61h]
cmp cl, 19h
jbe short loc_1348
add rdi, 1
mov [rsi+rdx], al
lea ecx, [rdx+1]
movzx eax, byte... | long long * func0(char *a1)
{
char v1; // al
char *v2; // rdi
long long v3; // rdx
int v4; // ecx
v1 = *a1;
if ( *a1 )
{
v2 = a1 + 1;
v3 = 0LL;
do
{
while ( (unsigned __int8)(v1 - 97) > 0x19u )
{
++v2;
*((_BYTE *)&result_1 + v3) = v1;
v4 = v3 + 1;
... | func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101360
ADD RDI,0x1
XOR EDX,EDX
LEA RSI,[0x104040]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101320:
LEA ECX,[RAX + -0x61]
CMP CL,0x19
JBE 0x00101348
ADD RDI,0x1
MOV byte ptr [RSI + RDX*0x1],AL
LEA ECX,[RDX + 0x1]
MOVZX EAX,byte ptr [RDI + -0x1]
MOVSXD RDX,ECX
TEST AL,... | int8 * func0(char *param_1)
{
char cVar1;
long lVar2;
char *pcVar3;
cVar1 = *param_1;
if (cVar1 == '\0') {
result_1._0_1_ = 0;
return &result_1;
}
lVar2 = 0;
pcVar3 = param_1 + 1;
do {
while ((byte)(cVar1 + 0x9fU) < 0x1a) {
cVar1 = *pcVar3;
pcVar3 = pcVar3 + 1;
if (cV... |
5,876 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| void func0(int nums[], int len, int n, int result[]) {
qsort(nums, len, sizeof(int), compare);
for (int i = 0; i < n; i++) {
result[i] = nums[i];
}
}
| int main() {
int nums1[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int result1[3];
int expected1[3] = {14, 22, 25};
func0(nums1, 9, 3, result1);
assert(memcmp(result1, expected1, 3 * sizeof(int)) == 0);
int nums2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int result2[2];
int expec... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rsi
mov -0x18(%rbp),%rax
lea -0x4d(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 1080 <qsort@plt>
movl $0x0,-0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+base], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
mov eax, [rbp+var_1C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax... | long long func0(void *a1, int a2, int a3, long long a4)
{
long long result; // rax
unsigned int i; // [rsp+2Ch] [rbp-4h]
qsort(a1, a2, 4uLL, compare);
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a3 )
break;
*(_DWORD *)(4LL * (int)i + a4) = *((_DWORD *)a1 + (int)i);
}
return resul... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x1011a9]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x00... | void func0(void *param_1,int param_2,int param_3,long param_4)
{
int local_c;
qsort(param_1,(long)param_2,4,compare);
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
*(int4 *)(param_4 + (long)local_c * 4) =
*(int4 *)((long)param_1 + (long)local_c * 4);
}
return;
} |
5,877 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| void func0(int nums[], int len, int n, int result[]) {
qsort(nums, len, sizeof(int), compare);
for (int i = 0; i < n; i++) {
result[i] = nums[i];
}
}
| int main() {
int nums1[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int result1[3];
int expected1[3] = {14, 22, 25};
func0(nums1, 9, 3, result1);
assert(memcmp(result1, expected1, 3 * sizeof(int)) == 0);
int nums2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int result2[2];
int expec... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %edx,%r12d
mov %rcx,%rbp
movslq %esi,%rsi
lea -0x24(%rip),%rcx
mov $0x4,%edx
callq 1080 <qsort@plt>
test %r12d,%r12d
jle 11f9 <func0+0x47>
lea -0x1(%r12),%ecx
mov $0x0,%eax
mov (%rbx,%rax,4),%edx
mov %edx,0x0(%rbp,%rax... | func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov ebx, edx
mov r12, rcx
movsxd rsi, esi
lea rcx, compare
mov edx, 4
call _qsort
test ebx, ebx
jle short loc_11F2
mov ecx, ebx
mov eax, 0
loc_11E1:
mov edx, [rbp+rax*4+0]
mov [r12+rax*4], edx
add rax, 1
c... | long long func0(long long a1, int a2, int a3, long long a4)
{
long long result; // rax
result = qsort(a1, a2, 4LL, compare);
if ( a3 > 0 )
{
result = 0LL;
do
{
*(_DWORD *)(a4 + 4 * result) = *(_DWORD *)(a1 + 4 * result);
++result;
}
while ( result != a3 );
}
return result;
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,EDX
MOV R12,RCX
MOVSXD RSI,ESI
LEA RCX,[0x1011a9]
MOV EDX,0x4
CALL 0x00101080
TEST EBX,EBX
JLE 0x001011f2
MOV ECX,EBX
MOV EAX,0x0
LAB_001011e1:
MOV EDX,dword ptr [RBP + RAX*0x4]
MOV dword ptr [R12 + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x001011e1
LAB_001... | void func0(void *param_1,int param_2,uint param_3,long param_4)
{
ulong uVar1;
qsort(param_1,(long)param_2,4,compare);
if (0 < (int)param_3) {
uVar1 = 0;
do {
*(int4 *)(param_4 + uVar1 * 4) = *(int4 *)((long)param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
}
ret... |
5,878 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| void func0(int nums[], int len, int n, int result[]) {
qsort(nums, len, sizeof(int), compare);
for (int i = 0; i < n; i++) {
result[i] = nums[i];
}
}
| int main() {
int nums1[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int result1[3];
int expected1[3] = {14, 22, 25};
func0(nums1, 9, 3, result1);
assert(memcmp(result1, expected1, 3 * sizeof(int)) == 0);
int nums2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int result2[2];
int expec... | O2 | c | func0:
endbr64
push %r12
movslq %esi,%rsi
mov %edx,%r12d
mov $0x4,%edx
push %rbp
mov %rcx,%rbp
lea -0x2c(%rip),%rcx
push %rbx
mov %rdi,%rbx
callq 1070 <qsort@plt>
test %r12d,%r12d
jle 141b <func0+0x4b>
lea -0x1(%r12),%ecx
xor %eax,%eax
nopl 0x0(%rax)
mov (%rbx,%rax,4),%edx
mov %... | func0:
endbr64
push r12
movsxd rsi, esi
mov r12, rcx
lea rcx, compare
push rbp
mov rbp, rdi
push rbx
mov ebx, edx
mov edx, 4
call _qsort
test ebx, ebx
jle short loc_1401
movsxd rdx, ebx
xor eax, eax
nop dword ptr [rax]
loc_13F0:
mov ecx, [rbp+rax*4+0]
mov [r12+ra... | long long func0(long long a1, int a2, int a3, long long a4)
{
long long result; // rax
result = qsort(a1, a2, 4LL, compare);
if ( a3 > 0 )
{
result = 0LL;
do
{
*(_DWORD *)(a4 + 4 * result) = *(_DWORD *)(a1 + 4 * result);
++result;
}
while ( result != a3 );
}
return result;
... | func0:
ENDBR64
PUSH R12
MOVSXD RSI,ESI
MOV R12,RCX
LEA RCX,[0x1013b0]
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV EBX,EDX
MOV EDX,0x4
CALL 0x00101070
TEST EBX,EBX
JLE 0x00101401
MOVSXD RDX,EBX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001013f0:
MOV ECX,dword ptr [RBP + RAX*0x4]
MOV dword ptr [R12 + RAX*0x4],ECX
ADD RAX,0x1
CMP RAX,RDX... | void func0(void *param_1,int param_2,int param_3,long param_4)
{
long lVar1;
qsort(param_1,(long)param_2,4,compare);
if (0 < param_3) {
lVar1 = 0;
do {
*(int4 *)(param_4 + lVar1 * 4) = *(int4 *)((long)param_1 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (lVar1 != param_3);
}
return;
} |
5,879 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| void func0(int nums[], int len, int n, int result[]) {
qsort(nums, len, sizeof(int), compare);
for (int i = 0; i < n; i++) {
result[i] = nums[i];
}
}
| int main() {
int nums1[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int result1[3];
int expected1[3] = {14, 22, 25};
func0(nums1, 9, 3, result1);
assert(memcmp(result1, expected1, 3 * sizeof(int)) == 0);
int nums2[] = {25, 35, 22, 85, 14, 65, 75, 25, 58};
int result2[2];
int expec... | O3 | c | func0:
endbr64
push %r12
movslq %esi,%rsi
mov %edx,%r12d
mov $0x4,%edx
push %rbp
mov %rcx,%rbp
lea -0x2c(%rip),%rcx
push %rbx
mov %rdi,%rbx
callq 1070 <qsort@plt>
test %r12d,%r12d
jle 142b <func0+0x9b>
lea 0xf(%rbx),%rdx
lea -0x1(%r12),%eax
sub %rbp,%rdx
cmp $0x1e,%rdx
jbe 1430... | func0:
endbr64
push r12
movsxd rsi, esi; nmemb
mov r12, rcx
lea rcx, compare; compar
push rbp
mov rbp, rdi
push rbx
movsxd rbx, edx
mov edx, 4; size
call _qsort
test ebx, ebx
jle short loc_13E1
lea eax, [rbx-1]
cmp eax, 2
jbe short loc_13C1
lea rdx, [rbp+4]
mov r... | void func0(char *a1, int a2, int a3, long long a4)
{
long long v5; // rbx
long long v6; // rbx
long long v7; // rax
long long v8; // rax
unsigned int v9; // eax
long long v10; // rdx
v5 = a3;
qsort(a1, a2, 4uLL, compare);
if ( (int)v5 > 0 )
{
if ( (unsigned int)(v5 - 1) > 2 && (unsigned long l... | func0:
ENDBR64
PUSH R12
MOVSXD RSI,ESI
MOV R12,RCX
LEA RCX,[0x101370]
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOVSXD RBX,EDX
MOV EDX,0x4
CALL 0x00101070
TEST EBX,EBX
JLE 0x001013e1
LEA EAX,[RBX + -0x1]
CMP EAX,0x2
JBE 0x001013c1
LEA RDX,[RBP + 0x4]
MOV RAX,R12
SUB RAX,RDX
CMP RAX,0x8
JA 0x001013f0
LAB_001013c1:
SHL RBX,0x2
XOR E... | void func0(void *param_1,int param_2,uint param_3,long param_4)
{
int8 uVar1;
uint uVar2;
long lVar3;
ulong uVar4;
qsort(param_1,(long)param_2,4,compare);
if (0 < (int)param_3) {
if ((param_3 - 1 < 3) || ((ulong)(param_4 - ((long)param_1 + 4)) < 9)) {
lVar3 = 0;
do {
*(int4 *)(pa... |
5,880 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double SA = M_PI * r * (r + l);
return SA;
}
| int main() {
assert(func0(5, 12) == 282.7433388230814);
assert(func0(10, 15) == 880.5179353159282);
assert(func0(19, 17) == 2655.923961165254);
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 (a1 + sqrt(a1 * a1 + a2 * a2)) * (a1 * 3.141592653589793);
} | 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 (param_1 + dVar1) * param_1 * DAT_001020a0;
} |
5,881 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double SA = M_PI * r * (r + l);
return SA;
}
| int main() {
assert(func0(5, 12) == 282.7433388230814);
assert(func0(10, 15) == 880.5179353159282);
assert(func0(19, 17) == 2655.923961165254);
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 11ba <func0+0x51>
movsd 0x8(%rsp),%xmm0
movapd %xmm0,%xmm1
mulsd 0xf14(%rip),%xmm1
addsd (%rsp),%xmm... | 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_11B0
sqrtsd xmm1, xmm1
loc_1191:
movsd xmm3, [rsp+18h+var_10]
movapd xmm0, xmm3
mulsd xmm0, cs:qword_20A0
addsd xmm1, xmm3
mulsd xmm0,... | double func0(double a1, double a2)
{
double v2; // xmm1_8
double v3; // xmm1_8
v2 = a2 * a2 + a1 * a1;
if ( v2 < 0.0 )
v3 = sqrt(v2);
else
v3 = sqrt(v2);
return a1 * 3.141592653589793 * (v3 + a1);
} | 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 0x001011b0
SQRTSD XMM1,XMM1
LAB_00101191:
MOVSD XMM3,qword ptr [RSP + 0x8]
MOVAPD XMM0,XMM3
MULSD XMM0,qword ptr [0x001020a0]
ADDSD XMM1,XMM3
MULSD XMM0,XMM1
ADD RSP,0x18
RET
... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = param_2 * param_2 + param_1 * param_1;
if (dVar1 < 0.0) {
dVar1 = sqrt(dVar1);
}
else {
dVar1 = SQRT(dVar1);
}
return param_1 * _DAT_001020a... |
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.