index int64 0 66.5k | func_name stringlengths 2 5.36k | func_dep stringlengths 16 2.19k | func stringlengths 8 55.3k | test stringlengths 0 7.07k | opt stringclasses 4
values | language stringclasses 2
values | asm stringlengths 0 45.4k | ida_asm stringlengths 0 44.7k | ida_pseudo stringlengths 0 44.3k | ghidra_asm stringlengths 0 49.1k | ghidra_pseudo stringlengths 0 64.7k |
|---|---|---|---|---|---|---|---|---|---|---|---|
7,182 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
| bool func0(const char *p) {
int len = strlen(p);
bool hasLower = false;
bool hasUpper = false;
bool hasDigit = false;
bool hasSpecial = false;
if (len < 6 || len > 12) {
return false;
}
for (int i = 0; i < len; i++) {
if (islower(p[i])) {
hasLow... | int main() {
assert(func0("password") == false);
assert(func0("Password@10") == true);
assert(func0("password@10") == false);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
lea -0x6(%rax),%edx
mov %rax,%rbx
xor %eax,%eax
cmp $0x6,%edx
ja 12de <func0+0xae>
test %ebx,%ebx
jle 12de <func0+0xae>
callq 1090 <__ctype_b_loc@plt>
mov %rbp,%rdi
xor %r10d,%r10d
xor %r9d,%... | func0:
endbr64
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
lea edx, [rax-6]
mov rbx, rax
xor eax, eax
cmp edx, 6
ja loc_12DE
test ebx, ebx
jle loc_12DE
call ___ctype_b_loc
mov rdx, rbp
xor r10d, r10d
xor r9d, r9d
mov r11, [rax]
lea eax, [rbx... | char func0(_BYTE *a1)
{
int v1; // eax
unsigned int v2; // edx
int v3; // ebx
char result; // al
long long *v5; // rax
_BYTE *v6; // rdx
char v7; // r10
char v8; // r9
long long v9; // r11
long long v10; // rax
char v11; // r8
char v12; // bl
long long v13; // rdi
long long v14; // rax
__... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
LEA EDX,[RAX + -0x6]
MOV RBX,RAX
XOR EAX,EAX
CMP EDX,0x6
JA 0x001012de
TEST EBX,EBX
JLE 0x001012de
CALL 0x00101090
MOV RDX,RBP
XOR R10D,R10D
XOR R9D,R9D
MOV R11,qword ptr [RAX]
LEA EAX,[RBX + -0x1]
XOR R8D,R8D
XOR EBX,EBX
LEA RDI,[RBP + RAX*0x1 + ... | uint func0(char *param_1)
{
char *pcVar1;
char cVar2;
ushort uVar3;
bool bVar4;
int iVar5;
uint uVar6;
byte bVar7;
uint uVar8;
size_t sVar9;
ushort **ppuVar10;
uint uVar11;
byte bVar12;
byte bVar13;
uint uVar14;
sVar9 = strlen(param_1);
iVar5 = (int)sVar9;
uVar8 = 0;
if ((iVar5 -... |
7,183 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
| bool func0(const char *p) {
int len = strlen(p);
bool hasLower = false;
bool hasUpper = false;
bool hasDigit = false;
bool hasSpecial = false;
if (len < 6 || len > 12) {
return false;
}
for (int i = 0; i < len; i++) {
if (islower(p[i])) {
hasLow... | int main() {
assert(func0("password") == false);
assert(func0("Password@10") == true);
assert(func0("password@10") == false);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
lea -0x6(%rax),%edx
mov %rax,%rbx
xor %eax,%eax
cmp $0x6,%edx
ja 12de <func0+0xae>
test %ebx,%ebx
jle 12de <func0+0xae>
callq 1090 <__ctype_b_loc@plt>
mov %rbp,%rdi
xor %r10d,%r10d
xor %r9d,%... | func0:
endbr64
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
lea edx, [rax-6]
mov rbx, rax
xor eax, eax
cmp edx, 6
ja short loc_12CD
call ___ctype_b_loc
xor edx, edx
xor r11d, r11d
xor r10d, r10d
mov rdi, [rax]
xor r9d, r9d
xor r8d, r8d
jmp s... | char func0(const char *a1)
{
int v2; // eax
unsigned int v3; // edx
int v4; // ebx
char result; // al
const unsigned __int16 **v6; // rax
long long v7; // rdx
bool v8; // r11
char v9; // r10
const unsigned __int16 *v10; // rdi
char v11; // r9
char v12; // r8
long long v13; // rsi
unsigned __i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
LEA EDX,[RAX + -0x6]
MOV RBX,RAX
XOR EAX,EAX
CMP EDX,0x6
JA 0x001012cd
CALL 0x00101090
XOR EDX,EDX
XOR R11D,R11D
XOR R10D,R10D
MOV RDI,qword ptr [RAX]
XOR R9D,R9D
XOR R8D,R8D
JMP 0x001012a0
LAB_00101270:
TEST CH,0x1
JNZ 0x001012d8
TEST CH,0x8
JNZ ... | uint func0(char *param_1)
{
char cVar1;
ushort uVar2;
bool bVar3;
int iVar4;
uint uVar5;
byte bVar6;
uint uVar7;
size_t sVar8;
ushort **ppuVar9;
long lVar10;
byte bVar11;
byte bVar12;
uint uVar13;
uint uVar14;
sVar8 = strlen(param_1);
iVar4 = (int)sVar8;
uVar7 = 0;
if (iVar4 - 6U... |
7,184 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* string, const char* sample) {
if (strstr(string, sample) != NULL) {
regex_t regex;
int result;
char pattern[100] = "^";
strcat(pattern, sample);
regcomp(®ex, pattern, 0);
result = regexec(®ex, string, 0, NULL, 0);
regfre... | int main() {
assert(strcmp(func0("dreams for dreams makes life fun", "makes"), "string doesnt start with the given substring") == 0);
assert(strcmp(func0("Hi there how are you Hi alex", "Hi"), "string starts with the given substring") == 0);
assert(strcmp(func0("Its been a long day", "been"), "string doe... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xd0,%rsp
mov %rdi,-0xc8(%rbp)
mov %rsi,-0xd0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0xd0(%rbp),%rdx
mov -0xc8(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1130 <strstr@plt>
test %rax,%rax
je 1365 <func0+0x13c>... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+haystack], rdi
mov [rbp+needle], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rdx, [rbp+needle]
mov rax, [rbp+haystack]
mov rsi, rdx; needle
mov rdi, rax; haystack
call _strstr
test rax, rax
jz ... | const char * func0(const char *a1, const char *a2)
{
int v3; // [rsp+1Ch] [rbp-B4h]
regex_t preg; // [rsp+20h] [rbp-B0h] BYREF
char dest[8]; // [rsp+60h] [rbp-70h] BYREF
long long v6; // [rsp+68h] [rbp-68h]
long long v7; // [rsp+70h] [rbp-60h]
long long v8; // [rsp+78h] [rbp-58h]
long long v9; // [rsp+80h... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV qword ptr [RBP + -0xc8],RDI
MOV qword ptr [RBP + -0xd0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RBP + -0xd0]
MOV RAX,qword ptr [RBP + -0xc8]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101130
TEST RAX,RAX
JZ 0x00101365
MOV q... | char * func0(char *param_1,char *param_2)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_b8;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = strstr(param_1,param_2);
if (pcVar2 == (char *)0x0) {
pcVar2 = "entered string isnt a substring";
... |
7,185 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* string, const char* sample) {
if (strstr(string, sample) != NULL) {
regex_t regex;
int result;
char pattern[100] = "^";
strcat(pattern, sample);
regcomp(®ex, pattern, 0);
result = regexec(®ex, string, 0, NULL, 0);
regfre... | int main() {
assert(strcmp(func0("dreams for dreams makes life fun", "makes"), "string doesnt start with the given substring") == 0);
assert(strcmp(func0("Hi there how are you Hi alex", "Hi"), "string starts with the given substring") == 0);
assert(strcmp(func0("Its been a long day", "been"), "string doe... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0xb0,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
callq 1110 <strstr@plt>
mov %rax,%rdx
lea 0xe20(%rip),%rax
test %rdx,%rdx
je 132d <func0+0x124>
movq $0x5e,0x40(%rsp)
movq $0x0,0x48(%rsp)
... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 0B0h
mov rbx, rdi
mov rbp, rsi
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
call _strstr
mov rdx, rax
lea rax, aEnteredStringI; "entered string isnt a substring"
test rdx, rdx
jz loc_134D
mov [rsp+0C8h+... | const char * func0(long long a1, long long a2)
{
long long v2; // rdx
const char *result; // rax
int v4; // ebx
_BYTE v5[64]; // [rsp+0h] [rbp-C8h] BYREF
_QWORD v6[12]; // [rsp+40h] [rbp-88h] BYREF
int v7; // [rsp+A0h] [rbp-28h]
unsigned long long v8; // [rsp+A8h] [rbp-20h]
v8 = __readfsqword(0x28u);
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb0
MOV RBX,RDI
MOV RBP,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
CALL 0x00101130
MOV RDX,RAX
LEA RAX,[0x102060]
TEST RDX,RDX
JZ 0x0010134d
MOV qword ptr [RSP + 0x40],0x5e
MOV qword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x0
MO... | char * func0(char *param_1,char *param_2)
{
int iVar1;
char *pcVar2;
char *pcVar3;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = strstr(param_1,param_2);
pcVar3 = "entered string isnt a substring";
if (pcVar2 != (c... |
7,186 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* string, const char* sample) {
if (strstr(string, sample) != NULL) {
regex_t regex;
int result;
char pattern[100] = "^";
strcat(pattern, sample);
regcomp(®ex, pattern, 0);
result = regexec(®ex, string, 0, NULL, 0);
regfre... | int main() {
assert(strcmp(func0("dreams for dreams makes life fun", "makes"), "string doesnt start with the given substring") == 0);
assert(strcmp(func0("Hi there how are you Hi alex", "Hi"), "string starts with the given substring") == 0);
assert(strcmp(func0("Its been a long day", "been"), "string doe... | O2 | c | func0:
endbr64
push %r13
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
callq 1110 <strstr@plt>
mov %rax,%r8
lea 0xd28(%rip),%rax
test %r8,%r8
je 13d8 <func0+0xd8>
pxor %xmm0,%xmm0
mov %r12,%rsi
lea 0x41(%rs... | func0:
endbr64
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
sub rsp, 0B0h
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
call _strstr
mov r8, rax
lea rax, aEnteredStringI; "entered string isnt a substring"
test r8, r8
jz loc_13E8
pxor xmm0, xmm0
mo... | const char * func0(long long a1, long long a2)
{
long long v2; // r8
const char *result; // rax
int v4; // ebp
_BYTE v5[64]; // [rsp+0h] [rbp-C8h] BYREF
_QWORD v6[2]; // [rsp+40h] [rbp-88h] BYREF
__int128 v7; // [rsp+50h] [rbp-78h]
__int128 v8; // [rsp+60h] [rbp-68h]
__int128 v9; // [rsp+70h] [rbp-58h]
... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
CALL 0x00101130
MOV R8,RAX
LEA RAX,[0x102060]
TEST R8,R8
JZ 0x001013e8
PXOR XMM0,XMM0
MOV RSI,R12
LEA RDI,[RSP + 0x41]
MOV R12,RSP
MOV EDX,0x63
LEA R13,[RSP + 0x40]
MOVAP... | char * func0(char *param_1,char *param_2)
{
int iVar1;
char *pcVar2;
char *pcVar3;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [16];
int1 local_78 [16];
int1 local_68 [16];
int1 local_58 [16];
int1 local_48 [16];
int1 local_38 [16];
int4 local_28;
long local_20;
local_20 = *(long... |
7,187 | func0 | #include <stdio.h>
#include <assert.h>
#include <string.h>
#include <regex.h>
| char* func0(const char* string, const char* sample) {
if (strstr(string, sample) != NULL) {
regex_t regex;
int result;
char pattern[100] = "^";
strcat(pattern, sample);
regcomp(®ex, pattern, 0);
result = regexec(®ex, string, 0, NULL, 0);
regfre... | int main() {
assert(strcmp(func0("dreams for dreams makes life fun", "makes"), "string doesnt start with the given substring") == 0);
assert(strcmp(func0("Hi there how are you Hi alex", "Hi"), "string starts with the given substring") == 0);
assert(strcmp(func0("Its been a long day", "been"), "string doe... | O3 | c | func0:
endbr64
push %r13
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
sub $0xb0,%rsp
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
callq 1110 <strstr@plt>
mov %rax,%r8
lea 0xd28(%rip),%rax
test %r8,%r8
je 13d8 <func0+0xd8>
pxor %xmm0,%xmm0
mov %r12,%rsi
lea 0x41(%rs... | func0:
endbr64
push r12
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 0B0h
mov rax, fs:28h
mov [rsp+0C8h+var_20], rax
xor eax, eax
call _strstr
mov rdx, rax
lea rax, aEnteredStringI; "entered string isnt a substring"
test rdx, rdx
jz loc_13E7
pxor xmm0, xmm0... | const char * func0(char *string, const char *a2)
{
char *v2; // rdx
const char *result; // rax
int v4; // ebx
regex_t v5; // [rsp+0h] [rbp-C8h] BYREF
char pattern[8]; // [rsp+40h] [rbp-88h] BYREF
long long v7; // [rsp+48h] [rbp-80h]
__int128 v8; // [rsp+50h] [rbp-78h]
__int128 v9; // [rsp+60h] [rbp-68h]... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
CALL 0x00101130
MOV RDX,RAX
LEA RAX,[0x102068]
TEST RDX,RDX
JZ 0x001013e7
PXOR XMM0,XMM0
MOV RSI,RBP
LEA RDI,[RSP + 0x41]
MOV RBP,RSP
MOV EDX,0x63
LEA R12,[RSP + 0x40]
MO... | char * func0(char *param_1,char *param_2)
{
int iVar1;
char *pcVar2;
char *pcVar3;
long in_FS_OFFSET;
regex_t rStack_c8;
char local_88 [16];
int local_78 [16];
int local_68 [16];
int local_58 [16];
int local_48 [16];
int local_38 [16];
int4 local_28;
long local_20;
local_20 = *(long *)(i... |
7,188 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| void func0(int *l, int len, int **out, int *out_len) {
int i, j = 0;
*out = (int*) malloc(len * sizeof(int));
for(i = 0; i < len; i++) {
if (l[i] % 2 != 0) {
(*out)[j++] = l[i];
}
}
*out_len = j;
}
| int main() {
int arr1[] = {1,3,5,2}, arr2[] = {5,6,7}, arr3[] = {1,2,3,4};
int *res;
int res_len;
func0(arr1, 4, &res, &res_len);
assert(res_len == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
free(res);
func0(arr2, 3, &res, &res_len);
assert(res_len == 2 && res[0] == 5 &... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rdx
mov -0x28(%rbp),%rax
mov %rd... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_4], 0
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_28]
mov ... | _DWORD * func0(long long a1, int a2, void **a3, _DWORD *a4)
{
int v4; // eax
_DWORD *result; // rax
int i; // [rsp+28h] [rbp-8h]
int v9; // [rsp+2Ch] [rbp-4h]
v9 = 0;
*a3 = malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) != 0 )
{
v4 = v9++;
*((_DW... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x4],0x0
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV RDX,RAX
MOV RAX,qword ptr [RBP ... | void func0(long param_1,int param_2,long *param_3,int *param_4)
{
void *pvVar1;
int4 local_10;
int4 local_c;
local_c = 0;
pvVar1 = malloc((long)param_2 << 2);
*param_3 = (long)pvVar1;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
if ((*(uint *)(param_1 + (long)local_10 * 4) & 1... |
7,189 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| void func0(int *l, int len, int **out, int *out_len) {
int i, j = 0;
*out = (int*) malloc(len * sizeof(int));
for(i = 0; i < len; i++) {
if (l[i] % 2 != 0) {
(*out)[j++] = l[i];
}
}
*out_len = j;
}
| int main() {
int arr1[] = {1,3,5,2}, arr2[] = {5,6,7}, arr3[] = {1,2,3,4};
int *res;
int res_len;
func0(arr1, 4, &res, &res_len);
assert(res_len == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
free(res);
func0(arr2, 3, &res, &res_len);
assert(res_len == 2 && res[0] == 5 &... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%r12d
mov %rdx,%rbx
mov %rcx,%rbp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,(%rbx)
test %r12d,%r12d
jle 120a <func0+0x61>
mov %r13,%rax
lea -0x1(%r12),%edx
lea 0x... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rdi
mov r12d, esi
mov rbx, rdx
mov rbp, rcx
movsxd rdi, esi
shl rdi, 2
call _malloc
mov [rbx], rax
test r12d, r12d
jle short loc_120A
mov rax, r13
lea edx, [r12-1]
lea rsi, [r13+rdx*4+4]... | _DWORD * func0(_DWORD *a1, int a2, _QWORD *a3, _DWORD *a4)
{
_DWORD *result; // rax
int v7; // ecx
result = (_DWORD *)malloc(4LL * a2);
*a3 = result;
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
result = a1;
v7 = 0;
do
{
if ( (*result & 1) != 0 )
*(_DWORD *)(*a3 + 4LL * v7++) =... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV R12D,ESI
MOV RBX,RDX
MOV RBP,RCX
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
MOV qword ptr [RBX],RAX
TEST R12D,R12D
JLE 0x0010120a
MOV RAX,R13
LEA EDX,[R12 + -0x1]
LEA RSI,[R13 + RDX*0x4 + 0x4]
MOV ECX,0x0
JMP 0x001011f4
LAB_001011eb:
ADD RAX... | void func0(uint *param_1,int param_2,long *param_3,int *param_4)
{
uint *puVar1;
void *pvVar2;
int iVar3;
pvVar2 = malloc((long)param_2 << 2);
*param_3 = (long)pvVar2;
if (param_2 < 1) {
iVar3 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
if ((*para... |
7,190 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| void func0(int *l, int len, int **out, int *out_len) {
int i, j = 0;
*out = (int*) malloc(len * sizeof(int));
for(i = 0; i < len; i++) {
if (l[i] % 2 != 0) {
(*out)[j++] = l[i];
}
}
*out_len = j;
}
| int main() {
int arr1[] = {1,3,5,2}, arr2[] = {5,6,7}, arr3[] = {1,2,3,4};
int *res;
int res_len;
func0(arr1, 4, &res, &res_len);
assert(res_len == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
free(res);
func0(arr2, 3, &res, &res_len);
assert(res_len == 2 && res[0] == 5 &... | O2 | c | func0:
endbr64
push %r13
mov %rdx,%r13
push %r12
mov %rcx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %rax,0x0(%r13)
test %ebp,%ebp
jle 13d0 <func0+0x70>
lea -0x1(%rbp),%edx
mov %rbx,%rdi
xor %e... | func0:
endbr64
push r13
mov r13, rdx
push r12
mov r12, rcx
push rbp
push rbx
mov rbx, rdi
movsxd rdi, esi
mov rbp, rdi
shl rdi, 2
sub rsp, 8
call _malloc
mov [r13+0], rax
test ebp, ebp
jle short loc_13D0
lea ecx, [rbp-1]
mov rdx, rbx
xor esi, esi
lea rd... | long long func0(_DWORD *a1, int a2, long long *a3, _DWORD *a4)
{
long long result; // rax
_DWORD *v8; // rdx
int v9; // esi
long long v10; // r8
result = malloc(4LL * a2);
*a3 = result;
if ( a2 <= 0 )
{
*a4 = 0;
}
else
{
v8 = a1;
v9 = 0;
do
{
if ( (*v8 & 1) != 0 )
... | func0:
ENDBR64
PUSH R13
MOV R13,RDX
PUSH R12
MOV R12,RCX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
MOV RBP,RDI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010b0
MOV qword ptr [R13],RAX
TEST EBP,EBP
JLE 0x001013d0
LEA ECX,[RBP + -0x1]
MOV RDX,RBX
XOR ESI,ESI
LEA RDI,[RBX + RCX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101... | void func0(uint *param_1,int param_2,int8 *param_3,int *param_4)
{
uint *puVar1;
void *pvVar2;
int iVar3;
long lVar4;
pvVar2 = malloc((long)param_2 << 2);
*param_3 = pvVar2;
if (0 < param_2) {
iVar3 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if ((*param_1 & 1) != 0) {
... |
7,191 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
| void func0(int *l, int len, int **out, int *out_len) {
int i, j = 0;
*out = (int*) malloc(len * sizeof(int));
for(i = 0; i < len; i++) {
if (l[i] % 2 != 0) {
(*out)[j++] = l[i];
}
}
*out_len = j;
}
| int main() {
int arr1[] = {1,3,5,2}, arr2[] = {5,6,7}, arr3[] = {1,2,3,4};
int *res;
int res_len;
func0(arr1, 4, &res, &res_len);
assert(res_len == 3 && res[0] == 1 && res[1] == 3 && res[2] == 5);
free(res);
func0(arr2, 3, &res, &res_len);
assert(res_len == 2 && res[0] == 5 &... | O3 | c | func0:
endbr64
push %r13
mov %rdx,%r13
push %r12
mov %rcx,%r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %rax,0x0(%r13)
test %ebp,%ebp
jle 13b0 <func0+0x70>
lea -0x1(%rbp),%edx
mov %rbx,%rdi
xor %e... | func0:
endbr64
push r14
movsxd r8, esi
mov r14, rdx
push r13
mov r13, rcx
push r12
mov r12, r8
push rbp
lea rbp, ds:0[r8*4]
push rbx
mov rbx, rdi
mov rdi, rbp; size
call _malloc
mov [r14], rax
test r12d, r12d
jle short loc_13B0
mov rdx, rbx
lea r8, [rbx+rbp]... | _DWORD * func0(_DWORD *a1, int a2, _QWORD *a3, _DWORD *a4)
{
_DWORD *result; // rax
_DWORD *v8; // rdx
int v9; // edi
long long v10; // r9
result = malloc(4LL * a2);
*a3 = result;
if ( a2 <= 0 )
{
*a4 = 0;
}
else
{
v8 = a1;
v9 = 0;
do
{
if ( (*v8 & 1) != 0 )
{
... | func0:
ENDBR64
PUSH R14
MOVSXD R8,ESI
MOV R14,RDX
PUSH R13
MOV R13,RCX
PUSH R12
MOV R12,R8
PUSH RBP
LEA RBP,[R8*0x4]
PUSH RBX
MOV RBX,RDI
MOV RDI,RBP
CALL 0x001010b0
MOV qword ptr [R14],RAX
TEST R12D,R12D
JLE 0x001013b0
MOV RDX,RBX
LEA R8,[RBX + RBP*0x1]
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_00101380:
MOV ESI,dword ptr [... | void func0(uint *param_1,int param_2,int8 *param_3,int *param_4)
{
uint *puVar1;
void *pvVar2;
int iVar3;
long lVar4;
pvVar2 = malloc((long)param_2 * 4);
*param_3 = pvVar2;
if (0 < param_2) {
puVar1 = param_1 + param_2;
iVar3 = 0;
do {
if ((*param_1 & 1) != 0) {
lVar4 = (long... |
7,192 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums[], int num_size, int list_index[], int index_size, int* result_size) {
static int result[100];
for (int i = 0; i < index_size; i++) {
result[i] = nums[list_index[i]];
}
*result_size = index_size;
return result;
}
| int main() {
int result_size;
int *result;
result = func0((int[]){2,3,8,4,7,9}, 6, (int[]){0,3,5}, 3, &result_size);
assert(result_size == 3 && result[0] == 2 && result[1] == 4 && result[2] == 9);
result = func0((int[]){1, 2, 3, 4, 5}, 5, (int[]){1, 2}, 2, &result_size);
assert(result_... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
mov %r8,-0x30(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d1 <func0+0x68>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_30], r8
mov [rbp+var_4], 0
jmp short loc_11D1
loc_118C:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add ra... | _DWORD * func0(long long a1, long long a2, long long a3, int a4, _DWORD *a5)
{
int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a4; ++i )
result_1[i] = *(_DWORD *)(4LL * *(int *)(4LL * i + a3) + a1);
*a5 = a4;
return result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d1
LAB_0010118c:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qwo... | int1 * func0(long param_1,int8 param_2,long param_3,int param_4,int *param_5)
{
int local_c;
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
*(int4 *)(result_1 + (long)local_c * 4) =
*(int4 *)(param_1 + (long)*(int *)(param_3 + (long)local_c * 4) * 4);
}
*param_5 = param_4;
retu... |
7,193 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums[], int num_size, int list_index[], int index_size, int* result_size) {
static int result[100];
for (int i = 0; i < index_size; i++) {
result[i] = nums[list_index[i]];
}
*result_size = index_size;
return result;
}
| int main() {
int result_size;
int *result;
result = func0((int[]){2,3,8,4,7,9}, 6, (int[]){0,3,5}, 3, &result_size);
assert(result_size == 3 && result[0] == 2 && result[1] == 4 && result[2] == 9);
result = func0((int[]){1, 2, 3, 4, 5}, 5, (int[]){1, 2}, 2, &result_size);
assert(result_... | O1 | c | func0:
endbr64
test %ecx,%ecx
jle 1198 <func0+0x2f>
lea -0x1(%rcx),%r10d
mov $0x0,%eax
lea 0x2ebf(%rip),%r9
movslq (%rdx,%rax,4),%rsi
mov (%rdi,%rsi,4),%esi
mov %esi,(%r9,%rax,4)
mov %rax,%rsi
add $0x1,%rax
cmp %r10,%rsi
jne 1181 <func0+0x18>
mov %ecx,(%r8)
lea 0x2e9e(%rip),%rax
re... | func0:
endbr64
test ecx, ecx
jle short loc_1194
mov r10d, ecx
mov eax, 0
lea r9, result_1
loc_1180:
movsxd rsi, dword ptr [rdx+rax*4]
mov esi, [rdi+rsi*4]
mov [r9+rax*4], esi
add rax, 1
cmp rax, r10
jnz short loc_1180
loc_1194:
mov [r8], ecx
lea rax, result_1
retn | _DWORD * func0(long long a1, long long a2, long long a3, int a4, int *a5)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
result_1[i] = *(_DWORD *)(a1 + 4LL * *(int *)(a3 + 4 * i));
}
*a5 = a4;
return result_1;
} | func0:
ENDBR64
TEST ECX,ECX
JLE 0x00101194
MOV R10D,ECX
MOV EAX,0x0
LEA R9,[0x104040]
LAB_00101180:
MOVSXD RSI,dword ptr [RDX + RAX*0x4]
MOV ESI,dword ptr [RDI + RSI*0x4]
MOV dword ptr [R9 + RAX*0x4],ESI
ADD RAX,0x1
CMP RAX,R10
JNZ 0x00101180
LAB_00101194:
MOV dword ptr [R8],ECX
LEA RAX,[0x104040]
RET | int4 * func0(long param_1,int8 param_2,long param_3,uint param_4,uint *param_5)
{
ulong uVar1;
if (0 < (int)param_4) {
uVar1 = 0;
do {
(&result_1)[uVar1] = *(int4 *)(param_1 + (long)*(int *)(param_3 + uVar1 * 4) * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_4);
}
*param_5 = param_... |
7,194 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums[], int num_size, int list_index[], int index_size, int* result_size) {
static int result[100];
for (int i = 0; i < index_size; i++) {
result[i] = nums[list_index[i]];
}
*result_size = index_size;
return result;
}
| int main() {
int result_size;
int *result;
result = func0((int[]){2,3,8,4,7,9}, 6, (int[]){0,3,5}, 3, &result_size);
assert(result_size == 3 && result[0] == 2 && result[1] == 4 && result[2] == 9);
result = func0((int[]){1, 2, 3, 4, 5}, 5, (int[]){1, 2}, 2, &result_size);
assert(result_... | O2 | c | func0:
endbr64
test %ecx,%ecx
jle 117f <func0+0x2f>
lea -0x1(%rcx),%r10d
xor %eax,%eax
lea 0x2edb(%rip),%r9
nopl (%rax)
movslq (%rdx,%rax,4),%rsi
mov (%rdi,%rsi,4),%esi
mov %esi,(%r9,%rax,4)
mov %rax,%rsi
add $0x1,%rax
cmp %r10,%rsi
jne 1168 <func0+0x18>
mov %ecx,(%r8)
lea 0x2eb7... | func0:
endbr64
lea r9, result_1
test ecx, ecx
jle short loc_117C
movsxd r10, ecx
xor eax, eax
nop dword ptr [rax+00h]
loc_1168:
movsxd rsi, dword ptr [rdx+rax*4]
mov esi, [rdi+rsi*4]
mov [r9+rax*4], esi
add rax, 1
cmp r10, rax
jnz short loc_1168
loc_117C:
mov [r8], ecx
mov ... | long long * func0(long long a1, long long a2, long long a3, int a4, int *a5)
{
long long i; // rax
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
*((_DWORD *)&result_1 + i) = *(_DWORD *)(a1 + 4LL * *(int *)(a3 + 4 * i));
}
*a5 = a4;
return &result_1;
} | func0:
ENDBR64
LEA R9,[0x104040]
TEST ECX,ECX
JLE 0x0010117c
MOVSXD R10,ECX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101168:
MOVSXD RSI,dword ptr [RDX + RAX*0x4]
MOV ESI,dword ptr [RDI + RSI*0x4]
MOV dword ptr [R9 + RAX*0x4],ESI
ADD RAX,0x1
CMP R10,RAX
JNZ 0x00101168
LAB_0010117c:
MOV dword ptr [R8],ECX
MOV RAX,R9
RET | int4 * func0(long param_1,int8 param_2,long param_3,int param_4,int *param_5)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
(&result_1)[lVar1] = *(int4 *)(param_1 + (long)*(int *)(param_3 + lVar1 * 4) * 4);
lVar1 = lVar1 + 1;
} while (param_4 != lVar1);
}
*param_5 = param_4;
ret... |
7,195 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums[], int num_size, int list_index[], int index_size, int* result_size) {
static int result[100];
for (int i = 0; i < index_size; i++) {
result[i] = nums[list_index[i]];
}
*result_size = index_size;
return result;
}
| int main() {
int result_size;
int *result;
result = func0((int[]){2,3,8,4,7,9}, 6, (int[]){0,3,5}, 3, &result_size);
assert(result_size == 3 && result[0] == 2 && result[1] == 4 && result[2] == 9);
result = func0((int[]){1, 2, 3, 4, 5}, 5, (int[]){1, 2}, 2, &result_size);
assert(result_... | O3 | c | func0:
endbr64
test %ecx,%ecx
jle 117f <func0+0x2f>
lea -0x1(%rcx),%r10d
xor %eax,%eax
lea 0x2edb(%rip),%r9
nopl (%rax)
movslq (%rdx,%rax,4),%rsi
mov (%rdi,%rsi,4),%esi
mov %esi,(%r9,%rax,4)
mov %rax,%rsi
add $0x1,%rax
cmp %r10,%rsi
jne 1168 <func0+0x18>
mov %ecx,(%r8)
lea 0x2eb7... | func0:
endbr64
lea r10, result_1
test ecx, ecx
jle short loc_1184
movsxd r9, ecx
xor eax, eax
shl r9, 2
nop dword ptr [rax+rax+00000000h]
loc_1170:
movsxd rsi, dword ptr [rdx+rax]
mov esi, [rdi+rsi*4]
mov [r10+rax], esi
add rax, 4
cmp rax, r9
jnz short loc_1170
loc_1184:
mov... | long long * func0(long long a1, long long a2, long long a3, int a4, int *a5)
{
long long v5; // rax
if ( a4 > 0 )
{
v5 = 0LL;
do
{
*(_DWORD *)((char *)&result_1 + v5) = *(_DWORD *)(a1 + 4LL * *(int *)(a3 + v5));
v5 += 4LL;
}
while ( v5 != 4LL * a4 );
}
*a5 = a4;
return &resu... | func0:
ENDBR64
LEA R10,[0x104040]
TEST ECX,ECX
JLE 0x00101184
MOVSXD R9,ECX
XOR EAX,EAX
SHL R9,0x2
NOP dword ptr [RAX + RAX*0x1]
LAB_00101170:
MOVSXD RSI,dword ptr [RDX + RAX*0x1]
MOV ESI,dword ptr [RDI + RSI*0x4]
MOV dword ptr [R10 + RAX*0x1],ESI
ADD RAX,0x4
CMP RAX,R9
JNZ 0x00101170
LAB_00101184:
MOV dword ptr [R8],E... | int4 * func0(long param_1,int8 param_2,long param_3,int param_4,int *param_5)
{
long lVar1;
if (0 < param_4) {
lVar1 = 0;
do {
*(int4 *)((long)&result_1 + lVar1) =
*(int4 *)(param_1 + (long)*(int *)(param_3 + lVar1) * 4);
lVar1 = lVar1 + 4;
} while (lVar1 != (long)param_4 * 4)... |
7,196 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
int sqa = pow(a, 2);
int sqb = pow(b, 2);
int sqc = pow(c, 2);
if (sqa == sqb + sqc || sqb == sqa + sqc || sqc == sqa + sqb) {
return "Right-angled Triangle";
} else if (sqa > sqc + sqb || sqb > sqa + sqc || sqc > sqa + sqb) {
return "Obtus... | int main() {
assert(strcmp(func0(1, 2, 3), "Obtuse-angled Triangle") == 0);
assert(strcmp(func0(2, 2, 2), "Acute-angled Triangle") == 0);
assert(strcmp(func0(1, 0, 1), "Right-angled Triangle") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd 0xf95(%rip),%xmm1
callq 1070 <pow@plt>
cvttsd2si %xmm0,%eax
mov %eax,-0xc(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
movsd 0xf7c(%rip),%xmm1
callq 1070 <p... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_14]
movq rax, xmm2
movsd xmm0, cs:y
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
cvttsd2si eax, xmm0
mov [rbp+var_C], ... | const char * func0(int a1, int a2, int a3)
{
int v5; // [rsp+14h] [rbp-Ch]
int v6; // [rsp+18h] [rbp-8h]
int v7; // [rsp+1Ch] [rbp-4h]
v5 = (int)pow((double)a1, 2.0);
v6 = (int)pow((double)a2, 2.0);
v7 = (int)pow((double)a3, 2.0);
if ( v5 == v6 + v7 || v6 == v5 + v7 || v7 == v5 + v6 )
return "Right-a... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x14]
MOVQ RAX,XMM2
MOVSD XMM0,qword ptr [0x00102120]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101070
CVTTSD2SI EAX,XMM0
MOV dwor... | char * func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
char *pcVar4;
double dVar5;
dVar5 = pow((double)param_1,DAT_00102120);
iVar1 = (int)dVar5;
dVar5 = pow((double)param_2,DAT_00102120);
iVar2 = (int)dVar5;
dVar5 = pow((double)param_3,DAT_00102120);
iVar3 = (int... |
7,197 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
int sqa = pow(a, 2);
int sqb = pow(b, 2);
int sqc = pow(c, 2);
if (sqa == sqb + sqc || sqb == sqa + sqc || sqc == sqa + sqb) {
return "Right-angled Triangle";
} else if (sqa > sqc + sqb || sqb > sqa + sqc || sqc > sqa + sqb) {
return "Obtus... | int main() {
assert(strcmp(func0(1, 2, 3), "Obtuse-angled Triangle") == 0);
assert(strcmp(func0(2, 2, 2), "Acute-angled Triangle") == 0);
assert(strcmp(func0(1, 0, 1), "Right-angled Triangle") == 0);
return 0;
}
| O1 | c | func0:
endbr64
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%edi
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%ecx
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%eax
lea (%rcx,%rax,1),%esi
lea 0xe94(%rip),%rdx
cmp %edi,%esi
j... | func0:
endbr64
mov eax, esi
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
mulsd xmm0, xmm0
cvttsd2si esi, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, xmm0
cvttsd2si ecx, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
mulsd xmm0, xmm0
cvttsd2si edx, xmm0
lea edi, [rcx+rdx]
lea rax, aRightAngledTri; "Rig... | const char * func0(int a1, int a2, int a3)
{
int v4; // esi
int v5; // ecx
int v6; // edx
const char *result; // rax
v4 = (int)((double)a1 * (double)a1);
v5 = (int)((double)a2 * (double)a2);
v6 = (int)((double)a3 * (double)a3);
result = "Right-angled Triangle";
if ( v5 + v6 != v4 && v4 + v6 != v5 && ... | func0:
ENDBR64
MOV EAX,ESI
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MULSD XMM0,XMM0
CVTTSD2SI ESI,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,XMM0
CVTTSD2SI ECX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
MULSD XMM0,XMM0
CVTTSD2SI EDX,XMM0
LEA EDI,[RCX + RDX*0x1]
LEA RAX,[0x102004]
CMP EDI,ESI
JZ 0x001011da
LEA R8D,[RSI + RDX*0... | char * func0(int param_1,int param_2,int param_3)
{
char *pcVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = (int)((double)param_1 * (double)param_1);
iVar2 = (int)((double)param_2 * (double)param_2);
iVar3 = (int)((double)param_3 * (double)param_3);
pcVar1 = "Right-angled Triangle";
if (((iVar2 + i... |
7,198 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
int sqa = pow(a, 2);
int sqb = pow(b, 2);
int sqc = pow(c, 2);
if (sqa == sqb + sqc || sqb == sqa + sqc || sqc == sqa + sqb) {
return "Right-angled Triangle";
} else if (sqa > sqc + sqb || sqb > sqa + sqc || sqc > sqa + sqb) {
return "Obtus... | int main() {
assert(strcmp(func0(1, 2, 3), "Obtuse-angled Triangle") == 0);
assert(strcmp(func0(2, 2, 2), "Acute-angled Triangle") == 0);
assert(strcmp(func0(1, 0, 1), "Right-angled Triangle") == 0);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm0,%xmm0
mov %edx,%r8d
cvtsi2sd %edi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%edx
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%eax
pxor %xmm0,%xmm0
cvtsi2sd %r8d,%xmm0
lea 0xd7d(%rip),%r8
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%ecx
lea (%rax,%rcx,1),%esi
cm... | func0:
endbr64
pxor xmm0, xmm0
mov r8d, edx
cvtsi2sd xmm0, edi
mulsd xmm0, xmm0
cvttsd2si edx, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, esi
mulsd xmm0, xmm0
cvttsd2si eax, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, r8d
lea r8, aRightAngledTri; "Right-angled Triangle"
mulsd xmm0, xmm0
cvttsd2si ecx, xmm0
lea ... | const char * func0(int a1, int a2, int a3)
{
int v4; // edx
int v5; // eax
double v6; // xmm0_8
const char *v7; // r8
int v8; // ecx
v4 = (int)((double)a1 * (double)a1);
v5 = (int)((double)a2 * (double)a2);
v6 = (double)a3;
v7 = "Right-angled Triangle";
v8 = (int)(v6 * v6);
if ( v5 + v8 != v4 && ... | func0:
ENDBR64
PXOR XMM0,XMM0
MOV R8D,EDX
CVTSI2SD XMM0,EDI
MULSD XMM0,XMM0
CVTTSD2SI EDX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,ESI
MULSD XMM0,XMM0
CVTTSD2SI EAX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,R8D
LEA R8,[0x102004]
MULSD XMM0,XMM0
CVTTSD2SI ECX,XMM0
LEA ESI,[RAX + RCX*0x1]
CMP ESI,EDX
JZ 0x001012c4
LEA EDI,[RDX + RCX*0x... | char * func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
char *pcVar4;
iVar3 = (int)((double)param_1 * (double)param_1);
iVar1 = (int)((double)param_2 * (double)param_2);
pcVar4 = "Right-angled Triangle";
iVar2 = (int)((double)param_3 * (double)param_3);
if ((((iVar1 + ... |
7,199 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
int sqa = pow(a, 2);
int sqb = pow(b, 2);
int sqc = pow(c, 2);
if (sqa == sqb + sqc || sqb == sqa + sqc || sqc == sqa + sqb) {
return "Right-angled Triangle";
} else if (sqa > sqc + sqb || sqb > sqa + sqc || sqc > sqa + sqb) {
return "Obtus... | int main() {
assert(strcmp(func0(1, 2, 3), "Obtuse-angled Triangle") == 0);
assert(strcmp(func0(2, 2, 2), "Acute-angled Triangle") == 0);
assert(strcmp(func0(1, 0, 1), "Right-angled Triangle") == 0);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm0,%xmm0
mov %edx,%r8d
cvtsi2sd %edi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%edx
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%eax
pxor %xmm0,%xmm0
cvtsi2sd %r8d,%xmm0
lea 0xd7d(%rip),%r8
mulsd %xmm0,%xmm0
cvttsd2si %xmm0,%ecx
lea (%rax,%rcx,1),%esi
cm... | func0:
endbr64
pxor xmm0, xmm0
mov eax, edx
cvtsi2sd xmm0, edi
mulsd xmm0, xmm0
cvttsd2si ecx, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, esi
lea rsi, aRightAngledTri; "Right-angled Triangle"
mulsd xmm0, xmm0
cvttsd2si edx, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, xmm0
cvttsd2si eax, xmm0
lea... | const char * func0(int a1, int a2, int a3)
{
int v4; // ecx
double v5; // xmm0_8
const char *v6; // rsi
int v7; // edx
int v8; // eax
v4 = (int)((double)a1 * (double)a1);
v5 = (double)a2;
v6 = "Right-angled Triangle";
v7 = (int)(v5 * v5);
v8 = (int)((double)a3 * (double)a3);
if ( v7 + v8 != v4 &&... | func0:
ENDBR64
PXOR XMM0,XMM0
MOV EAX,EDX
CVTSI2SD XMM0,EDI
MULSD XMM0,XMM0
CVTTSD2SI ECX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,ESI
LEA RSI,[0x102004]
MULSD XMM0,XMM0
CVTTSD2SI EDX,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,XMM0
CVTTSD2SI EAX,XMM0
LEA EDI,[RDX + RAX*0x1]
CMP EDI,ECX
JZ 0x001012c8
LEA R8D,[RCX + RAX*0... | char * func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
char *pcVar4;
iVar2 = (int)((double)param_1 * (double)param_1);
pcVar4 = "Right-angled Triangle";
iVar3 = (int)((double)param_2 * (double)param_2);
iVar1 = (int)((double)param_3 * (double)param_3);
if ((((iVar3 + ... |
7,200 | func0 |
#include <assert.h>
| int func0(int list1[][4], int rows, int C) {
int result = 0;
for (int i = 0; i < rows; i++) {
result += list1[i][C];
}
return result;
}
| int main() {
int array1[3][4] = {{1,2,3,2},{4,5,6,2},{7,8,9,5}};
assert(func0(array1, 3, 0) == 12);
assert(func0(array1, 3, 1) == 15);
assert(func0(array1, 3, 3) == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ad <func0+0x44>
mov -0x4(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x20(%rbp),%eax
cltq
m... | 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_8], 0
mov [rbp+var_4], 0
jmp short loc_11AD
loc_118B:
mov eax, [rbp+var_4]
cdqe
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [... | long long func0(long long a1, int a2, int a3)
{
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
v4 += *(_DWORD *)(a1 + 16LL * i + 4LL * a3);
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ad
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD R... | int func0(long param_1,int param_2,int param_3)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 + *(int *)((long)local_c * 0x10 + param_1 + (long)param_3 * 4);
}
return local_10;
} |
7,201 | func0 |
#include <assert.h>
| int func0(int list1[][4], int rows, int C) {
int result = 0;
for (int i = 0; i < rows; i++) {
result += list1[i][C];
}
return result;
}
| int main() {
int array1[3][4] = {{1,2,3,2},{4,5,6,2},{7,8,9,5}};
assert(func0(array1, 3, 0) == 12);
assert(func0(array1, 3, 1) == 15);
assert(func0(array1, 3, 3) == 9);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1197 <func0+0x2e>
movslq %edx,%rdx
lea (%rdi,%rdx,4),%rax
lea -0x1(%rsi),%ecx
lea (%rdx,%rcx,4),%rdx
lea 0x10(%rdi,%rdx,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x10,%rax
cmp %rcx,%rax
jne 1189 <func0+0x20>
mov %edx,%eax
retq
mov $0x0,%edx
jmp ... | func0:
endbr64
test esi, esi
jle short loc_1197
movsxd rdx, edx
lea rax, [rdi+rdx*4]
lea ecx, [rsi-1]
lea rdx, [rdx+rcx*4]
lea rcx, [rdi+rdx*4+10h]
mov edx, 0
loc_1189:
add edx, [rax]
add rax, 10h
cmp rax, rcx
jnz short loc_1189
loc_1194:
mov eax, edx
retn
loc_1197:
mov ... | long long func0(long long a1, int a2, int a3)
{
_DWORD *v3; // rax
long long v4; // rcx
unsigned int v5; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v3 = (_DWORD *)(a1 + 4LL * a3);
v4 = a1 + 4 * (a3 + 4LL * (unsigned int)(a2 - 1)) + 16;
v5 = 0;
do
{
v5 += *v3;
v3 += ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101197
MOVSXD RDX,EDX
LEA RAX,[RDI + RDX*0x4]
LEA ECX,[RSI + -0x1]
LEA RDX,[RDX + RCX*0x4]
LEA RCX,[RDI + RDX*0x4 + 0x10]
MOV EDX,0x0
LAB_00101189:
ADD EDX,dword ptr [RAX]
ADD RAX,0x10
CMP RAX,RCX
JNZ 0x00101189
LAB_00101194:
MOV EAX,EDX
RET
LAB_00101197:
MOV EDX,0x0
JMP 0x00101194 | int func0(long param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = (int *)(param_1 + (long)param_3 * 4);
iVar2 = 0;
do {
iVar2 = iVar2 + *piVar1;
piVar1 = piVar1 + 4;
} while (piVar1 != (int *)(param_1 + 0x10 + ((long)p... |
7,202 | func0 |
#include <assert.h>
| int func0(int list1[][4], int rows, int C) {
int result = 0;
for (int i = 0; i < rows; i++) {
result += list1[i][C];
}
return result;
}
| int main() {
int array1[3][4] = {{1,2,3,2},{4,5,6,2},{7,8,9,5}};
assert(func0(array1, 3, 0) == 12);
assert(func0(array1, 3, 1) == 15);
assert(func0(array1, 3, 3) == 9);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
movslq %edx,%rdx
lea -0x1(%rsi),%ecx
xor %r8d,%r8d
lea (%rdi,%rdx,4),%rax
lea (%rdx,%rcx,4),%rdx
lea 0x10(%rdi,%rdx,4),%rdx
xchg %ax,%ax
add (%rax),%r8d
add $0x10,%rax
cmp %rdx,%rax
jne 1160 <func0+0x20>
mov %r8d,%eax
retq
xor %... | func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rdx, edx
lea ecx, [rsi-1]
xor r8d, r8d
lea rax, [rdi+rdx*4]
lea rdx, [rdx+rcx*4]
lea rdx, [rdi+rdx*4+10h]
xchg ax, ax
loc_1160:
add r8d, [rax]
add rax, 10h
cmp rax, rdx
jnz short loc_1160
mov eax, r8d
retn
loc_1170... | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r8d
_DWORD *v4; // rax
long long v5; // rdx
if ( a2 <= 0 )
return 0LL;
v3 = 0;
v4 = (_DWORD *)(a1 + 4LL * a3);
v5 = a1 + 4 * (a3 + 4LL * (unsigned int)(a2 - 1)) + 16;
do
{
v3 += *v4;
v4 += 4;
}
while ( v4 != (_DWORD ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RDX,EDX
LEA ECX,[RSI + -0x1]
XOR R8D,R8D
LEA RAX,[RDI + RDX*0x4]
LEA RDX,[RDX + RCX*0x4]
LEA RDX,[RDI + RDX*0x4 + 0x10]
NOP
LAB_00101160:
ADD R8D,dword ptr [RAX]
ADD RAX,0x10
CMP RAX,RDX
JNZ 0x00101160
MOV EAX,R8D
RET
LAB_00101170:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(long param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
iVar2 = 0;
piVar1 = (int *)(param_1 + (long)param_3 * 4);
do {
iVar2 = iVar2 + *piVar1;
piVar1 = piVar1 + 4;
} while (piVar1 != (int *)(param_1 + 0x10 + ((long)param_3 + (ulong)(param_2 - 1... |
7,203 | func0 |
#include <assert.h>
| int func0(int list1[][4], int rows, int C) {
int result = 0;
for (int i = 0; i < rows; i++) {
result += list1[i][C];
}
return result;
}
| int main() {
int array1[3][4] = {{1,2,3,2},{4,5,6,2},{7,8,9,5}};
assert(func0(array1, 3, 0) == 12);
assert(func0(array1, 3, 1) == 15);
assert(func0(array1, 3, 3) == 9);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1268 <func0+0x128>
lea -0x1(%rsi),%ecx
cmp $0x7,%ecx
jbe 126b <func0+0x12b>
movslq %edx,%r8
mov %ecx,%edx
pxor %xmm2,%xmm2
shr $0x2,%edx
lea (%rdi,%r8,4),%rax
shl $0x6,%rdx
add %rax,%rdx
movdqu (%rax),%xmm0
movdqu 0x10(%rax),%xmm3
add $0x40,%rax
movdqu... | func0:
endbr64
mov r8, rdi
mov edi, esi
test esi, esi
jle loc_1200
lea esi, [rsi-1]
cmp esi, 3
jbe loc_1203
mov ecx, esi
movsxd rdx, edx
pxor xmm1, xmm1
shr ecx, 2
lea rax, [r8+rdx*4]
shl rcx, 6
add rcx, rax
nop dword ptr [rax+00h]
loc_1178:
movdqu xmm0, xmmword p... | long long func0(long long a1, int a2, long long a3)
{
unsigned int v5; // esi
__m128i v6; // xmm1
const __m128i *v7; // rax
const __m128i *v8; // rcx
__m128 v9; // xmm0
__m128 v10; // xmm3
signed int v11; // ecx
__m128i v12; // xmm1
int v13; // eax
_DWORD *v14; // rdx
long long result; // rax
... | func0:
ENDBR64
MOV R8,RDI
MOV EDI,ESI
TEST ESI,ESI
JLE 0x00101200
LEA ESI,[RSI + -0x1]
CMP ESI,0x3
JBE 0x00101203
MOV ECX,ESI
MOVSXD RDX,EDX
PXOR XMM1,XMM1
SHR ECX,0x2
LEA RAX,[R8 + RDX*0x4]
SHL RCX,0x6
ADD RCX,RAX
NOP dword ptr [RAX]
LAB_00101178:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQU XMM3,xmmword ptr [RAX + 0x10]
ADD ... | int func0(long param_1,int param_2,int param_3)
{
int *piVar1;
int *piVar2;
int *piVar3;
uint uVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
if (param_2 < 1) {
iVar5 = 0;
}
else {
uVar4 = param_2 - 1;
if (uVar4 < 4) {
uVar4 = 0;
iVar5 = 0;
}
else {
iVa... |
7,204 | func0 | #include <assert.h>
#include <ctype.h>
| void func0(const char* string, int* alphabets, int* digits, int* special) {
*alphabets = *digits = *special = 0;
for (int i = 0; string[i] != '\0'; i++) {
if (isalpha(string[i]))
(*alphabets)++;
else if (isdigit(string[i]))
(*digits)++;
else
(*... | int main() {
int alphabets, digits, special;
func0("abc!@#123", &alphabets, &digits, &special);
assert(alphabets == 3 && digits == 3 && special == 3);
func0("dgsuy@#$%&1255", &alphabets, &digits, &special);
assert(alphabets == 5 && digits == 4 && special == 5);
func0("fjdsif627348#%$... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
mov -0x30(%rbp),%rax
movl $0x0,(%rax)
mov -0x30(%rbp),%rax
mov (%rax),%edx
mov -0x28(%rbp),%rax
mov %edx,(%rax)
mov -0x28(%rbp),%rax
mov (%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov rax, [rbp+var_30]
mov dword ptr [rax], 0
mov rax, [rbp+var_30]
mov edx, [rax]
mov rax, [rbp+var_28]
mov [rax], edx
mov rax,... | long long func0(long long a1, _DWORD *a2, _DWORD *a3, _DWORD *a4)
{
long long result; // rax
int i; // [rsp+2Ch] [rbp-4h]
*a4 = 0;
*a3 = *a4;
*a2 = *a3;
for ( i = 0; ; ++i )
{
result = *(unsigned __int8 *)(i + a1);
if ( !(_BYTE)result )
break;
if ( ((*__ctype_b_loc())[*(char *)(i + a1)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]... | void func0(long param_1,int *param_2,int *param_3,int *param_4)
{
ushort **ppuVar1;
int local_c;
*param_4 = 0;
*param_3 = *param_4;
*param_2 = *param_3;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[*(char *)(param_1 +... |
7,205 | func0 | #include <assert.h>
#include <ctype.h>
| void func0(const char* string, int* alphabets, int* digits, int* special) {
*alphabets = *digits = *special = 0;
for (int i = 0; string[i] != '\0'; i++) {
if (isalpha(string[i]))
(*alphabets)++;
else if (isdigit(string[i]))
(*digits)++;
else
(*... | int main() {
int alphabets, digits, special;
func0("abc!@#123", &alphabets, &digits, &special);
assert(alphabets == 3 && digits == 3 && special == 3);
func0("dgsuy@#$%&1255", &alphabets, &digits, &special);
assert(alphabets == 5 && digits == 4 && special == 5);
func0("fjdsif627348#%$... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
movl $0x0,(%rcx)
movl $0x0,(%rdx)
movl $0x0,(%rsi)
movzbl (%rdi),%ebx
test %bl,%bl
je 11f8 <func0+0x6f>
mov %rdi,%rbp
mov %rsi,%r12
mov %rdx,%r13
mov %rcx,%r14
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
jmp ... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov dword ptr [rcx], 0
mov dword ptr [rdx], 0
mov dword ptr [rsi], 0
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_11F8
mov rbp, rdi
mov r12, rsi
mov r13, rdx
mov r14, rcx
call ___ctype_b_loc
lea ... | void func0(char *a1, _DWORD *a2, _DWORD *a3, _DWORD *a4)
{
char v4; // bl
_QWORD *v7; // rax
char *v8; // rdx
__int16 v9; // cx
*a4 = 0;
*a3 = 0;
*a2 = 0;
v4 = *a1;
if ( *a1 )
{
v7 = (_QWORD *)__ctype_b_loc();
v8 = a1 + 1;
do
{
v9 = *(_WORD *)(*v7 + 2LL * v4);
if ( (v9 ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV dword ptr [RCX],0x0
MOV dword ptr [RDX],0x0
MOV dword ptr [RSI],0x0
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001011f8
MOV RBP,RDI
MOV R12,RSI
MOV R13,RDX
MOV R14,RCX
CALL 0x00101090
LEA RDX,[RBP + 0x1]
JMP 0x001011db
LAB_001011c5:
TEST CH,0x8
JZ 0x001011f2... | void func0(char *param_1,int *param_2,int *param_3,int *param_4)
{
ushort **ppuVar1;
char *pcVar2;
char cVar3;
*param_4 = 0;
*param_3 = 0;
*param_2 = 0;
cVar3 = *param_1;
if (cVar3 != '\0') {
ppuVar1 = __ctype_b_loc();
pcVar2 = param_1 + 1;
do {
if (((*ppuVar1)[cVar3] & 0x400) == 0... |
7,206 | func0 | #include <assert.h>
#include <ctype.h>
| void func0(const char* string, int* alphabets, int* digits, int* special) {
*alphabets = *digits = *special = 0;
for (int i = 0; string[i] != '\0'; i++) {
if (isalpha(string[i]))
(*alphabets)++;
else if (isdigit(string[i]))
(*digits)++;
else
(*... | int main() {
int alphabets, digits, special;
func0("abc!@#123", &alphabets, &digits, &special);
assert(alphabets == 3 && digits == 3 && special == 3);
func0("dgsuy@#$%&1255", &alphabets, &digits, &special);
assert(alphabets == 5 && digits == 4 && special == 5);
func0("fjdsif627348#%$... | O2 | c | func0:
endbr64
push %r14
movl $0x0,(%rcx)
push %r13
movl $0x0,(%rdx)
push %r12
push %rbp
push %rbx
movl $0x0,(%rsi)
movsbq (%rdi),%rbx
test %bl,%bl
je 1341 <func0+0x71>
mov %rdi,%rbp
mov %rsi,%r12
mov %rdx,%r13
mov %rcx,%r14
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
mov ... | func0:
endbr64
push r14
mov dword ptr [rcx], 0
push r13
mov dword ptr [rdx], 0
push r12
push rbp
push rbx
mov dword ptr [rsi], 0
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1341
mov rbp, rdi
mov r12, rsi
mov r13, rdx
mov r14, rcx
call ___ctype_b_loc
lea ... | void func0(char *a1, _DWORD *a2, _DWORD *a3, _DWORD *a4)
{
long long v4; // rbx
char *v8; // rdi
long long v9; // rsi
__int16 v10; // ax
*a4 = 0;
*a3 = 0;
*a2 = 0;
v4 = *a1;
if ( (_BYTE)v4 )
{
v8 = a1 + 1;
v9 = *(_QWORD *)__ctype_b_loc();
do
{
while ( 1 )
{
v10 ... | func0:
ENDBR64
PUSH R14
MOV dword ptr [RCX],0x0
PUSH R13
MOV dword ptr [RDX],0x0
PUSH R12
PUSH RBP
PUSH RBX
MOV dword ptr [RSI],0x0
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101341
MOV RBP,RDI
MOV R12,RSI
MOV R13,RDX
MOV R14,RCX
CALL 0x00101090
LEA RDI,[RBP + 0x1]
MOV RSI,qword ptr [RAX]
JMP 0x00101321
LAB_00101310:
A... | void func0(char *param_1,int *param_2,int *param_3,int *param_4)
{
char cVar1;
ushort *puVar2;
ushort **ppuVar3;
long lVar4;
char *pcVar5;
*param_4 = 0;
*param_3 = 0;
*param_2 = 0;
lVar4 = (long)*param_1;
if (*param_1 != '\0') {
ppuVar3 = __ctype_b_loc();
puVar2 = *ppuVar3;
pcVar5 = ... |
7,207 | func0 | #include <assert.h>
#include <ctype.h>
| void func0(const char* string, int* alphabets, int* digits, int* special) {
*alphabets = *digits = *special = 0;
for (int i = 0; string[i] != '\0'; i++) {
if (isalpha(string[i]))
(*alphabets)++;
else if (isdigit(string[i]))
(*digits)++;
else
(*... | int main() {
int alphabets, digits, special;
func0("abc!@#123", &alphabets, &digits, &special);
assert(alphabets == 3 && digits == 3 && special == 3);
func0("dgsuy@#$%&1255", &alphabets, &digits, &special);
assert(alphabets == 5 && digits == 4 && special == 5);
func0("fjdsif627348#%$... | O3 | c | func0:
endbr64
push %r14
movl $0x0,(%rcx)
push %r13
movl $0x0,(%rdx)
push %r12
push %rbp
push %rbx
movl $0x0,(%rsi)
movsbq (%rdi),%rbx
test %bl,%bl
je 1341 <func0+0x71>
mov %rdi,%rbp
mov %rsi,%r12
mov %rdx,%r13
mov %rcx,%r14
callq 1090 <__ctype_b_loc@plt>
lea 0x1(%rbp),%rdi
mov ... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov dword ptr [rcx], 0
mov dword ptr [rdx], 0
mov dword ptr [rsi], 0
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1341
mov rbp, rdi
mov r12, rsi
mov r13, rdx
mov r14, rcx
call ___ctype_b_loc
lea ... | void func0(char *a1, _DWORD *a2, _DWORD *a3, _DWORD *a4)
{
long long v4; // rbx
char *v8; // rdi
const unsigned __int16 *v9; // rsi
unsigned __int16 v10; // ax
*a4 = 0;
*a3 = 0;
*a2 = 0;
v4 = *a1;
if ( (_BYTE)v4 )
{
v8 = a1 + 1;
v9 = *__ctype_b_loc();
do
{
while ( 1 )
{... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV dword ptr [RCX],0x0
MOV dword ptr [RDX],0x0
MOV dword ptr [RSI],0x0
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101341
MOV RBP,RDI
MOV R12,RSI
MOV R13,RDX
MOV R14,RCX
CALL 0x00101090
LEA RDI,[RBP + 0x1]
MOV RSI,qword ptr [RAX]
JMP 0x00101321
LAB_00101310:
A... | void func0(char *param_1,int *param_2,int *param_3,int *param_4)
{
char cVar1;
ushort *puVar2;
ushort **ppuVar3;
long lVar4;
char *pcVar5;
*param_4 = 0;
*param_3 = 0;
*param_2 = 0;
lVar4 = (long)*param_1;
if (*param_1 != '\0') {
ppuVar3 = __ctype_b_loc();
puVar2 = *ppuVar3;
pcVar5 = ... |
7,208 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(char* input[], int size) {
int count[100] = {0};
char* unique[100];
int unique_count = 0;
for(int i = 0; i < size; i++) {
int found = 0;
for(int j = 0; j < unique_count; j++) {
if(strcmp(input[i], unique[j]) == 0) {
count[j]++;
... | int main() {
char* arr1[] = {"aaa","bbb","ccc","bbb","aaa","aaa"};
assert(strcmp(func0(arr1, 6), "bbb") == 0);
char* arr2[] = {"abc","bcd","abc","bcd","bcd","bcd"};
assert(strcmp(func0(arr2, 6), "abc") == 0);
char* arr3[] = {"cdma","gsm","hspa","gsm","cdma","cdma"};
assert(strcmp(func0... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x4f0,%rsp
mov %rdi,-0x4e8(%rbp)
mov %esi,-0x4ec(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x4c0(%rbp),%rdx
mov $0x0,%eax
mov $0x32,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x4e0(%rbp)
movl $0x0,-0x4dc(... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 4F0h
mov [rbp+var_4E8], rdi
mov [rbp+var_4EC], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_4C0]
mov eax, 0
mov ecx, 32h ; '2'
mov rdi, rdx
rep stosq
mov [rbp+var_4E0], 0
mov [rbp+var_4DC], 0
... | char * func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-4E0h]
int i; // [rsp+14h] [rbp-4DCh]
int v5; // [rsp+18h] [rbp-4D8h]
int j; // [rsp+1Ch] [rbp-4D4h]
int v7; // [rsp+20h] [rbp-4D0h]
int v8; // [rsp+24h] [rbp-4CCh]
int k; // [rsp+28h] [rbp-4C8h]
int m; // [rsp+2Ch] [rbp-4C4h]
_DWORD v11[10... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x4f0
MOV qword ptr [RBP + -0x4e8],RDI
MOV dword ptr [RBP + -0x4ec],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x4c0]
MOV EAX,0x0
MOV ECX,0x32
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x4e0],0x0
MOV dword ptr [RBP + -0x4d... | int8 func0(long param_1,int param_2)
{
bool bVar1;
int iVar2;
int8 uVar3;
long lVar4;
int *piVar5;
long in_FS_OFFSET;
int local_4e8;
int local_4e4;
int local_4dc;
int local_4d8;
int local_4d4;
int local_4d0;
int local_4cc;
int local_4c8 [100];
int8 auStack_338 [101];
long local_10;
... |
7,209 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(char* input[], int size) {
int count[100] = {0};
char* unique[100];
int unique_count = 0;
for(int i = 0; i < size; i++) {
int found = 0;
for(int j = 0; j < unique_count; j++) {
if(strcmp(input[i], unique[j]) == 0) {
count[j]++;
... | int main() {
char* arr1[] = {"aaa","bbb","ccc","bbb","aaa","aaa"};
assert(strcmp(func0(arr1, 6), "bbb") == 0);
char* arr2[] = {"abc","bcd","abc","bcd","bcd","bcd"};
assert(strcmp(func0(arr2, 6), "abc") == 0);
char* arr3[] = {"cdma","gsm","hspa","gsm","cdma","cdma"};
assert(strcmp(func0... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x4d8,%rsp
mov %rdi,%rdx
mov %fs:0x28,%rax
mov %rax,0x4c8(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rdi
mov $0x32,%ecx
rep stos %rax,%es:(%rdi)
test %esi,%esi
jle 12d6 <func0+0x14d>
mov %rdx,%r14
lea -0... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 4D8h
mov rdx, rdi
mov rax, fs:28h
mov [rsp+508h+var_40], rax
xor eax, eax
lea rdi, [rsp+508h+var_4F8]
mov ecx, 32h ; '2'
rep stosq
test esi, esi
jle loc_12D9
mov r14, rdx
lea eax, [... | long long func0(_QWORD *a1, int a2)
{
_QWORD *v2; // r14
int v3; // r15d
long long v4; // r12
long long v5; // rbx
int *v6; // rcx
int v7; // edx
int v8; // esi
int v9; // eax
int v10; // r9d
long long v11; // rax
_DWORD v13[302]; // [rsp+10h] [rbp-4F8h] BYREF
unsigned long long v14; // [rsp+4C... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x4d8
MOV RDX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x4c8],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x10]
MOV ECX,0x32
STOSQ.REP RDI
TEST ESI,ESI
JLE 0x001012d9
MOV R14,RDX
LEA EAX,[RSI + -0x1]
LEA RAX,[RDX + RAX*0x8 + 0x8]
MOV qword ptr ... | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
char *__s1;
int iVar3;
int8 uVar4;
long lVar5;
int *piVar6;
int iVar7;
int iVar8;
ulong uVar9;
int iVar10;
uint uVar11;
long in_FS_OFFSET;
int local_4f8 [100];
int8 auStack_368 [101];
long local_40;
local_40 = *(long ... |
7,210 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(char* input[], int size) {
int count[100] = {0};
char* unique[100];
int unique_count = 0;
for(int i = 0; i < size; i++) {
int found = 0;
for(int j = 0; j < unique_count; j++) {
if(strcmp(input[i], unique[j]) == 0) {
count[j]++;
... | int main() {
char* arr1[] = {"aaa","bbb","ccc","bbb","aaa","aaa"};
assert(strcmp(func0(arr1, 6), "bbb") == 0);
char* arr2[] = {"abc","bcd","abc","bcd","bcd","bcd"};
assert(strcmp(func0(arr2, 6), "abc") == 0);
char* arr3[] = {"cdma","gsm","hspa","gsm","cdma","cdma"};
assert(strcmp(func0... | O2 | c | func0:
endbr64
push %r15
mov $0x32,%ecx
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x4e8,%rsp
mov %fs:0x28,%rax
mov %rax,0x4d8(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rdi
mov %rdi,0x10(%rsp)
rep stos %rax,%es:(%rdi)
test %esi,%esi
jle 148c <func0+0x14c>
lea... | func0:
endbr64
push r15
mov ecx, 32h ; '2'
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 4E8h
mov rax, fs:28h
mov [rsp+518h+var_40], rax
xor eax, eax
lea rdi, [rsp+518h+var_4F8]
mov [rsp+518h+var_508], rdi
rep stosq
test esi, esi
jle loc_1472... | long long func0(long long *a1, int a2)
{
long long *v2; // r13
long long v3; // rbp
long long v4; // r12
long long v5; // r14
int *v6; // rax
int v7; // esi
int v8; // ecx
int *v9; // rdi
int v10; // edx
long long v11; // rax
int v13; // [rsp+Ch] [rbp-50Ch]
_DWORD v14[302]; // [rsp+20h] [rbp-4F... | func0:
ENDBR64
PUSH R15
MOV ECX,0x32
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x4e8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x4d8],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RDI
STOSQ.REP RDI
TEST ESI,ESI
JLE 0x00101472
LEA EAX,[RSI + -0x1]
MOV dword ptr [RSP + 0xc]... | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
char *__s1;
int iVar3;
int *piVar4;
ulong uVar5;
int8 uVar6;
long lVar7;
int iVar8;
long lVar9;
long in_FS_OFFSET;
uint local_50c;
int local_4f8 [100];
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFF... |
7,211 | func0 |
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
| char* func0(char* input[], int size) {
int count[100] = {0};
char* unique[100];
int unique_count = 0;
for(int i = 0; i < size; i++) {
int found = 0;
for(int j = 0; j < unique_count; j++) {
if(strcmp(input[i], unique[j]) == 0) {
count[j]++;
... | int main() {
char* arr1[] = {"aaa","bbb","ccc","bbb","aaa","aaa"};
assert(strcmp(func0(arr1, 6), "bbb") == 0);
char* arr2[] = {"abc","bcd","abc","bcd","bcd","bcd"};
assert(strcmp(func0(arr2, 6), "abc") == 0);
char* arr3[] = {"cdma","gsm","hspa","gsm","cdma","cdma"};
assert(strcmp(func0... | O3 | c | func0:
endbr64
push %r15
mov $0x32,%ecx
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x4e8,%rsp
mov %fs:0x28,%rax
mov %rax,0x4d8(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rdi
mov %rdi,0x10(%rsp)
rep stos %rax,%es:(%rdi)
test %esi,%esi
jle 14b4 <func0+0x154>
lea... | func0:
endbr64
push r15
mov ecx, 32h ; '2'
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 4D8h
mov rax, fs:28h
mov [rsp+508h+var_40], rax
xor eax, eax
lea rdi, [rsp+508h+var_4F8]
mov [rsp+508h+var_508], rdi
rep stosq
test esi, esi
jle loc_14DE... | long long func0(const char **a1, int a2)
{
const char **v2; // r12
int v3; // r13d
const char *v4; // rbx
long long v5; // rbp
long long v6; // r14
int v7; // esi
int *v8; // rax
int *v9; // rdi
int v10; // ecx
int v11; // edx
long long v12; // rax
const char **v14; // [rsp+8h] [rbp-500h]
_DW... | func0:
ENDBR64
PUSH R15
MOV ECX,0x32
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x4d8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x4c8],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x10]
MOV qword ptr [RSP],RDI
STOSQ.REP RDI
TEST ESI,ESI
JLE 0x001014de
MOVSXD RSI,ESI
XOR R13D,R13D
LEA RAX,[R12 + RSI*0x8]
... | int8 func0(int8 *param_1,int param_2)
{
int8 *puVar1;
int iVar2;
int iVar3;
int *piVar4;
int8 uVar5;
long lVar6;
char *__s1;
int iVar7;
int *piVar8;
int iVar9;
long lVar10;
long in_FS_OFFSET;
int local_4f8 [100];
int8 local_368 [101];
long local_40;
local_40 = *(long *)(in_FS_OFFSET ... |
7,212 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double a, int digits) {
double n = pow(10, -digits);
return round(ceil(a / n) * n * pow(10, digits)) / pow(10, digits);
}
| int main() {
assert(func0(123.01247,0) == 124);
assert(func0(123.01247,1) == 123.1);
assert(func0(123.01247,2) == 123.02);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
movsd %xmm0,-0x18(%rbp)
mov %edi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
neg %eax
cvtsi2sd %eax,%xmm0
mov 0xed3(%rip),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1090 <pow@plt>
movq %xmm0,%rax
mov %rax,-0x8(%rbp)
movsd -0x18(%rbp),%xmm0
divs... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
movsd [rbp+var_28], xmm0
mov [rbp+var_2C], edi
mov eax, [rbp+var_2C]
neg eax
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mov rax, cs:x
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movq rax, xmm0
mov [rbp+var_18], rax
... | __int128 __usercall func0@<xmm0>(int a1@<edi>, double a2@<xmm0>)
{
double v2; // xmm0_8
double v3; // rbx
__int128 v4; // xmm1
double v6; // [rsp+8h] [rbp-38h]
double v8; // [rsp+28h] [rbp-18h]
v8 = pow(10.0, (double)-a1);
v6 = ceil(a2 / v8) * v8;
v2 = pow(10.0, (double)a1);
v3 = round(v2 * v6);
v4... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOVSD qword ptr [RBP + -0x28],XMM0
MOV dword ptr [RBP + -0x2c],EDI
MOV EAX,dword ptr [RBP + -0x2c]
NEG EAX
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOV RAX,qword ptr [0x00102080]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101090
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x18],RA... | double func0(double param_1,int param_2)
{
double dVar1;
double dVar2;
double dVar3;
dVar1 = pow(DAT_00102080,(double)-param_2);
dVar2 = ceil(param_1 / dVar1);
dVar3 = pow(DAT_00102080,(double)param_2);
dVar1 = round(dVar3 * dVar2 * dVar1);
dVar2 = pow(DAT_00102080,(double)param_2);
return dVar1 /... |
7,213 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double a, int digits) {
double n = pow(10, -digits);
return round(ceil(a / n) * n * pow(10, digits)) / pow(10, digits);
}
| int main() {
assert(func0(123.01247,0) == 124);
assert(func0(123.01247,1) == 123.1);
assert(func0(123.01247,2) == 123.02);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
sub $0x20,%rsp
movsd %xmm0,0x8(%rsp)
mov %edi,%ebx
mov %edi,%eax
neg %eax
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd 0xef2(%rip),%xmm0
callq 1080 <pow@plt>
movsd %xmm0,0x18(%rsp)
movsd 0x8(%rsp),%xmm1
divsd %xmm0,%xmm1
movsd %xmm1,0x8(%rsp)
movsd 0xf0f(%rip),%xmm0
movapd... | func0:
endbr64
push rbp
push rbx
sub rsp, 18h
movq rbx, xmm0
mov ebp, edi
mov eax, edi
neg eax
pxor xmm1, xmm1
cvtsi2sd xmm1, eax
movsd xmm0, cs:qword_2080
call _pow
movsd [rsp+28h+var_20], xmm0
movq xmm5, rbx
divsd xmm5, xmm0
movq rbx, xmm5
movsd xmm2, cs:qword_20C0
movapd ... | double func0(int a1, double a2)
{
__m128d v3; // xmm5
double v4; // rbx
__m128d v5; // xmm1
double v6; // xmm0_8
double v7; // rbx
double v9; // [rsp+8h] [rbp-20h]
v9 = pow(10.0, (double)-a1);
v3 = (__m128d)*(unsigned long long *)&a2;
v4 = a2 / v9;
v3.m128d_f64[0] = v4;
if ( fabs(v4) < 4.5035996... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOVQ RBX,XMM0
MOV EBP,EDI
MOV EAX,EDI
NEG EAX
PXOR XMM1,XMM1
CVTSI2SD XMM1,EAX
MOVSD XMM0,qword ptr [0x00102080]
CALL 0x00101080
MOVSD qword ptr [RSP + 0x8],XMM0
MOVQ XMM5,RBX
DIVSD XMM5,XMM0
MOVQ RBX,XMM5
MOVSD XMM2,qword ptr [0x001020c0]
MOVAPD XMM1,XMM5
ANDPD XMM1,XMM2
M... | double func0(double param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow(DAT_00102080,(double)-param_2);
param_1 = param_1 / dVar1;
if ((double)((ulong)param_1 & DAT_001020c0) < DAT_00102088) {
param_1 = (double)((ulong)((double)(long)param_1 +
(double)(-(ulong)... |
7,214 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double a, int digits) {
double n = pow(10, -digits);
return round(ceil(a / n) * n * pow(10, digits)) / pow(10, digits);
}
| int main() {
assert(func0(123.01247,0) == 124);
assert(func0(123.01247,1) == 123.1);
assert(func0(123.01247,2) == 123.02);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %edi,%eax
pxor %xmm1,%xmm1
mov %edi,%ebx
neg %eax
cvtsi2sd %eax,%xmm1
sub $0x20,%rsp
movsd 0xe21(%rip),%xmm4
movsd %xmm0,0x8(%rsp)
movapd %xmm4,%xmm0
callq 1080 <pow@plt>
movsd 0x8(%rsp),%xmm2
movsd 0xe0c(%rip),%xmm5
movapd %xmm0,%xmm3
mov 0xdf9(%rip),%rax
divsd %xm... | func0:
endbr64
push rbx
mov eax, edi
pxor xmm1, xmm1
mov ebx, edi
neg eax
cvtsi2sd xmm1, eax
sub rsp, 20h
movsd xmm4, cs:qword_2080
movsd [rsp+28h+var_20], xmm0
movapd xmm0, xmm4
call _pow
movsd xmm2, [rsp+28h+var_20]
movsd xmm1, cs:qword_20C0
movsd xmm5, cs:qword_2088
movapd xmm3, ... | __int128 __usercall func0@<xmm0>(int a1@<edi>, double a2@<xmm0>)
{
double v2; // xmm3_8
__m128d v3; // xmm2
__m128d v4; // xmm0
double v5; // xmm0_8
__int128 v6; // xmm2
double v9; // [rsp+0h] [rbp-20h]
v3 = (__m128d)*(unsigned long long *)&a2;
v2 = pow(10.0, (double)-a1);
v3.m128d_f64[0] = a2 / v2;
... | func0:
ENDBR64
PUSH RBX
MOV EAX,EDI
PXOR XMM1,XMM1
MOV EBX,EDI
NEG EAX
CVTSI2SD XMM1,EAX
SUB RSP,0x20
MOVSD XMM4,qword ptr [0x00102080]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVAPD XMM0,XMM4
CALL 0x00101080
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [0x001020c0]
MOVSD XMM5,qword ptr [0x00102088]
MOVAPD XMM3,XMM0
... | double func0(double param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow(DAT_00102080,(double)-param_2);
param_1 = param_1 / dVar1;
if ((double)((ulong)param_1 & DAT_001020c0) < DAT_00102088) {
param_1 = (double)((ulong)((double)(long)param_1 +
(double)(-(ulong)... |
7,215 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double a, int digits) {
double n = pow(10, -digits);
return round(ceil(a / n) * n * pow(10, digits)) / pow(10, digits);
}
| int main() {
assert(func0(123.01247,0) == 124);
assert(func0(123.01247,1) == 123.1);
assert(func0(123.01247,2) == 123.02);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %edi,%eax
pxor %xmm1,%xmm1
mov %edi,%ebx
neg %eax
cvtsi2sd %eax,%xmm1
sub $0x20,%rsp
movsd 0xe21(%rip),%xmm4
movsd %xmm0,0x8(%rsp)
movapd %xmm4,%xmm0
callq 1080 <pow@plt>
movsd 0x8(%rsp),%xmm2
movsd 0xe0c(%rip),%xmm5
movapd %xmm0,%xmm3
mov 0xdf9(%rip),%rax
divsd %xm... | func0:
endbr64
push rbx
mov eax, edi
pxor xmm1, xmm1
mov ebx, edi
neg eax
cvtsi2sd xmm1, eax; y
sub rsp, 20h
movsd [rsp+28h+var_20], xmm0
movsd xmm0, cs:x; x
call _pow
movsd xmm2, [rsp+28h+var_20]
movsd xmm1, cs:qword_2098
movsd xmm4, cs:qword_2088
movapd xmm3, xmm0
divsd xmm2, xmm... | __int128 __usercall func0@<xmm0>(int a1@<edi>, double a2@<xmm0>)
{
double v2; // xmm3_8
__m128d v3; // xmm2
__m128d v4; // xmm0
double v5; // xmm0_8
__int128 v6; // xmm2
double v9; // [rsp+0h] [rbp-20h]
v3 = (__m128d)*(unsigned long long *)&a2;
v2 = pow(10.0, (double)-a1);
v3.m128d_f64[0] = a2 / v2;
... | func0:
ENDBR64
PUSH RBX
MOV EAX,EDI
PXOR XMM1,XMM1
MOV EBX,EDI
NEG EAX
CVTSI2SD XMM1,EAX
SUB RSP,0x20
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD XMM0,qword ptr [0x00102080]
CALL 0x00101080
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [0x00102098]
MOVSD XMM4,qword ptr [0x00102088]
MOVAPD XMM3,XMM0
DIVSD XMM2,XMM0
M... | double func0(double param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow(DAT_00102080,(double)-param_2);
param_1 = param_1 / dVar1;
if ((double)((ulong)param_1 & DAT_00102098) < DAT_00102088) {
param_1 = (double)((ulong)((double)(long)param_1 +
(double)(-(ulong)... |
7,216 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] == arr[j]) {
cnt++;
}
}
}
return cnt;
}
| int main() {
int arr1[] = {1, 1, 1, 1};
int arr2[] = {1, 5, 1};
int arr3[] = {3, 2, 1, 7, 8, 9};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 6) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d7 <func0+0x6e>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11cb <func0+0x62>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11D7
loc_1188:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11CB
loc_1193:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * j + a1) )
++v3;
}
}... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d7
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011cb
LAB_00101193:
MOV EAX,dword ptr [RBP + -... | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_c = local_10, local_10 < param_2; local_10 = local_10 + 1) {
while (local_c = local_c + 1, local_c < param_2) {
if (*(int *)(param_1 + (long)local_10 * 4) == *(int *)(param_1 ... |
7,217 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] == arr[j]) {
cnt++;
}
}
}
return cnt;
}
| int main() {
int arr1[] = {1, 1, 1, 1};
int arr2[] = {1, 5, 1};
int arr3[] = {3, 2, 1, 7, 8, 9};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 6) == 0);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ab <func0+0x42>
lea -0x1(%rsi),%r9d
add $0x1,%r9
mov $0x1,%r8d
mov $0x0,%ecx
jmp 119c <func0+0x33>
add $0x1,%rax
cmp %eax,%esi
jle 1198 <func0+0x2f>
cmp (%rdi,%rax,4),%edx
jne 1186 <func0+0x1d>
add $0x1,%ecx
jmp 1186 <func0+0x1d>
add $0x1,%... | func0:
endbr64
test esi, esi
jle short loc_11A6
mov r9d, esi
mov r8d, 1
mov ecx, 0
jmp short loc_1197
loc_1181:
add rax, 1
cmp esi, eax
jle short loc_1193
loc_1189:
cmp edx, [rdi+rax*4]
jnz short loc_1181
add ecx, 1
jmp short loc_1181
loc_1193:
add r8, 1
loc_1197:
... | long long func0(long long a1, int a2)
{
long long v2; // r8
unsigned int v3; // ecx
long long v4; // rax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = 1LL;
v3 = 0;
while ( v2 != a2 )
{
v4 = v2;
do
{
if ( *(_DWORD *)(a1 + 4 * v2 - 4) == *(_DWORD *)(a1 + 4 * v4) ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a6
MOV R9D,ESI
MOV R8D,0x1
MOV ECX,0x0
JMP 0x00101197
LAB_00101181:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101193
LAB_00101189:
CMP EDX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101181
ADD ECX,0x1
JMP 0x00101181
LAB_00101193:
ADD R8,0x1
LAB_00101197:
CMP R8,R9
JZ 0x001011ab
MOV EDX,dword ptr [R... | int func0(long param_1,uint param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
if ((int)param_2 < 1) {
iVar2 = 0;
}
else {
iVar2 = 0;
for (uVar3 = 1; uVar3 != param_2; uVar3 = uVar3 + 1) {
uVar1 = uVar3;
do {
if (*(int *)(param_1 + -4 + uVar3 * 4) == *(int *)(param_1 + uVar1... |
7,218 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] == arr[j]) {
cnt++;
}
}
}
return cnt;
}
| int main() {
int arr1[] = {1, 1, 1, 1};
int arr2[] = {1, 5, 1};
int arr3[] = {3, 2, 1, 7, 8, 9};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 6) == 0);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 137e <func0+0x4e>
lea -0x1(%rsi),%r9d
mov $0x1,%ecx
xor %r8d,%r8d
add $0x1,%r9
cmp %r9,%rcx
je 137a <func0+0x4a>
nopl (%rax)
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
nopw 0x0(%rax,%rax,1)
cmp (%rdi,%rax,4),%edx
jne 1369 <func0+0x39>
add $0x1,%... | func0:
endbr64
test esi, esi
jle short loc_12EE
movsxd r9, esi
mov ecx, 1
xor r8d, r8d
cmp rcx, r9
jz short loc_12EA
nop dword ptr [rax+rax+00000000h]
loc_12C0:
mov edx, [rdi+rcx*4-4]
mov rax, rcx
nop word ptr [rax+rax+00000000h]
loc_12D0:
cmp edx, [rdi+rax*4]
jnz short ... | long long func0(long long a1, int a2)
{
long long v2; // rcx
unsigned int i; // r8d
long long v4; // rax
if ( a2 <= 0 )
return 0LL;
v2 = 1LL;
for ( i = 0; v2 != a2; ++v2 )
{
v4 = v2;
do
{
if ( *(_DWORD *)(a1 + 4 * v2 - 4) == *(_DWORD *)(a1 + 4 * v4) )
++i;
++v4;
}... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012ee
MOVSXD R9,ESI
MOV ECX,0x1
XOR R8D,R8D
CMP RCX,R9
JZ 0x001012ea
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
NOP word ptr [RAX + RAX*0x1]
LAB_001012d0:
CMP EDX,dword ptr [RDI + RAX*0x4]
JNZ 0x001012d9
ADD R8D,0x1
LAB_001012d9:... | int func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
int iVar3;
if (param_2 < 1) {
return 0;
}
lVar2 = 1;
iVar3 = 0;
if ((long)param_2 != 1) {
do {
lVar1 = lVar2;
do {
if (*(int *)(param_1 + -4 + lVar2 * 4) == *(int *)(param_1 + lVar1 * 4)) {
iVar3 = iV... |
7,219 | func0 | #include <assert.h>
| int func0(int arr[], int n) {
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] == arr[j]) {
cnt++;
}
}
}
return cnt;
}
| int main() {
int arr1[] = {1, 1, 1, 1};
int arr2[] = {1, 5, 1};
int arr3[] = {3, 2, 1, 7, 8, 9};
assert(func0(arr1, 4) == 6);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 6) == 0);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1439 <func0+0x129>
cmp $0x1,%esi
je 1439 <func0+0x129>
push %rbp
lea 0x4(%rdi),%r9
xor %r10d,%r10d
mov $0x1,%ecx
push %rbx
lea -0x1(%rsi),%ebp
mov $0x1,%ebx
nopl 0x0(%rax,%rax,1)
mov %esi,%r8d
mov %ebp,%eax
mov -0x4(%r9),%r11d
sub %ecx,%r8d
... | func0:
endbr64
test esi, esi
jle loc_1244
cmp esi, 1
jz loc_1244
push rbp
mov r11, rdi
lea r8, [rdi+4]
xor r10d, r10d
push rbx
mov ecx, 1
lea ebp, [rsi-1]
mov ebx, 1
xchg ax, ax
loc_1170:
mov edi, esi
mov eax, ebp
mov r9d, [r8-4]
sub edi, ecx
cmp esi,... | long long func0(long long a1, int a2)
{
const __m128i *v3; // r8
unsigned int v4; // r10d
int v5; // ecx
unsigned int v6; // r9d
unsigned int v7; // edi
__m128i v8; // xmm1
const __m128i *v9; // rax
__m128i v10; // xmm2
__m128i v11; // xmm0
__m128i v12; // xmm1
int v13; // eax
long long v14; //... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101244
CMP ESI,0x1
JZ 0x00101244
PUSH RBP
MOV R11,RDI
LEA R8,[RDI + 0x4]
XOR R10D,R10D
PUSH RBX
MOV ECX,0x1
LEA EBP,[RSI + -0x1]
MOV EBX,0x1
NOP
LAB_00101170:
MOV EDI,ESI
MOV EAX,EBP
MOV R9D,dword ptr [R8 + -0x4]
SUB EDI,ECX
CMP ESI,ECX
CMOVLE EDI,EBX
SUB EAX,ECX
CMP EAX,0x2
JBE 0x00... | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
uint uVar3;
int iVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int iVar9;
int *piVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if ((param_2 < 1) || (param_2 == 1)) {
return 0;
}
piVa... |
7,220 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(const char *input) {
int max = 0;
char temp[256]; // Temporary string for holding digits
int index = 0;
for (int i = 0; input[i] != '\0'; i++) {
if (input[i] >= '0' && input[i] <= '9') {
temp[index++] = input[i]; // collect digits
} else {
... | int main() {
assert(func0("100klh564abc365bg") == 564);
assert(func0("hello300how546mer231") == 546);
assert(func0("its233beenalong343journey234") == 343);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x140,%rsp
mov %rdi,-0x138(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x124(%rbp)
movl $0x0,-0x120(%rbp)
movl $0x0,-0x11c(%rbp)
jmpq 128f <func0+0x106>
mov -0x11c(%rbp),%eax
movslq %eax,%rdx
mov -0x138(%rbp),%rax
add... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 140h
mov [rbp+var_138], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_124], 0
mov [rbp+var_120], 0
mov [rbp+var_11C], 0
jmp loc_128F
loc_11D1:
mov eax, [rbp+var_11C]
movsxd rdx, eax
mov rax, [rbp+var_1... | long long func0(long long a1)
{
int v1; // eax
int v3; // [rsp+1Ch] [rbp-124h]
int v4; // [rsp+20h] [rbp-120h]
int i; // [rsp+24h] [rbp-11Ch]
int v6; // [rsp+28h] [rbp-118h]
int v7; // [rsp+2Ch] [rbp-114h]
char nptr[264]; // [rsp+30h] [rbp-110h] BYREF
unsigned long long v9; // [rsp+138h] [rbp-8h]
v9... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x140
MOV qword ptr [RBP + -0x138],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x124],0x0
MOV dword ptr [RBP + -0x120],0x0
MOV dword ptr [RBP + -0x11c],0x0
JMP 0x0010128f
LAB_001011d1:
MOV EAX,dword ptr [RBP + -0x11c]
MOVSX... | int func0(long param_1)
{
int iVar1;
long in_FS_OFFSET;
int local_12c;
int local_128;
int local_124;
char local_118 [264];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_12c = 0;
local_128 = 0;
for (local_124 = 0; *(char *)(param_1 + local_124) != '\0'; local_124 = local_124 +... |
7,221 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(const char *input) {
int max = 0;
char temp[256]; // Temporary string for holding digits
int index = 0;
for (int i = 0; input[i] != '\0'; i++) {
if (input[i] >= '0' && input[i] <= '9') {
temp[index++] = input[i]; // collect digits
} else {
... | int main() {
assert(func0("100klh564abc365bg") == 564);
assert(func0("hello300how546mer231") == 546);
assert(func0("its233beenalong343journey234") == 343);
return 0;
}
| O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x110,%rsp
mov %fs:0x28,%rax
mov %rax,0x108(%rsp)
xor %eax,%eax
movzbl (%rdi),%eax
test %al,%al
je 1256 <func0+0xcd>
lea 0x1(%rdi),%rbx
mov $0x0,%edx
mov $0x0,%ebp
mov %rsp,%r12
jmp 11d9 <func0+0x50>
test %edx,%edx
jne 11ec <f... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 110h
mov rax, fs:28h
mov [rsp+128h+var_20], rax
xor eax, eax
movzx eax, byte ptr [rdi]
test al, al
jz loc_1256
lea rbx, [rdi+1]
mov edx, 0
mov ebp, 0
mov r12, rsp
jmp short loc_11D9
loc_11C9:
test edx, edx
jnz ... | long long func0(char *a1)
{
char v1; // al
char *v2; // rbx
int v3; // edx
signed int v4; // ebp
int v5; // eax
unsigned int v7; // eax
_BYTE v8[264]; // [rsp+0h] [rbp-128h] BYREF
unsigned long long v9; // [rsp+108h] [rbp-20h]
v9 = __readfsqword(0x28u);
v1 = *a1;
if ( *a1 )
{
v2 = a1 + 1;
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x110
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x108],RAX
XOR EAX,EAX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101256
LEA RBX,[RDI + 0x1]
MOV EDX,0x0
MOV EBP,0x0
MOV R12,RSP
JMP 0x001011d9
LAB_001011c9:
TEST EDX,EDX
JNZ 0x001011ec
LAB_001011cd:
ADD RBX,0x1
MOV... | int func0(char *param_1)
{
char cVar1;
long lVar2;
int iVar3;
char *pcVar4;
int iVar5;
long in_FS_OFFSET;
char local_128 [264];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar5 = 0;
}
else {
iVar3 = 0;
iVar5 = 0;
pcVar4 ... |
7,222 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(const char *input) {
int max = 0;
char temp[256]; // Temporary string for holding digits
int index = 0;
for (int i = 0; input[i] != '\0'; i++) {
if (input[i] >= '0' && input[i] <= '9') {
temp[index++] = input[i]; // collect digits
} else {
... | int main() {
assert(func0("100klh564abc365bg") == 564);
assert(func0("hello300how546mer231") == 546);
assert(func0("its233beenalong343journey234") == 343);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x110,%rsp
mov %fs:0x28,%rax
mov %rax,0x108(%rsp)
xor %eax,%eax
movzbl (%rdi),%eax
test %al,%al
je 1318 <func0+0xd8>
lea 0x1(%rdi),%rbx
xor %edx,%edx
xor %r12d,%r12d
mov %rsp,%rbp
jmp 1294 <func0+0x54>
nopl 0x0(%rax,%rax,1)
movsl... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 110h
mov rax, fs:28h
mov [rsp+128h+var_20], rax
xor eax, eax
movzx eax, byte ptr [rdi]
test al, al
jz loc_1318
lea rbx, [rdi+1]
xor edx, edx
xor r12d, r12d
mov rbp, rsp
jmp short loc_1294
loc_1280:
movsxd rcx, edx... | long long func0(char *a1)
{
char v1; // al
char *v2; // rbx
int v3; // edx
signed int v4; // r12d
long long v5; // rcx
int v6; // eax
unsigned int v7; // eax
_BYTE v9[264]; // [rsp+0h] [rbp-128h] BYREF
unsigned long long v10; // [rsp+108h] [rbp-20h]
v10 = __readfsqword(0x28u);
v1 = *a1;
if ( !... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x110
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x108],RAX
XOR EAX,EAX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101318
LEA RBX,[RDI + 0x1]
XOR EDX,EDX
XOR R12D,R12D
MOV RBP,RSP
JMP 0x00101294
LAB_00101280:
MOVSXD RCX,EDX
ADD EDX,0x1
MOV byte ptr [RSP + RCX*0x1]... | int func0(char *param_1)
{
char cVar1;
long lVar2;
int iVar3;
int iVar4;
long in_FS_OFFSET;
char local_128 [264];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar4 = 0;
}
else {
param_1 = param_1 + 1;
iVar3 = 0;
iVar4 = 0;
... |
7,223 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int func0(const char *input) {
int max = 0;
char temp[256]; // Temporary string for holding digits
int index = 0;
for (int i = 0; input[i] != '\0'; i++) {
if (input[i] >= '0' && input[i] <= '9') {
temp[index++] = input[i]; // collect digits
} else {
... | int main() {
assert(func0("100klh564abc365bg") == 564);
assert(func0("hello300how546mer231") == 546);
assert(func0("its233beenalong343journey234") == 343);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x110,%rsp
mov %fs:0x28,%rax
mov %rax,0x108(%rsp)
xor %eax,%eax
movzbl (%rdi),%eax
test %al,%al
je 1318 <func0+0xd8>
lea 0x1(%rdi),%rbx
xor %edx,%edx
xor %r12d,%r12d
mov %rsp,%rbp
jmp 1294 <func0+0x54>
nopl 0x0(%rax,%rax,1)
movsl... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 110h
mov rax, fs:28h
mov [rsp+128h+var_20], rax
xor eax, eax
movzx eax, byte ptr [rdi]
test al, al
jz loc_1318
lea rbx, [rdi+1]
xor edx, edx
xor r12d, r12d
mov rbp, rsp
jmp short loc_1294
loc_1280:
movsxd rcx, edx... | long long func0(char *a1)
{
char v1; // al
char *v2; // rbx
int v3; // edx
signed int v4; // r12d
long long v5; // rcx
int v6; // eax
unsigned int v7; // eax
char v9[264]; // [rsp+0h] [rbp-128h] BYREF
unsigned long long v10; // [rsp+108h] [rbp-20h]
v10 = __readfsqword(0x28u);
v1 = *a1;
if ( !*... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x110
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x108],RAX
XOR EAX,EAX
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101318
LEA RBX,[RDI + 0x1]
XOR EDX,EDX
XOR R12D,R12D
MOV RBP,RSP
JMP 0x00101294
LAB_00101280:
MOVSXD RCX,EDX
ADD EDX,0x1
MOV byte ptr [RSP + RCX*0x1]... | int func0(char *param_1)
{
char cVar1;
long lVar2;
int iVar3;
int iVar4;
long in_FS_OFFSET;
char local_128 [264];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar4 = 0;
}
else {
param_1 = param_1 + 1;
iVar3 = 0;
iVar4 = 0;
... |
7,224 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
char* value;
} Item;
typedef struct {
Item* items;
int size;
} Dictionary;
| int* func0(Dictionary dict) {
int* keys = malloc(dict.size * sizeof(int));
for (int i = 0; i < dict.size; i++) {
keys[i] = dict.items[i].key;
}
return keys;
}
| int main() {
Dictionary dict1 = {
.items = (Item[]){{1, "python"}, {2, "java"}},
.size = 2
};
int* keys1 = func0(dict1);
assert(keys1[0] == 1 && keys1[1] == 2);
free(keys1);
Dictionary dict2 = {
.items = (Item[]){{10, "red"}, {20, "blue"}, {30, "black"}},
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,%rax
mov %rsi,%rcx
mov %rcx,%rdx
mov %rax,-0x20(%rbp)
mov %rdx,-0x18(%rbp)
mov -0x18(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1212 <func0+0x69>
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov rax, rdi
mov rcx, rsi
mov rdx, rcx
mov [rbp+var_20], rax
mov [rbp+var_18], rdx
mov eax, dword ptr [rbp+var_18]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short... | _DWORD * func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v4; // [rsp+18h] [rbp-8h]
v4 = malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
v4[i] = *(_DWORD *)(16LL * i + a1);
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV RAX,RDI
MOV RCX,RSI
MOV RDX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x18],RDX
MOV EAX,dword ptr [RBP + -0x18]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101212
LAB_001011e4:
MOV... | void * func0(long param_1,int param_2)
{
void *pvVar1;
int4 local_14;
pvVar1 = malloc((long)param_2 << 2);
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
*(int4 *)((long)pvVar1 + (long)local_14 * 4) =
*(int4 *)(param_1 + (long)local_14 * 0x10);
}
return pvVar1;
} |
7,225 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
char* value;
} Item;
typedef struct {
Item* items;
int size;
} Dictionary;
| int* func0(Dictionary dict) {
int* keys = malloc(dict.size * sizeof(int));
for (int i = 0; i < dict.size; i++) {
keys[i] = dict.items[i].key;
}
return keys;
}
| int main() {
Dictionary dict1 = {
.items = (Item[]){{1, "python"}, {2, "java"}},
.size = 2
};
int* keys1 = func0(dict1);
assert(keys1[0] == 1 && keys1[1] == 2);
free(keys1);
Dictionary dict2 = {
.items = (Item[]){{10, "red"}, {20, "blue"}, {30, "black"}},
... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 11ec <func0+0x43>
mov %rbp,%rdx
mov %rax,%rcx
lea -0x1(%rbx),%esi
shl $0x4,%rsi
lea 0x10(%rbp,%rsi,1),%rdi
mov (%rdx),%esi
mov ... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
movsxd rdi, esi
shl rdi, 2
call _malloc
test ebx, ebx
jle short loc_11EC
mov rdx, rbp
mov rcx, rax
lea esi, [rbx-1]
shl rsi, 4
lea rdi, [rbp+rsi+10h]
loc_11DB:
mov esi, [rdx]
mov [rcx], esi... | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
_DWORD *v3; // rdx
_DWORD *v4; // rcx
result = malloc(4LL * a2);
if ( a2 > 0 )
{
v3 = a1;
v4 = (_DWORD *)result;
do
{
*v4 = *v3;
v3 += 4;
++v4;
}
while ( v3 != &a1[4 * (a2 - 1) + 4] );
}
return res... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001011ec
MOV RDX,RBP
MOV RCX,RAX
LEA ESI,[RBX + -0x1]
SHL RSI,0x4
LEA RDI,[RBP + RSI*0x1 + 0x10]
LAB_001011db:
MOV ESI,dword ptr [RDX]
MOV dword ptr [RCX],ESI
ADD RDX,0x10
ADD RCX,0x4
CMP R... | void func0(int4 *param_1,int param_2)
{
int4 *puVar1;
int4 *puVar2;
puVar2 = (int4 *)malloc((long)param_2 << 2);
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
do {
*puVar2 = *param_1;
param_1 = param_1 + 4;
puVar2 = puVar2 + 1;
} while (param_1 != puVar1);... |
7,226 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
char* value;
} Item;
typedef struct {
Item* items;
int size;
} Dictionary;
| int* func0(Dictionary dict) {
int* keys = malloc(dict.size * sizeof(int));
for (int i = 0; i < dict.size; i++) {
keys[i] = dict.items[i].key;
}
return keys;
}
| int main() {
Dictionary dict1 = {
.items = (Item[]){{1, "python"}, {2, "java"}},
.size = 2
};
int* keys1 = func0(dict1);
assert(keys1[0] == 1 && keys1[1] == 2);
free(keys1);
Dictionary dict2 = {
.items = (Item[]){{10, "red"}, {20, "blue"}, {30, "black"}},
... | O2 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
shl $0x2,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 13ba <func0+0x4a>
lea -0x1(%rbp),%ecx
mov %rbx,%rdi
mov %rax,%rdx
shl $0x4,%rcx
lea 0x10(%rbx,%rcx,1),%rsi
nopw 0x0(%rax,%rax,1)
m... | func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
movsxd rdi, esi
shl rdi, 2
sub rsp, 8
call _malloc
test ebp, ebp
jle short loc_13BA
lea esi, [rbp-1]
mov rdx, rbx
mov rcx, rax
shl rsi, 4
lea rdi, [rbx+rsi+10h]
nop word ptr [rax+rax+00h]
loc_13A8:
mov ... | long long func0(int *a1, int a2)
{
long long result; // rax
int *v3; // rdx
long long v4; // rcx
long long v5; // rdi
int v6; // esi
result = malloc(4LL * a2);
if ( a2 > 0 )
{
v3 = a1;
v4 = result;
v5 = (long long)&a1[4 * (a2 - 1) + 4];
do
{
v6 = *v3;
v3 += 4;
v4 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
MOVSXD RDI,ESI
SHL RDI,0x2
SUB RSP,0x8
CALL 0x001010b0
TEST EBP,EBP
JLE 0x001013ba
LEA ESI,[RBP + -0x1]
MOV RDX,RBX
MOV RCX,RAX
SHL RSI,0x4
LEA RDI,[RBX + RSI*0x1 + 0x10]
NOP word ptr [RAX + RAX*0x1]
LAB_001013a8:
MOV ESI,dword ptr [RDX]
ADD RDX,0x10
ADD RCX,0x4
... | void func0(int4 *param_1,int param_2)
{
int4 *puVar1;
int4 uVar2;
int4 *puVar3;
puVar3 = (int4 *)malloc((long)param_2 << 2);
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) * 4 + 4;
do {
uVar2 = *param_1;
param_1 = param_1 + 4;
*puVar3 = uVar2;
puVar3 = puVar3 + ... |
7,227 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
char* value;
} Item;
typedef struct {
Item* items;
int size;
} Dictionary;
| int* func0(Dictionary dict) {
int* keys = malloc(dict.size * sizeof(int));
for (int i = 0; i < dict.size; i++) {
keys[i] = dict.items[i].key;
}
return keys;
}
| int main() {
Dictionary dict1 = {
.items = (Item[]){{1, "python"}, {2, "java"}},
.size = 2
};
int* keys1 = func0(dict1);
assert(keys1[0] == 1 && keys1[1] == 2);
free(keys1);
Dictionary dict2 = {
.items = (Item[]){{10, "red"}, {20, "blue"}, {30, "black"}},
... | O3 | c | func0:
endbr64
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
shl $0x2,%rdi
mov %rsi,%rbx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 1446 <func0+0xd6>
lea -0x1(%rbx),%edi
cmp $0x3,%edi
jbe 144d <func0+0xdd>
mov %edi,%r8d
mov %rbp,%rdx
mov %rax,%rcx
shr $0x2,%... | func0:
endbr64
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
shl rdi, 2; size
mov rbx, rsi
sub rsp, 8
call _malloc
mov rdi, rax
test ebx, ebx
jle loc_1435
lea esi, [rbx-1]
cmp esi, 3
jbe loc_143F
mov ecx, esi
mov rax, rbp
mov rdx, rdi
shr ecx, 2
shl ... | __m128 * func0(const __m128i *a1, int a2)
{
__m128 *v4; // rdi
unsigned int v5; // esi
const __m128i *v6; // rax
__m128 *v7; // rdx
__m128 v8; // xmm0
__m128 v9; // xmm2
signed int v10; // eax
long long v11; // rsi
long long v12; // rdx
v4 = (__m128 *)malloc(4LL * a2);
if ( a2 > 0 )
{
v5 = ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
SHL RDI,0x2
MOV RBX,RSI
SUB RSP,0x8
CALL 0x001010b0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x00101435
LEA ESI,[RBX + -0x1]
CMP ESI,0x3
JBE 0x0010143f
MOV ECX,ESI
MOV RAX,RBP
MOV RDX,RDI
SHR ECX,0x2
SHL RCX,0x6
ADD RCX,RBP
NOP dword ptr [RAX]
LAB_001013b8:
MOVDQU XMM0,xm... | int4 * func0(int4 *param_1,int param_2)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
uint uVar4;
int4 *puVar5;
int4 *puVar6;
int4 *puVar7;
long lVar8;
int4 *puVar9;
puVar5 = (int4 *)malloc((long)param_2 << 2);
if (0 < param_2) {
uVar4 = param_2 - 1;
if (uVar4 < 4) {
uVar4 = 0;
}
... |
7,228 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int **func0(int n) {
if (n <= 0) return NULL;
int **matrix = (int **)malloc(n * sizeof(int *));
for (int i = 0; i < n; i++) {
matrix[i] = (int *)calloc(n, sizeof(int));
}
int row_st = 0, row_ed = n - 1;
int col_st = 0, col_ed = n - 1;
int current = 1;
w... | int main() {
int n1 = 3, n2 = 2, n7 = 7;
int expected1[3][3] = {{1, 2, 3}, {8, 9, 4}, {7, 6, 5}};
int expected2[2][2] = {{1,2}, {4,3}};
int expected7[7][7] = {{1, 2, 3, 4, 5, 6, 7}, {24, 25, 26, 27, 28, 29, 8}, {23, 40, 41, 42, 43, 30, 9}, {22, 39, 48, 49, 44, 31, 10}, {21, 38, 47, 46, 45, 32,... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
cmpl $0x0,-0x44(%rbp)
jg 11e9 <func0+0x20>
mov $0x0,%eax
jmpq 139e <func0+0x1d5>
mov -0x44(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x40(... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_44], edi
cmp [rbp+var_44], 0
jg short loc_11E9
mov eax, 0
jmp loc_139E
loc_11E9:
mov eax, [rbp+var_44]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_40],... | _QWORD * func0(int a1)
{
int v2; // eax
int v3; // eax
int v4; // eax
int v5; // eax
int i; // [rsp+10h] [rbp-40h]
int v7; // [rsp+14h] [rbp-3Ch]
int v8; // [rsp+18h] [rbp-38h]
int v9; // [rsp+1Ch] [rbp-34h]
int v10; // [rsp+20h] [rbp-30h]
int v11; // [rsp+24h] [rbp-2Ch]
int j; // [rsp+28h] [rbp-2... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x44],EDI
CMP dword ptr [RBP + -0x44],0x0
JG 0x001011e9
MOV EAX,0x0
JMP 0x0010139e
LAB_001011e9:
MOV EAX,dword ptr [RBP + -0x44]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x40],0x0
JM... | void * func0(int param_1)
{
void *pvVar1;
void *pvVar2;
int4 local_48;
int4 local_44;
int4 local_40;
int4 local_3c;
int4 local_38;
int4 local_34;
int4 local_30;
int4 local_2c;
int4 local_28;
int4 local_24;
if (param_1 < 1) {
pvVar1 = (void *)0x0;
}
else {
pvVar1 = malloc((long)... |
7,229 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int **func0(int n) {
if (n <= 0) return NULL;
int **matrix = (int **)malloc(n * sizeof(int *));
for (int i = 0; i < n; i++) {
matrix[i] = (int *)calloc(n, sizeof(int));
}
int row_st = 0, row_ed = n - 1;
int col_st = 0, col_ed = n - 1;
int current = 1;
w... | int main() {
int n1 = 3, n2 = 2, n7 = 7;
int expected1[3][3] = {{1, 2, 3}, {8, 9, 4}, {7, 6, 5}};
int expected2[2][2] = {{1,2}, {4,3}};
int expected7[7][7] = {{1, 2, 3, 4, 5, 6, 7}, {24, 25, 26, 27, 28, 29, 8}, {23, 40, 41, 42, 43, 30, 9}, {22, 39, 48, 49, 44, 31, 10}, {21, 38, 47, 46, 45, 32,... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov $0x0,%ebp
test %edi,%edi
jle 1363 <func0+0x19a>
mov %edi,%r14d
movslq %edi,%r13
lea 0x0(,%r13,8),%rax
mov %rax,0x8(%rsp)
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rbp
mov %rax,%r... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebx, 0
test edi, edi
jle loc_1321
mov ebp, edi
movsxd r13, edi
lea rdi, ds:0[r13*8]
call _malloc
mov rbx, rax
mov r12, rax
mov eax, ebp
lea r14, [rbx+rax*8]
loc_1206:
mov ... | long long func0(int a1)
{
long long v1; // rbx
_QWORD *v2; // r12
int v3; // r8d
int v4; // ebp
long long v5; // r10
int v6; // r9d
long long v7; // rdi
int v8; // eax
int v9; // r11d
int v10; // esi
int *v11; // rdx
int v12; // r13d
int v13; // r12d
int v14; // ecx
_QWORD *v15; // rdx
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,0x0
TEST EDI,EDI
JLE 0x00101321
MOV EBP,EDI
MOVSXD R13,EDI
LEA RDI,[R13*0x8]
CALL 0x001010d0
MOV RBX,RAX
MOV R12,RAX
MOV EAX,EBP
LEA R14,[RBX + RAX*0x8]
LAB_00101206:
MOV ESI,0x4
MOV RDI,R13
CALL 0x001010c0
MOV qword ptr [R12],RAX
... | int8 * func0(uint param_1)
{
int iVar1;
int iVar2;
int iVar3;
void *pvVar4;
int *piVar5;
long *plVar6;
long lVar7;
int8 *puVar8;
int iVar9;
long lVar10;
int iVar11;
int iVar12;
long lVar13;
int iVar14;
int8 *puVar15;
puVar8 = (int8 *)0x0;
if (0 < (int)param_1) {
puVar8 = (int8 ... |
7,230 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int **func0(int n) {
if (n <= 0) return NULL;
int **matrix = (int **)malloc(n * sizeof(int *));
for (int i = 0; i < n; i++) {
matrix[i] = (int *)calloc(n, sizeof(int));
}
int row_st = 0, row_ed = n - 1;
int col_st = 0, col_ed = n - 1;
int current = 1;
w... | int main() {
int n1 = 3, n2 = 2, n7 = 7;
int expected1[3][3] = {{1, 2, 3}, {8, 9, 4}, {7, 6, 5}};
int expected2[2][2] = {{1,2}, {4,3}};
int expected7[7][7] = {{1, 2, 3, 4, 5, 6, 7}, {24, 25, 26, 27, 28, 29, 8}, {23, 40, 41, 42, 43, 30, 9}, {22, 39, 48, 49, 44, 31, 10}, {21, 38, 47, 46, 45, 32,... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
sub $0x8,%rsp
test %edi,%edi
jle 16fd <func0+0x16d>
movslq %edi,%r13
mov %edi,%ebx
lea 0x0(,%r13,8),%rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
mov %rax,%rbp
lea -0x1(%rbx),%eax
mov %rax,%... | func0:
endbr64
push r15
push r14
push r13
push r12
xor r12d, r12d
push rbp
push rbx
sub rsp, 18h
test edi, edi
jle loc_1708
movsxd rbp, edi
mov r13d, edi
lea rdi, ds:0[rbp*8]
call _malloc
mov r12, rax
mov r15, rax
lea eax, [r13-1]
mov [rsp+48h+var_3C], eax
mo... | long long func0(int a1)
{
long long v1; // r12
long long v3; // r15
int v4; // ebx
long long v5; // r10
long long v6; // rdi
long long v7; // r9
int v8; // r11d
int v9; // eax
int v10; // esi
int v11; // r8d
int v12; // ecx
int v13; // r14d
long long v14; // rdx
int v15; // r13d
int v16; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST EDI,EDI
JLE 0x00101708
MOVSXD RBP,EDI
MOV R13D,EDI
LEA RDI,[RBP*0x8]
CALL 0x001010d0
MOV R12,RAX
MOV R15,RAX
LEA EAX,[R13 + -0x1]
MOV dword ptr [RSP + 0xc],EAX
MOV EBX,EAX
MOV EAX,R13D
LEA R14,[R12 + RAX*0x8]
NOP word p... | int8 * func0(uint param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int8 *puVar5;
void *pvVar6;
int iVar7;
long *plVar8;
int *piVar9;
long lVar10;
int iVar11;
long lVar12;
uint uVar13;
int iVar14;
long lVar15;
ulong uVar16;
ulong uVar17;
int8 *puVar18;
int8 *puVar19;
puV... |
7,231 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int **func0(int n) {
if (n <= 0) return NULL;
int **matrix = (int **)malloc(n * sizeof(int *));
for (int i = 0; i < n; i++) {
matrix[i] = (int *)calloc(n, sizeof(int));
}
int row_st = 0, row_ed = n - 1;
int col_st = 0, col_ed = n - 1;
int current = 1;
w... | int main() {
int n1 = 3, n2 = 2, n7 = 7;
int expected1[3][3] = {{1, 2, 3}, {8, 9, 4}, {7, 6, 5}};
int expected2[2][2] = {{1,2}, {4,3}};
int expected7[7][7] = {{1, 2, 3, 4, 5, 6, 7}, {24, 25, 26, 27, 28, 29, 8}, {23, 40, 41, 42, 43, 30, 9}, {22, 39, 48, 49, 44, 31, 10}, {21, 38, 47, 46, 45, 32,... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
sub $0x18,%rsp
test %edi,%edi
jle 1782 <func0+0x272>
movslq %edi,%rbx
mov %edi,%r14d
lea 0x0(,%rbx,8),%rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
mov %rax,%rbp
lea -0x1(%r14),%eax
mov %rax... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
xor ebx, ebx
sub rsp, 18h
test edi, edi
jle loc_1724
movsxd rbp, edi
mov r14d, edi
lea r13, ds:0[rbp*8]
mov rdi, r13; size
call _malloc
mov rbx, rax
mov r12, rax
add r13, rax
nop dword p... | _QWORD * func0(int a1)
{
_QWORD *v1; // rbx
long long v2; // rbp
_QWORD *v4; // r12
signed int v5; // r10d
unsigned long long v6; // rdi
int v7; // esi
int v8; // r14d
long long v9; // r13
unsigned int v10; // r9d
__m128i si128; // xmm3
__m128i v12; // xmm2
signed int v13; // r12d
signed int v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
XOR EBX,EBX
SUB RSP,0x18
TEST EDI,EDI
JLE 0x00101724
MOVSXD RBP,EDI
MOV R14D,EDI
LEA R13,[RBP*0x8]
MOV RDI,R13
CALL 0x001010d0
MOV RBX,RAX
MOV R12,RAX
ADD R13,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101500:
MOV ESI,0x4
MOV RDI,RBP
ADD R12,0x8
CALL 0x0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 * func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int8 *puVar12;
void *pvVar13;
int *piVar14;
uint uV... |
7,232 | func0 |
#include <assert.h>
| float func0(int x1, int y1, int x2, int y2) {
return (float)(y2 - y1) / (x2 - x1);
}
| int main() {
assert(func0(4, 2, 2, 5) == -1.5);
assert(func0(2, 4, 4, 6) == 1.0);
assert(func0(1, 2, 4, 2) == 0.0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
mov %ecx,-0x10(%rbp)
mov -0x10(%rbp),%eax
sub -0x8(%rbp),%eax
cvtsi2ss %eax,%xmm0
mov -0xc(%rbp),%eax
sub -0x4(%rbp),%eax
cvtsi2ss %eax,%xmm1
divss %xmm1,%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov [rbp+var_10], ecx
mov eax, [rbp+var_10]
sub eax, [rbp+var_8]
pxor xmm0, xmm0
cvtsi2ss xmm0, eax
mov eax, [rbp+var_C]
sub eax, [rbp+var_4]
pxor xmm1, xmm1
cvtsi2ss xmm1, ea... | float func0(int a1, int a2, int a3, int a4)
{
return (float)(a4 - a2) / (float)(a3 - a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV dword ptr [RBP + -0x10],ECX
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,dword ptr [RBP + -0x8]
PXOR XMM0,XMM0
CVTSI2SS XMM0,EAX
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x4]
P... | int8 func0(int param_1,int param_2,int param_3,int param_4)
{
int auVar1 [16];
auVar1._4_12_ = SUB1612((int [16])0x0,4);
auVar1._0_4_ = (float)(param_4 - param_2) / (float)(param_3 - param_1);
return auVar1._0_8_;
} |
7,233 | func0 |
#include <assert.h>
| float func0(int x1, int y1, int x2, int y2) {
return (float)(y2 - y1) / (x2 - x1);
}
| int main() {
assert(func0(4, 2, 2, 5) == -1.5);
assert(func0(2, 4, 4, 6) == 1.0);
assert(func0(1, 2, 4, 2) == 0.0);
return 0;
}
| O1 | c | func0:
endbr64
sub %esi,%ecx
pxor %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
sub %edi,%edx
pxor %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
divss %xmm1,%xmm0
retq
| func0:
endbr64
sub ecx, esi
pxor xmm0, xmm0
cvtsi2ss xmm0, ecx
sub edx, edi
pxor xmm1, xmm1
cvtsi2ss xmm1, edx
divss xmm0, xmm1
retn | float func0(int a1, int a2, int a3, int a4)
{
return (float)(a4 - a2) / (float)(a3 - a1);
} | func0:
ENDBR64
SUB ECX,ESI
PXOR XMM0,XMM0
CVTSI2SS XMM0,ECX
SUB EDX,EDI
PXOR XMM1,XMM1
CVTSI2SS XMM1,EDX
DIVSS XMM0,XMM1
RET | int8 func0(int param_1,int param_2,int param_3,int param_4)
{
int1 auVar1 [16];
auVar1._4_12_ = SUB1612((int1 [16])0x0,4);
auVar1._0_4_ = (float)(param_4 - param_2) / (float)(param_3 - param_1);
return auVar1._0_8_;
} |
7,234 | func0 |
#include <assert.h>
| float func0(int x1, int y1, int x2, int y2) {
return (float)(y2 - y1) / (x2 - x1);
}
| int main() {
assert(func0(4, 2, 2, 5) == -1.5);
assert(func0(2, 4, 4, 6) == 1.0);
assert(func0(1, 2, 4, 2) == 0.0);
return 0;
}
| O2 | c | func0:
endbr64
sub %esi,%ecx
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
sub %edi,%edx
cvtsi2ss %ecx,%xmm0
cvtsi2ss %edx,%xmm1
divss %xmm1,%xmm0
retq
nopl (%rax)
| func0:
endbr64
sub ecx, esi
pxor xmm0, xmm0
pxor xmm1, xmm1
sub edx, edi
cvtsi2ss xmm0, ecx
cvtsi2ss xmm1, edx
divss xmm0, xmm1
retn | float func0(int a1, int a2, int a3, int a4)
{
return (float)(a4 - a2) / (float)(a3 - a1);
} | func0:
ENDBR64
SUB ECX,ESI
PXOR XMM0,XMM0
PXOR XMM1,XMM1
SUB EDX,EDI
CVTSI2SS XMM0,ECX
CVTSI2SS XMM1,EDX
DIVSS XMM0,XMM1
RET | int8 func0(int param_1,int param_2,int param_3,int param_4)
{
int1 auVar1 [16];
auVar1._4_12_ = SUB1612((int1 [16])0x0,4);
auVar1._0_4_ = (float)(param_4 - param_2) / (float)(param_3 - param_1);
return auVar1._0_8_;
} |
7,235 | func0 |
#include <assert.h>
| float func0(int x1, int y1, int x2, int y2) {
return (float)(y2 - y1) / (x2 - x1);
}
| int main() {
assert(func0(4, 2, 2, 5) == -1.5);
assert(func0(2, 4, 4, 6) == 1.0);
assert(func0(1, 2, 4, 2) == 0.0);
return 0;
}
| O3 | c | func0:
endbr64
sub %esi,%ecx
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
sub %edi,%edx
cvtsi2ss %ecx,%xmm0
cvtsi2ss %edx,%xmm1
divss %xmm1,%xmm0
retq
nopl (%rax)
| func0:
endbr64
sub ecx, esi
pxor xmm0, xmm0
pxor xmm1, xmm1
sub edx, edi
cvtsi2ss xmm0, ecx
cvtsi2ss xmm1, edx
divss xmm0, xmm1
retn | float func0(int a1, int a2, int a3, int a4)
{
return (float)(a4 - a2) / (float)(a3 - a1);
} | func0:
ENDBR64
SUB ECX,ESI
PXOR XMM0,XMM0
PXOR XMM1,XMM1
SUB EDX,EDI
CVTSI2SS XMM0,ECX
CVTSI2SS XMM1,EDX
DIVSS XMM0,XMM1
RET | int8 func0(int param_1,int param_2,int param_3,int param_4)
{
int auVar1 [16];
auVar1._4_12_ = SUB1612((int [16])0x0,4);
auVar1._0_4_ = (float)(param_4 - param_2) / (float)(param_3 - param_1);
return auVar1._0_8_;
} |
7,236 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = INT_MIN;
int max_ending_here = 0;
int start = 0;
int end = 0;
int s = 0;
for (int i = 0; i < size; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
... | int main() {
assert(func0((int[]){-2, -3, 4, -1, -2, 1, 5, -3}, 8) == 5);
assert(func0((int[]){1, -2, 1, 1, -2, 1}, 6) == 2);
assert(func0((int[]){-1, -2, 3, 4, 5}, 5) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x80000000,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11f1 <func0+0x88>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mo... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_18], 80000000h
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11F1
loc_11A4:
mov eax, [rbp+var_4]
cdqe
lea rdx,... | long long func0(long long a1, int a2)
{
signed int v3; // [rsp+14h] [rbp-18h]
int v4; // [rsp+18h] [rbp-14h]
int v5; // [rsp+1Ch] [rbp-10h]
int v6; // [rsp+20h] [rbp-Ch]
int v7; // [rsp+24h] [rbp-8h]
int i; // [rsp+28h] [rbp-4h]
v3 = 0x80000000;
v4 = 0;
v5 = 0;
v6 = 0;
v7 = 0;
for ( i = 0; i <... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x18],0x80000000
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011f1
LAB_00101... | int func0(long param_1,int param_2)
{
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
local_20 = -0x80000000;
local_1c = 0;
local_18 = 0;
local_14 = 0;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_1c = local_1c... |
7,237 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = INT_MIN;
int max_ending_here = 0;
int start = 0;
int end = 0;
int s = 0;
for (int i = 0; i < size; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
... | int main() {
assert(func0((int[]){-2, -3, 4, -1, -2, 1, 5, -3}, 8) == 5);
assert(func0((int[]){1, -2, 1, 1, -2, 1}, 6) == 2);
assert(func0((int[]){-1, -2, 3, 4, 5}, 5) == 3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
test %esi,%esi
jle 11cd <func0+0x64>
lea -0x1(%rsi),%r10d
mov $0x0,%edx
mov $0x0,%r11d
mov $0x0,%eax
mov $0x0,%ebx
mov $0x0,%esi
mov $0x80000000,%r8d
mov $0x0,%ebp
jmp 11ae <func0+0x45>
test %ecx,%ecx
js 11c5 <func0+0x5c>
lea 0x1(%rdx),%rcx... | func0:
endbr64
push rbp
push rbx
test esi, esi
jle short loc_11CE
mov esi, esi
mov edx, 0
mov r11d, 0
mov eax, 0
mov ebx, 0
mov r8d, 0
mov r9d, 80000000h
mov ebp, 0
jmp short loc_11AA
loc_119D:
test ecx, ecx
js short loc_11C5
loc_11A1:
add rdx, 1
cmp rdx,... | long long func0(long long a1, int a2)
{
long long v2; // rdx
int v3; // r11d
int v4; // eax
int v5; // ebx
int v6; // r8d
signed int v7; // r9d
int v8; // ecx
if ( a2 <= 0 )
{
v4 = 0;
v5 = 0;
}
else
{
v2 = 0LL;
v3 = 0;
v4 = 0;
v5 = 0;
v6 = 0;
v7 = 0x80000000;
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x001011ce
MOV ESI,ESI
MOV EDX,0x0
MOV R11D,0x0
MOV EAX,0x0
MOV EBX,0x0
MOV R8D,0x0
MOV R9D,0x80000000
MOV EBP,0x0
JMP 0x001011aa
LAB_0010119d:
TEST ECX,ECX
JS 0x001011c5
LAB_001011a1:
ADD RDX,0x1
CMP RDX,RSI
JZ 0x001011d8
LAB_001011aa:
MOV R10D,EDX
MOV ECX,R8D
ADD ECX,... | int func0(long param_1,uint param_2)
{
int iVar1;
ulong uVar2;
int iVar3;
ulong uVar4;
int iVar5;
int iVar6;
int iVar7;
if ((int)param_2 < 1) {
iVar1 = 0;
iVar5 = 0;
}
else {
uVar4 = 0;
iVar7 = 0;
uVar2 = 0;
iVar5 = 0;
iVar3 = 0;
iVar6 = -0x80000000;
do {
... |
7,238 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = INT_MIN;
int max_ending_here = 0;
int start = 0;
int end = 0;
int s = 0;
for (int i = 0; i < size; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
... | int main() {
assert(func0((int[]){-2, -3, 4, -1, -2, 1, 5, -3}, 8) == 5);
assert(func0((int[]){1, -2, 1, 1, -2, 1}, 6) == 2);
assert(func0((int[]){-1, -2, 3, 4, 5}, 5) == 3);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 13d8 <func0+0x58>
push %rbx
xor %r8d,%r8d
xor %r9d,%r9d
xor %eax,%eax
xor %ebx,%ebx
xor %ecx,%ecx
mov $0x80000000,%r10d
xor %r11d,%r11d
xchg %ax,%ax
add (%rdi),%ecx
mov %ecx,%edx
cmp %r10d,%ecx
jle 13b2 <func0+0x32>
mov %r8d,%eax
mov %r9d... | func0:
endbr64
test esi, esi
jle short loc_1310
xor ecx, ecx
xor r8d, r8d
xor eax, eax
xor r11d, r11d
xor edx, edx
mov r9d, 80000000h
xor r10d, r10d
nop dword ptr [rax]
loc_12E0:
add edx, [rdi]
cmp edx, r9d
jle short loc_12EF
mov eax, ecx
mov r11d, r8d
mov ... | long long func0(_DWORD *a1, int a2)
{
int v2; // ecx
int v3; // r8d
int v4; // eax
int v5; // r11d
int v6; // edx
signed int v7; // r9d
if ( a2 <= 0 )
return 1LL;
v2 = 0;
v3 = 0;
v4 = 0;
v5 = 0;
v6 = 0;
v7 = 0x80000000;
do
{
v6 += *a1;
if ( v6 > v7 )
{
v4 = v2;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101310
XOR ECX,ECX
XOR R8D,R8D
XOR EAX,EAX
XOR R11D,R11D
XOR EDX,EDX
MOV R9D,0x80000000
XOR R10D,R10D
NOP dword ptr [RAX]
LAB_001012e0:
ADD EDX,dword ptr [RDI]
CMP EDX,R9D
JLE 0x001012ef
MOV EAX,ECX
MOV R11D,R8D
MOV R9D,EDX
LAB_001012ef:
ADD ECX,0x1
TEST EDX,EDX
CMOVS R8D,ECX
CMOVS E... | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_2 < 1) {
return 1;
}
iVar2 = 0;
iVar4 = 0;
iVar1 = 0;
iVar6 = 0;
iVar3 = 0;
iVar5 = -0x80000000;
do {
iVar3 = iVar3 + *param_1;
if (iVar5 < iVar3) {
iVar5... |
7,239 | func0 |
#include <limits.h>
#include <assert.h>
| int func0(int a[], int size) {
int max_so_far = INT_MIN;
int max_ending_here = 0;
int start = 0;
int end = 0;
int s = 0;
for (int i = 0; i < size; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
... | int main() {
assert(func0((int[]){-2, -3, 4, -1, -2, 1, 5, -3}, 8) == 5);
assert(func0((int[]){1, -2, 1, 1, -2, 1}, 6) == 2);
assert(func0((int[]){-1, -2, 3, 4, 5}, 5) == 3);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1458 <func0+0x58>
push %rbx
xor %r8d,%r8d
xor %r9d,%r9d
xor %eax,%eax
xor %ebx,%ebx
xor %ecx,%ecx
mov $0x80000000,%r10d
xor %r11d,%r11d
xchg %ax,%ax
add (%rdi),%ecx
mov %ecx,%edx
cmp %ecx,%r10d
jge 1432 <func0+0x32>
mov %r8d,%eax
mov %r9d... | func0:
endbr64
test esi, esi
jle short loc_1190
xor ecx, ecx
xor r8d, r8d
xor eax, eax
xor r11d, r11d
xor edx, edx
mov r9d, 80000000h
xor r10d, r10d
nop dword ptr [rax]
loc_1160:
add edx, [rdi]
cmp r9d, edx
jge short loc_116F
mov eax, ecx
mov r11d, r8d
mov ... | long long func0(_DWORD *a1, int a2)
{
int v2; // ecx
int v3; // r8d
int v4; // eax
int v5; // r11d
int v6; // edx
signed int v7; // r9d
if ( a2 <= 0 )
return 1LL;
v2 = 0;
v3 = 0;
v4 = 0;
v5 = 0;
v6 = 0;
v7 = 0x80000000;
do
{
v6 += *a1;
if ( v7 < v6 )
{
v4 = v2;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
XOR ECX,ECX
XOR R8D,R8D
XOR EAX,EAX
XOR R11D,R11D
XOR EDX,EDX
MOV R9D,0x80000000
XOR R10D,R10D
NOP dword ptr [RAX]
LAB_00101160:
ADD EDX,dword ptr [RDI]
CMP R9D,EDX
JGE 0x0010116f
MOV EAX,ECX
MOV R11D,R8D
MOV R9D,EDX
LAB_0010116f:
ADD ECX,0x1
TEST EDX,EDX
CMOVS R8D,ECX
CMOVS E... | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_2 < 1) {
return 1;
}
iVar2 = 0;
iVar4 = 0;
iVar1 = 0;
iVar6 = 0;
iVar3 = 0;
iVar5 = -0x80000000;
do {
iVar3 = iVar3 + *param_1;
if (iVar5 < iVar3) {
iVar5... |
7,240 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += (2 * i + 1) * (2 * i + 1) * (2 * i + 1);
}
return sum;
}
| int main() {
assert(func0(2) == 28);
assert(func0(3) == 153);
assert(func0(4) == 496);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1189 <func0+0x40>
mov -0x4(%rbp),%eax
add %eax,%eax
lea 0x1(%rax),%edx
mov -0x4(%rbp),%eax
add %eax,%eax
add $0x1,%eax
imul %edx,%eax
mov -0x4(%rbp),%edx
add %edx,%edx
add ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_1189
loc_1164:
mov eax, [rbp+var_4]
add eax, eax
lea edx, [rax+1]
mov eax, [rbp+var_4]
add eax, eax
add eax, 1
imul eax, edx
mov edx, [rbp+var_4]
add e... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 0; i < a1; ++i )
v2 += (2 * i + 1) * (2 * i + 1) * (2 * i + 1);
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101189
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
ADD EAX,0x1
IMUL EAX,EDX
MOV EDX,dword ptr [RBP + -0x4]... | int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_1; local_c = local_c + 1) {
local_10 = local_10 + (local_c * 2 + 1) * (local_c * 2 + 1) * (local_c * 2 + 1);
}
return local_10;
} |
7,241 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += (2 * i + 1) * (2 * i + 1) * (2 * i + 1);
}
return sum;
}
| int main() {
assert(func0(2) == 28);
assert(func0(3) == 153);
assert(func0(4) == 496);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1173 <func0+0x2a>
lea 0x1(%rdi,%rdi,1),%esi
mov $0x1,%eax
mov $0x0,%ecx
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add %edx,%ecx
add $0x2,%eax
cmp %esi,%eax
jne 115f <func0+0x16>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1170 <func0+0x27>
| func0:
endbr64
test edi, edi
jle short loc_1173
lea esi, [rdi+rdi+1]
mov eax, 1
mov ecx, 0
loc_115F:
mov edx, eax
imul edx, eax
imul edx, eax
add ecx, edx
add eax, 2
cmp eax, esi
jnz short loc_115F
loc_1170:
mov eax, ecx
retn
loc_1173:
mov ecx, 0
jmp short loc_11... | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = 1;
v2 = 0;
do
{
v2 += v1 * v1 * v1;
v1 += 2;
}
while ( v1 != 2 * a1 + 1 );
}
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101173
LEA ESI,[RDI + RDI*0x1 + 0x1]
MOV EAX,0x1
MOV ECX,0x0
LAB_0010115f:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD ECX,EDX
ADD EAX,0x2
CMP EAX,ESI
JNZ 0x0010115f
LAB_00101170:
MOV EAX,ECX
RET
LAB_00101173:
MOV ECX,0x0
JMP 0x00101170 | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 2;
} while (iVar1 != param_1 * 2 + 1);
}
return iVar2;
} |
7,242 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += (2 * i + 1) * (2 * i + 1) * (2 * i + 1);
}
return sum;
}
| int main() {
assert(func0(2) == 28);
assert(func0(3) == 153);
assert(func0(4) == 496);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
lea 0x1(%rdi,%rdi,1),%ecx
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add $0x2,%eax
add %edx,%r8d
cmp %ecx,%eax
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mo... | func0:
endbr64
test edi, edi
jle short loc_1170
lea ecx, [rdi+rdi+1]
mov eax, 1
xor r8d, r8d
nop dword ptr [rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
imul edx, eax
add eax, 2
add r8d, edx
cmp eax, ecx
jnz short loc_1158
mov eax, r8d
retn
loc_1170:
xor r8d, r8... | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // r8d
int v3; // edx
if ( a1 <= 0 )
return 0LL;
v1 = 1;
v2 = 0;
do
{
v3 = v1 * v1 * v1;
v1 += 2;
v2 += v3;
}
while ( v1 != 2 * a1 + 1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
LEA ECX,[RDI + RDI*0x1 + 0x1]
MOV EAX,0x1
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x2
ADD R8D,EDX
CMP EAX,ECX
JNZ 0x00101158
MOV EAX,R8D
RET
LAB_00101170:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar3 = 0;
do {
iVar2 = iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 2;
iVar3 = iVar3 + iVar2;
} while (iVar1 != param_1 * 2 + 1);
return iVar3;
}
return 0;
} |
7,243 | func0 |
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += (2 * i + 1) * (2 * i + 1) * (2 * i + 1);
}
return sum;
}
| int main() {
assert(func0(2) == 28);
assert(func0(3) == 153);
assert(func0(4) == 496);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1230 <func0+0xf0>
lea -0x1(%rdi),%eax
cmp $0x15,%eax
jbe 1237 <func0+0xf7>
mov %edi,%edx
movdqa 0xeae(%rip),%xmm4
xor %eax,%eax
pxor %xmm3,%xmm3
movdqa 0xeb0(%rip),%xmm6
movdqa 0xeb8(%rip),%xmm5
shr $0x2,%edx
nopl 0x0(%rax,%rax,1)
movdqa %xmm4,%xmm0
add $0... | func0:
endbr64
mov edx, edi
test edi, edi
jle loc_1378
lea eax, [rdi-1]
cmp eax, 0Dh
jbe loc_1381
mov ecx, edi
movdqa xmm3, cs:xmmword_2010
xor eax, eax
pxor xmm2, xmm2
movdqa xmm5, cs:xmmword_2020
movdqa xmm4, cs:xmmword_2030
shr ecx, 2
nop dword ptr [rax]
loc_1180:
movdqa ... | long long func0(int a1)
{
__m128i si128; // xmm3
int v2; // eax
__m128i v3; // xmm2
__m128i v4; // xmm5
__m128i v5; // xmm4
__m128i v6; // xmm0
__m128i v7; // xmm0
__m128i v8; // xmm6
__m128i v9; // xmm1
unsigned int v10; // ecx
__m128i v11; // xmm2
long long result; // rax
int v13; // esi
... | func0:
ENDBR64
MOV EDX,EDI
TEST EDI,EDI
JLE 0x00101378
LEA EAX,[RDI + -0x1]
CMP EAX,0xd
JBE 0x00101381
MOV ECX,EDI
MOVDQA XMM3,xmmword ptr [0x00102010]
XOR EAX,EAX
PXOR XMM2,XMM2
MOVDQA XMM5,xmmword ptr [0x00102020]
MOVDQA XMM4,xmmword ptr [0x00102030]
SHR ECX,0x2
NOP dword ptr [RAX]
LAB_00101180:
MOVDQA XMM0,XMM3
ADD ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint param_1)
{
uint uVar1;
int iVar2;
int iVar3;
int auVar4 [16];
long lVar6;
int auVar5 [16];
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
ulong uVar13;
if ((int)para... |
7,244 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *s1, const char *s2) {
int c0 = 0;
int c1 = 0;
int length = strlen(s1);
for (int i = 0; i < length; i++) {
if (s1[i] == '0' && s2[i] == '1') {
c0++;
} else if (s1[i] == '1' && s2[i] == '0') {
c1++;
}
}
int result = c... | int main() {
assert(func0("0011", "1111") == 1);
assert(func0("00011", "01001") == 2);
assert(func0("111", "111") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1201 <func0+0x98>
mov -0xc(%rbp),%eax
mo... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov [rbp+var_C], 0
jmp short loc_1201
loc_11A3:
mov eax, [rbp+var_C]
m... | long long func0(const char *a1, long long a2)
{
int v3; // [rsp+1Ch] [rbp-14h]
int v4; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
int v6; // [rsp+28h] [rbp-8h]
unsigned int v7; // [rsp+2Ch] [rbp-4h]
v3 = 0;
v4 = 0;
v6 = strlen(a1);
for ( i = 0; i < v6; ++i )
{
if ( a1[i] == 48 && *(_B... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101201
LAB_00... | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
uint local_1c;
uint local_18;
int local_14;
local_1c = 0;
local_18 = 0;
sVar2 = strlen(param_1);
for (local_14 = 0; local_14 < (int)sVar2; local_14 = local_14 + 1) {
if ((param_1[local_14] == '0') && (*(char *)(param_2 + local_14... |
7,245 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *s1, const char *s2) {
int c0 = 0;
int c1 = 0;
int length = strlen(s1);
for (int i = 0; i < length; i++) {
if (s1[i] == '0' && s2[i] == '1') {
c0++;
} else if (s1[i] == '1' && s2[i] == '0') {
c1++;
}
}
int result = c... | int main() {
assert(func0("0011", "1111") == 1);
assert(func0("00011", "01001") == 2);
assert(func0("111", "111") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r8
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
test %ecx,%ecx
jle 11dd <func0+0x94>
lea -0x1(%rcx),%r9d
mov $0x0,%eax
mov $0x0,%edi
mov $0x0,%ecx
jmp 1196 <func0+0x4d>
cmpb $0x31,(%rsi,%rax,1)
sete %dl
movzbl... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov rbp, rsi
call _strlen
test eax, eax
jle short loc_11FA
lea edi, [rax-1]
mov eax, 0
mov esi, 0
mov ecx, 0
jmp short loc_11AF
loc_1196:
cmp byte ptr [rbp+rax+0], 31h ; '1'
setz dl
movzx edx, dl
add ec... | long long func0(long long a1, long long a2)
{
int v4; // eax
long long v5; // rdi
long long v6; // rax
int v7; // esi
int v8; // ecx
char v9; // dl
long long result; // rax
v4 = strlen();
if ( v4 <= 0 )
return 0LL;
v5 = (unsigned int)(v4 - 1);
v6 = 0LL;
v7 = 0;
v8 = 0;
while ( 1 )
{
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV RBP,RSI
CALL 0x00101060
TEST EAX,EAX
JLE 0x001011fa
LEA EDI,[RAX + -0x1]
MOV EAX,0x0
MOV ESI,0x0
MOV ECX,0x0
JMP 0x001011af
LAB_00101196:
CMP byte ptr [RBP + RAX*0x1],0x31
SETZ DL
MOVZX EDX,DL
ADD ECX,EDX
LAB_001011a3:
LEA RDX,[RAX + 0x1]
CMP RAX,RDI
JZ 0x001... | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
uint uVar4;
uint uVar5;
bool bVar6;
sVar2 = strlen(param_1);
if ((int)sVar2 < 1) {
iVar1 = 0;
}
else {
uVar5 = 0;
uVar4 = 0;
uVar3 = 0;
do {
if (param_1[uVar3] == '0') {
uVar4 = uVar4 ... |
7,246 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *s1, const char *s2) {
int c0 = 0;
int c1 = 0;
int length = strlen(s1);
for (int i = 0; i < length; i++) {
if (s1[i] == '0' && s2[i] == '1') {
c0++;
} else if (s1[i] == '1' && s2[i] == '0') {
c1++;
}
}
int result = c... | int main() {
assert(func0("0011", "1111") == 1);
assert(func0("00011", "01001") == 2);
assert(func0("111", "111") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %eax,%eax
jle 12b0 <func0+0x90>
lea -0x1(%rax),%edi
xor %r8d,%r8d
xor %eax,%eax
xor %ecx,%ecx
jmp 1266 <func0+0x46>
nopl (%rax)
cmp $0x31,%dl
jne 125a <func0+0x3a>
xor %... | func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle short loc_12B0
lea edi, [rax-1]
xor r8d, r8d
xor eax, eax
xor ecx, ecx
jmp short loc_1266
loc_1248:
cmp dl, 31h ; '1'
jnz short loc_125A
xor edx, edx
cmp b... | long long func0(long long a1, long long a2)
{
int v3; // eax
long long v4; // rdi
int v5; // r8d
long long v6; // rax
int v7; // ecx
long long v8; // rdx
char v9; // dl
long long result; // rax
v3 = strlen();
if ( v3 <= 0 )
return 0LL;
v4 = (unsigned int)(v3 - 1);
v5 = 0;
v6 = 0LL;
v7 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
TEST EAX,EAX
JLE 0x001012b0
LEA EDI,[RAX + -0x1]
XOR R8D,R8D
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00101266
LAB_00101248:
CMP DL,0x31
JNZ 0x0010125a
XOR EDX,EDX
CMP byte ptr [RBP + RAX*0x1],0x30
SETZ DL
ADD R8D,EDX
LAB_0010125a:
LEA RDX,[RAX +... | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
uint uVar3;
ulong uVar4;
uint uVar5;
sVar2 = strlen(param_1);
if ((int)sVar2 < 1) {
return 0;
}
uVar5 = 0;
uVar4 = 0;
uVar3 = 0;
while( true ) {
if (param_1[uVar4] == '0') {
uVar3 = uVar3 + (*(char *)(param_2 + uV... |
7,247 | func0 |
#include <assert.h>
#include <string.h>
| int func0(const char *s1, const char *s2) {
int c0 = 0;
int c1 = 0;
int length = strlen(s1);
for (int i = 0; i < length; i++) {
if (s1[i] == '0' && s2[i] == '1') {
c0++;
} else if (s1[i] == '1' && s2[i] == '0') {
c1++;
}
}
int result = c... | int main() {
assert(func0("0011", "1111") == 1);
assert(func0("00011", "01001") == 2);
assert(func0("111", "111") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
test %eax,%eax
jle 12b0 <func0+0x90>
lea -0x1(%rax),%edi
xor %r8d,%r8d
xor %eax,%eax
xor %ecx,%ecx
jmp 1266 <func0+0x46>
nopl (%rax)
cmp $0x31,%dl
jne 125a <func0+0x3a>
xor %... | func0:
endbr64
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
test eax, eax
jle loc_12C0
lea ecx, [rax-1]
xor edi, edi
xor eax, eax
xor esi, esi
jmp short loc_126C
loc_1250:
cmp dl, 31h ; '1'
jnz short loc_1260
cmp byte ptr [rbp+rax+0], 30... | long long func0(const char *a1, long long a2)
{
int v4; // eax
long long v5; // rcx
int v6; // edi
long long v7; // rax
int v8; // esi
long long v9; // rdx
char v10; // dl
long long result; // rax
v4 = strlen(a1);
if ( v4 <= 0 )
return 0LL;
v5 = (unsigned int)(v4 - 1);
v6 = 0;
v7 = 0LL;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101060
TEST EAX,EAX
JLE 0x001012c0
LEA ECX,[RAX + -0x1]
XOR EDI,EDI
XOR EAX,EAX
XOR ESI,ESI
JMP 0x0010126c
LAB_00101250:
CMP DL,0x31
JNZ 0x00101260
CMP byte ptr [RBP + RAX*0x1],0x30
JNZ 0x00101260
ADD EDI,0x1
NOP
LAB_00101260:
LEA RDX,[RAX + ... | int func0(char *param_1,long param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
uint uVar4;
uint uVar5;
sVar2 = strlen(param_1);
if (0 < (int)sVar2) {
uVar5 = 0;
uVar3 = 0;
uVar4 = 0;
while( true ) {
if (param_1[uVar3] == '0') {
if (*(char *)(param_2 + uVar3) == '1') {
... |
7,248 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* first;
char* second;
} tuple;
| tuple* func0(tuple arr[], int n) {
for(int i = 0; i < n; i++) {
for(int j = 0; j < n - i -1; j++) {
if(strcmp(arr[j].first, arr[j +1].first) > 0) {
tuple temp = arr[j];
arr[j] = arr[j +1];
arr[j +1] = temp;
}
}
}
... | int main() {
// Test case 1
tuple test1[] = {{"Amana", "28"}, {"Zenat", "30"}, {"Abhishek", "29"}, {"Nikhil", "21"}, {"B", "C"}};
tuple expected1[] = {{"Abhishek", "29"}, {"Amana", "28"}, {"B", "C"}, {"Nikhil", "21"}, {"Zenat", "30"}};
func0(test1, 5);
for(int i = 0; i < 5; i++) {
asse... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x18(%rbp)
jmpq 1293 <func0+0x10a>
movl $0x0,-0x14(%rbp)
jmpq 127d <func0+0xf4>
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
shl $0x4,%rax
mov %rax,%rdx
mov -0x28(%rbp),%rax
add ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_18], 0
jmp loc_1293
loc_11A8:
mov [rbp+var_14], 0
jmp loc_127D
loc_11B4:
mov eax, [rbp+var_14]
cdqe
add rax, 1
shl rax, 4
mov rdx, rax
mov rax, [rbp+var_28]
a... | long long func0(long long a1, int a2)
{
long long *v2; // rax
_QWORD *v3; // rax
_QWORD *v4; // rcx
long long v5; // rdx
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
long long v9; // [rsp+20h] [rbp-10h]
long long v10; // [rsp+28h] [rbp-8h]
for ( i = 0; i < a2; ++i )
{
for ( j = ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101293
LAB_001011a8:
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010127d
LAB_001011b4:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
SHL RAX,0x4
MOV RDX,RAX
MOV RAX,qwor... | long func0(long param_1,int param_2)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int iVar4;
int8 *puVar5;
int8 *puVar6;
int local_20;
int local_1c;
for (local_20 = 0; local_20 < param_2; local_20 = local_20 + 1) {
for (local_1c = 0; local_1c < (param_2 - local_20) + -1; local_1c = local_1c + 1) {
... |
7,249 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* first;
char* second;
} tuple;
| tuple* func0(tuple arr[], int n) {
for(int i = 0; i < n; i++) {
for(int j = 0; j < n - i -1; j++) {
if(strcmp(arr[j].first, arr[j +1].first) > 0) {
tuple temp = arr[j];
arr[j] = arr[j +1];
arr[j +1] = temp;
}
}
}
... | int main() {
// Test case 1
tuple test1[] = {{"Amana", "28"}, {"Zenat", "30"}, {"Abhishek", "29"}, {"Nikhil", "21"}, {"B", "C"}};
tuple expected1[] = {{"Abhishek", "29"}, {"Amana", "28"}, {"B", "C"}, {"Nikhil", "21"}, {"Zenat", "30"}};
func0(test1, 5);
for(int i = 0; i < 5; i++) {
asse... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r14
test %esi,%esi
jle 11e8 <func0+0x5f>
lea -0x1(%rsi),%r13d
lea 0x10(%rdi),%r15
jmp 11fe <func0+0x75>
add $0x10,%rbx
cmp %r12,%rbx
je 11fa <func0+0x71>
mov (%rbx),%rbp
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r14, rdi
test esi, esi
jle short loc_11E8
lea r13d, [rsi-1]
lea r15, [rdi+10h]
jmp short loc_11FE
loc_11AC:
add rbx, 10h
cmp rbx, r12
jz short loc_11FA
loc_11B5:
mov rbp, [rb... | __m128i * func0(__m128i *a1, int a2)
{
int v2; // r13d
__m128i *v3; // rbx
long long v4; // rbp
long long v5; // rax
if ( a2 > 0 )
{
v2 = a2 - 1;
do
{
while ( v2 > 0 )
{
v3 = a1;
do
{
v4 = v3->m128i_i64[0];
if ( (int)strcmp(v3->m128i_i64[0... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R14,RDI
TEST ESI,ESI
JLE 0x001011e8
LEA R13D,[RSI + -0x1]
LEA R15,[RDI + 0x10]
JMP 0x001011fe
LAB_001011ac:
ADD RBX,0x10
CMP RBX,R12
JZ 0x001011fa
LAB_001011b5:
MOV RBP,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x10]
MOV RDI,RBP
CALL 0x... | int8 * func0(int8 *param_1,int param_2)
{
char *__s1;
int8 uVar1;
int iVar2;
int8 *puVar3;
if (0 < param_2) {
param_2 = param_2 + -1;
do {
for (; 0 < param_2; param_2 = param_2 + -1) {
puVar3 = param_1;
do {
__s1 = (char *)*puVar3;
iVar2 = strcmp(__s1,(cha... |
7,250 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* first;
char* second;
} tuple;
| tuple* func0(tuple arr[], int n) {
for(int i = 0; i < n; i++) {
for(int j = 0; j < n - i -1; j++) {
if(strcmp(arr[j].first, arr[j +1].first) > 0) {
tuple temp = arr[j];
arr[j] = arr[j +1];
arr[j +1] = temp;
}
}
}
... | int main() {
// Test case 1
tuple test1[] = {{"Amana", "28"}, {"Zenat", "30"}, {"Abhishek", "29"}, {"Nikhil", "21"}, {"B", "C"}};
tuple expected1[] = {{"Abhishek", "29"}, {"Amana", "28"}, {"B", "C"}, {"Nikhil", "21"}, {"Zenat", "30"}};
func0(test1, 5);
for(int i = 0; i < 5; i++) {
asse... | O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 167d <func0+0x7d>
mov %esi,%r13d
lea 0x10(%rdi),%r15
sub $0x1,%r13d
test %r13d,%r13d
je 167d <func0+0x7d>
nopl 0x0(%rax)
lea -0x1(%r13),%r12d
mov %r14,%... | func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_167D
mov r13d, esi
lea r15, [rdi+10h]
sub r13d, 1
test r13d, r13d
jz short loc_167D
nop dword ptr [rax+00000000h]
loc_1630:
lea r12d, [r13... | __m128i * func0(__m128i *a1, int a2)
{
long long v2; // r13
__m128i *v3; // rbx
long long v4; // rbp
long long v5; // rax
__m128i v6; // xmm0
if ( a2 > 0 )
{
LODWORD(v2) = a2 - 1;
if ( a2 != 1 )
{
do
{
v3 = a1;
v2 = (unsigned int)(v2 - 1);
do
{
... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x0010167d
MOV R13D,ESI
LEA R15,[RDI + 0x10]
SUB R13D,0x1
TEST R13D,R13D
JZ 0x0010167d
NOP dword ptr [RAX]
LAB_00101630:
LEA R12D,[R13 + -0x1]
MOV RBX,R14
MOV R13,R12
SHL R12,0x4
ADD R12,R15
NOP dword ptr [RAX]... | int8 * func0(int8 *param_1,int param_2)
{
char *__s1;
int8 uVar1;
int8 uVar2;
int iVar3;
int8 *puVar4;
ulong uVar5;
uint uVar6;
if (0 < param_2) {
uVar6 = param_2 - 1;
uVar5 = (ulong)uVar6;
while (uVar6 != 0) {
uVar6 = (int)uVar5 - 1;
uVar5 = (ulong)uVar6;
puVar4 = para... |
7,251 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char* first;
char* second;
} tuple;
| tuple* func0(tuple arr[], int n) {
for(int i = 0; i < n; i++) {
for(int j = 0; j < n - i -1; j++) {
if(strcmp(arr[j].first, arr[j +1].first) > 0) {
tuple temp = arr[j];
arr[j] = arr[j +1];
arr[j +1] = temp;
}
}
}
... | int main() {
// Test case 1
tuple test1[] = {{"Amana", "28"}, {"Zenat", "30"}, {"Abhishek", "29"}, {"Nikhil", "21"}, {"B", "C"}};
tuple expected1[] = {{"Abhishek", "29"}, {"Amana", "28"}, {"B", "C"}, {"Nikhil", "21"}, {"Zenat", "30"}};
func0(test1, 5);
for(int i = 0; i < 5; i++) {
asse... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %esi,%esi
jle 1877 <func0+0x87>
mov %esi,%r13d
lea 0x10(%rdi),%r15
sub $0x1,%r13d
test %r13d,%r13d
je 1877 <func0+0x87>
nopl 0x0(%rax)
lea -0x1(%r13),%r12d
mov %r14,%... | func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 8
test esi, esi
jle short loc_1891
mov r13d, esi
lea r15, [rdi+10h]
loc_1830:
cmp r13d, 1
jle short loc_188B
nop word ptr [rax+rax+00000000h]
loc_1840:
lea r12d, [r13-2]
mo... | long long func0(long long a1, int a2)
{
int v2; // r13d
long long v3; // rbx
__m128i v4; // xmm1
if ( a2 > 0 )
{
v2 = a2;
do
{
for ( ; v2 > 1; --v2 )
{
v3 = a1;
do
{
if ( strcmp(*(const char **)v3, *(const char **)(v3 + 16)) > 0 )
{
... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ESI,ESI
JLE 0x00101891
MOV R13D,ESI
LEA R15,[RDI + 0x10]
LAB_00101830:
CMP R13D,0x1
JLE 0x0010188b
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101840:
LEA R12D,[R13 + -0x2]
MOV RBX,R14
SHL R12,0x4
ADD R12,R15
NOP
LAB_00101850:
M... | int8 * func0(int8 *param_1,int param_2)
{
char *__s1;
int8 uVar1;
int8 uVar2;
int iVar3;
int8 *puVar4;
if (0 < param_2) {
do {
for (; 1 < param_2; param_2 = param_2 + -1) {
puVar4 = param_1;
do {
__s1 = (char *)*puVar4;
iVar3 = strcmp(__s1,(char *)puVar4[2])... |
7,252 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (b == 0) {
return "Yes";
}
else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, -1), "Yes") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
cmpl $0x0,-0x8(%rbp)
jne 1189 <func0+0x20>
lea 0xe81(%rip),%rax
jmp 1190 <func0+0x27>
lea 0xe7c(%rip),%rax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
cmp [rbp+var_8], 0
jnz short loc_1189
lea rax, s2; "Yes"
jmp short loc_1190
loc_1189:
lea rax, aNo; "No"
loc_1190:
pop rbp
retn | const char * func0(long long a1, int a2)
{
if ( a2 )
return "No";
else
return "Yes";
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
CMP dword ptr [RBP + -0x8],0x0
JNZ 0x00101189
LEA RAX,[0x102008]
JMP 0x00101190
LAB_00101189:
LEA RAX,[0x10200c]
LAB_00101190:
POP RBP
RET | int * func0(int8 param_1,int param_2)
{
int *puVar1;
if (param_2 == 0) {
puVar1 = &DAT_00102008;
}
else {
puVar1 = &DAT_0010200c;
}
return puVar1;
} |
7,253 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (b == 0) {
return "Yes";
}
else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, -1), "Yes") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
lea 0xece(%rip),%rax
lea 0xecb(%rip),%rdx
cmovne %rdx,%rax
retq
| func0:
endbr64
test esi, esi
lea rax, unk_2004
lea rdx, unk_2008
cmovnz rax, rdx
retn | void * func0(long long a1, int a2)
{
void *result; // rax
result = &unk_2004;
if ( a2 )
return &unk_2008;
return result;
} | func0:
ENDBR64
TEST ESI,ESI
LEA RAX,[0x102004]
LEA RDX,[0x102008]
CMOVNZ RAX,RDX
RET | int * func0(int8 param_1,int param_2)
{
int *puVar1;
puVar1 = &DAT_00102004;
if (param_2 != 0) {
puVar1 = &DAT_00102008;
}
return puVar1;
} |
7,254 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (b == 0) {
return "Yes";
}
else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, -1), "Yes") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
lea 0xebb(%rip),%rdx
lea 0xeb0(%rip),%rax
cmovne %rdx,%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
test esi, esi
lea rdx, unk_2008
lea rax, unk_2004
cmovnz rax, rdx
retn | void * func0(long long a1, int a2)
{
void *result; // rax
result = &unk_2004;
if ( a2 )
return &unk_2008;
return result;
} | func0:
ENDBR64
TEST ESI,ESI
LEA RDX,[0x102008]
LEA RAX,[0x102004]
CMOVNZ RAX,RDX
RET | int * func0(int8 param_1,int param_2)
{
int *puVar1;
puVar1 = &DAT_00102004;
if (param_2 != 0) {
puVar1 = &DAT_00102008;
}
return puVar1;
} |
7,255 | func0 |
#include <assert.h>
#include <string.h>
| char* func0(int a, int b, int c) {
if (b == 0) {
return "Yes";
}
else {
return "No";
}
}
| int main() {
assert(strcmp(func0(2, 0, -1), "Yes") == 0);
assert(strcmp(func0(1, -5, 6), "No") == 0);
assert(strcmp(func0(2, 0, 2), "Yes") == 0);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
lea 0xebb(%rip),%rdx
lea 0xeb0(%rip),%rax
cmovne %rdx,%rax
retq
nopl 0x0(%rax)
| func0:
endbr64
test esi, esi
lea rdx, unk_2004
lea rax, unk_2008
cmovz rax, rdx
retn | void * func0(long long a1, int a2)
{
void *result; // rax
result = &unk_2008;
if ( !a2 )
return &unk_2004;
return result;
} | func0:
ENDBR64
TEST ESI,ESI
LEA RDX,[0x102004]
LEA RAX,[0x102008]
CMOVZ RAX,RDX
RET | int * func0(int8 param_1,int param_2)
{
int *puVar1;
puVar1 = &DAT_00102008;
if (param_2 == 0) {
puVar1 = &DAT_00102004;
}
return puVar1;
} |
7,256 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count++;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
assert(func0(arr1, 5) == 5);
int arr2[] = {8, 4, 2, 1};
assert(func0(arr2, 4) == 6);
int arr3[] = {3, 1, 2};
assert(func0(arr3, 3) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d7 <func0+0x6e>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11cb <func0+0x62>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11D7
loc_1188:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11CB
loc_1193:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) > *(_DWORD *)(4LL * j + a1) )
++v3;
}
}
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d7
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011cb
LAB_00101193:
MOV EAX,dword ptr [RBP + -... | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_c = local_10, local_10 < param_2; local_10 = local_10 + 1) {
while (local_c = local_c + 1, local_c < param_2) {
if (*(int *)(param_1 + (long)local_c * 4) < *(int *)(param_1 + ... |
7,257 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count++;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
assert(func0(arr1, 5) == 5);
int arr2[] = {8, 4, 2, 1};
assert(func0(arr2, 4) == 6);
int arr3[] = {3, 1, 2};
assert(func0(arr3, 3) == 2);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ab <func0+0x42>
lea -0x1(%rsi),%r9d
add $0x1,%r9
mov $0x1,%r8d
mov $0x0,%ecx
jmp 119c <func0+0x33>
add $0x1,%rax
cmp %eax,%esi
jle 1198 <func0+0x2f>
cmp (%rdi,%rax,4),%edx
jle 1186 <func0+0x1d>
add $0x1,%ecx
jmp 1186 <func0+0x1d>
add $0x1,%... | func0:
endbr64
test esi, esi
jle short loc_11A6
mov r9d, esi
mov r8d, 1
mov ecx, 0
jmp short loc_1197
loc_1181:
add rax, 1
cmp esi, eax
jle short loc_1193
loc_1189:
cmp edx, [rdi+rax*4]
jle short loc_1181
add ecx, 1
jmp short loc_1181
loc_1193:
add r8, 1
loc_1197:
... | long long func0(long long a1, int a2)
{
long long v2; // r8
unsigned int v3; // ecx
long long v4; // rax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = 1LL;
v3 = 0;
while ( v2 != a2 )
{
v4 = v2;
do
{
if ( *(_DWORD *)(a1 + 4 * v2 - 4) > *(_DWORD *)(a1 + 4 * v4) )... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a6
MOV R9D,ESI
MOV R8D,0x1
MOV ECX,0x0
JMP 0x00101197
LAB_00101181:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101193
LAB_00101189:
CMP EDX,dword ptr [RDI + RAX*0x4]
JLE 0x00101181
ADD ECX,0x1
JMP 0x00101181
LAB_00101193:
ADD R8,0x1
LAB_00101197:
CMP R8,R9
JZ 0x001011ab
MOV EDX,dword ptr [R... | int func0(long param_1,uint param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
if ((int)param_2 < 1) {
iVar2 = 0;
}
else {
iVar2 = 0;
for (uVar3 = 1; uVar3 != param_2; uVar3 = uVar3 + 1) {
uVar1 = uVar3;
do {
if (*(int *)(param_1 + uVar1 * 4) < *(int *)(param_1 + -4 + uVar3 ... |
7,258 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count++;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
assert(func0(arr1, 5) == 5);
int arr2[] = {8, 4, 2, 1};
assert(func0(arr2, 4) == 6);
int arr3[] = {3, 1, 2};
assert(func0(arr3, 3) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 137e <func0+0x4e>
lea -0x1(%rsi),%r9d
mov $0x1,%ecx
xor %r8d,%r8d
add $0x1,%r9
cmp %r9,%rcx
je 137a <func0+0x4a>
nopl (%rax)
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
nopw 0x0(%rax,%rax,1)
cmp (%rdi,%rax,4),%edx
jle 1369 <func0+0x39>
add $0x1,%... | func0:
endbr64
test esi, esi
jle short loc_12EE
movsxd r9, esi
mov ecx, 1
xor r8d, r8d
cmp rcx, r9
jz short loc_12EA
nop dword ptr [rax+rax+00000000h]
loc_12C0:
mov edx, [rdi+rcx*4-4]
mov rax, rcx
nop word ptr [rax+rax+00000000h]
loc_12D0:
cmp edx, [rdi+rax*4]
jle short ... | long long func0(long long a1, int a2)
{
long long v2; // rcx
unsigned int i; // r8d
long long v4; // rax
if ( a2 <= 0 )
return 0LL;
v2 = 1LL;
for ( i = 0; v2 != a2; ++v2 )
{
v4 = v2;
do
{
if ( *(_DWORD *)(a1 + 4 * v2 - 4) > *(_DWORD *)(a1 + 4 * v4) )
++i;
++v4;
}
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012ee
MOVSXD R9,ESI
MOV ECX,0x1
XOR R8D,R8D
CMP RCX,R9
JZ 0x001012ea
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
NOP word ptr [RAX + RAX*0x1]
LAB_001012d0:
CMP EDX,dword ptr [RDI + RAX*0x4]
JLE 0x001012d9
ADD R8D,0x1
LAB_001012d9:... | int func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
int iVar3;
if (param_2 < 1) {
return 0;
}
lVar2 = 1;
iVar3 = 0;
if ((long)param_2 != 1) {
do {
lVar1 = lVar2;
do {
if (*(int *)(param_1 + lVar1 * 4) < *(int *)(param_1 + -4 + lVar2 * 4)) {
iVar3 = iVa... |
7,259 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count++;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
assert(func0(arr1, 5) == 5);
int arr2[] = {8, 4, 2, 1};
assert(func0(arr2, 4) == 6);
int arr3[] = {3, 1, 2};
assert(func0(arr3, 3) == 2);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 143d <func0+0x12d>
cmp $0x1,%esi
je 143d <func0+0x12d>
push %rbp
lea 0x4(%rdi),%r10
xor %r9d,%r9d
mov $0x1,%ecx
push %rbx
lea -0x1(%rsi),%ebp
mov $0x1,%ebx
nopl 0x0(%rax,%rax,1)
mov %esi,%r8d
mov %ebp,%eax
mov -0x4(%r10),%r11d
sub %ecx,%r8d
... | func0:
endbr64
test esi, esi
jle loc_1248
cmp esi, 1
jz loc_1248
push rbp
mov r11, rdi
lea r8, [rdi+4]
xor r9d, r9d
push rbx
mov ecx, 1
lea ebp, [rsi-1]
mov ebx, 1
xchg ax, ax
loc_1170:
mov edi, esi
mov eax, ebp
mov r10d, [r8-4]
sub edi, ecx
cmp esi, ... | long long func0(long long a1, int a2)
{
const __m128i *v3; // r8
unsigned int v4; // r9d
int v5; // ecx
signed int v6; // r10d
unsigned int v7; // edi
__m128i v8; // xmm0
const __m128i *v9; // rax
__m128i v10; // xmm2
__m128i v11; // xmm3
__m128i v12; // xmm0
int v13; // eax
long long v14; // r... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101248
CMP ESI,0x1
JZ 0x00101248
PUSH RBP
MOV R11,RDI
LEA R8,[RDI + 0x4]
XOR R9D,R9D
PUSH RBX
MOV ECX,0x1
LEA EBP,[RSI + -0x1]
MOV EBX,0x1
NOP
LAB_00101170:
MOV EDI,ESI
MOV EAX,EBP
MOV R10D,dword ptr [R8 + -0x4]
SUB EDI,ECX
CMP ESI,ECX
CMOVLE EDI,EBX
SUB EAX,ECX
CMP EAX,0x2
JBE 0x001... | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
uint uVar3;
int iVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int iVar9;
int *piVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if ((param_2 < 1) || (param_2 == 1)) {
return 0;
}
piVa... |
7,260 | func0 | #include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
... | int main() {
int arr1[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
int arr2[] = {1, 2, 3, 2, 3, 1, 3};
int arr3[] = {5, 7, 2, 7, 5, 2, 5};
assert(func0(arr1, 13) == 5);
assert(func0(arr2, 7) == 3);
assert(func0(arr3, 7) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11f7 <func0+0x8e>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c9 <func0+0x60>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
jmp short loc_11F7
loc_1181:
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11C9
loc_1191:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add ... | long long func0(long long a1, int a2)
{
int i; // [rsp+10h] [rbp-Ch]
char v4; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
v4 = 0;
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * j + a1) )
++v4;
}
if ( (v4 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011f7
LAB_00101181:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c9
LAB_00101191:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword p... | int4 func0(long param_1,int param_2)
{
byte bVar1;
int local_14;
int local_c;
local_14 = 0;
while( true ) {
if (param_2 <= local_14) {
return 0xffffffff;
}
bVar1 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_14 * 4) == *(i... |
7,261 | func0 | #include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
... | int main() {
int arr1[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
int arr2[] = {1, 2, 3, 2, 3, 1, 3};
int arr3[] = {5, 7, 2, 7, 5, 2, 5};
assert(func0(arr1, 13) == 5);
assert(func0(arr2, 7) == 3);
assert(func0(arr3, 7) == 5);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11c4 <func0+0x5b>
push %rbx
lea -0x1(%rsi),%r11d
mov %rdi,%rbx
lea 0x4(%rdi,%r11,4),%r8
mov $0x0,%r9d
jmp 1197 <func0+0x2e>
test $0x1,%dl
jne 11bb <func0+0x52>
lea 0x1(%r9),%rax
cmp %r11,%r9
je 11ca <func0+0x61>
mov %rax,%r9
mov %r9d,%r10d
mov... | func0:
endbr64
test esi, esi
jle short loc_11BE
mov r11d, esi
lea eax, [rsi-1]
lea r8, [rdi+rax*4+4]
mov r9d, 0
jmp short loc_1192
loc_1184:
test dl, 1
jnz short loc_11B6
add r9, 1
cmp r9, r11
jz short loc_11C4
loc_1192:
mov r10d, r9d
mov esi, [rdi+r9*4]
mov ra... | long long func0(_DWORD *a1, int a2)
{
long long i; // r9
_DWORD *v3; // rax
char v4; // dl
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
for ( i = 0LL; i != a2; ++i )
{
v3 = a1;
v4 = 0;
do
v4 += a1[i] == *v3++;
while ( v3 != &a1[a2 - 1 + 1] );
if ( (v4 & 1) != 0 )
return (unsigne... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011be
MOV R11D,ESI
LEA EAX,[RSI + -0x1]
LEA R8,[RDI + RAX*0x4 + 0x4]
MOV R9D,0x0
JMP 0x00101192
LAB_00101184:
TEST DL,0x1
JNZ 0x001011b6
ADD R9,0x1
CMP R9,R11
JZ 0x001011c4
LAB_00101192:
MOV R10D,R9D
MOV ESI,dword ptr [RDI + R9*0x4]
MOV RAX,RDI
MOV EDX,0x0
LAB_001011a1:
CMP ESI,dwor... | int func0(int *param_1,uint param_2)
{
int *piVar1;
bool bVar2;
ulong uVar3;
if ((int)param_2 < 1) {
return -1;
}
uVar3 = 0;
while( true ) {
bVar2 = false;
piVar1 = param_1;
do {
bVar2 = (bool)(bVar2 ^ param_1[uVar3] == *piVar1);
piVar1 = piVar1 + 1;
} while (piVar1 != ... |
7,262 | func0 | #include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
... | int main() {
int arr1[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
int arr2[] = {1, 2, 3, 2, 3, 1, 3};
int arr3[] = {5, 7, 2, 7, 5, 2, 5};
assert(func0(arr1, 13) == 5);
assert(func0(arr2, 7) == 3);
assert(func0(arr3, 7) == 5);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1341 <func0+0x41>
lea -0x1(%rsi),%eax
mov %rdi,%r9
lea 0x4(%rdi,%rax,4),%rsi
nopl 0x0(%rax,%rax,1)
mov (%r9),%r8d
mov %rdi,%rax
xor %edx,%edx
xor %ecx,%ecx
cmp (%rax),%r8d
sete %cl
add $0x4,%rax
add %ecx,%edx
cmp %rsi,%rax
jne 1320 <func0+0x... | func0:
endbr64
test esi, esi
jle short loc_1341
lea eax, [rsi-1]
mov r9, rdi
lea rsi, [rdi+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_1318:
mov r8d, [r9]
mov rax, rdi
xor edx, edx
loc_1320:
xor ecx, ecx
cmp r8d, [rax]
setz cl
add rax, 4
add edx, ecx
cmp rax, rsi
j... | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // r9
long long v3; // rsi
unsigned int v4; // r8d
unsigned int *v5; // rax
char v6; // dl
char v7; // cl
if ( a2 <= 0 )
{
return (unsigned int)-1;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
while ( 1 )
{
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101341
LEA EAX,[RSI + -0x1]
MOV R9,RDI
LEA RSI,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101318:
MOV R8D,dword ptr [R9]
MOV RAX,RDI
XOR EDX,EDX
LAB_00101320:
XOR ECX,ECX
CMP R8D,dword ptr [RAX]
SETZ CL
ADD RAX,0x4
ADD EDX,ECX
CMP RAX,RSI
JNZ 0x00101320
AND EDX,0x1
JNZ... | int func0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
bool bVar3;
int *piVar4;
if (0 < param_2) {
piVar4 = param_1;
do {
bVar3 = false;
piVar2 = param_1;
do {
iVar1 = *piVar2;
piVar2 = piVar2 + 1;
bVar3 = (bool)(bVar3 ^ *piVar4 == iVar1);
} w... |
7,263 | func0 | #include <assert.h>
| int func0(int arr[], int arr_size) {
for (int i = 0; i < arr_size; i++) {
int count = 0;
for (int j = 0; j < arr_size; j++) {
if (arr[i] == arr[j]) {
count++;
}
}
if (count % 2 != 0) {
return arr[i];
}
}
... | int main() {
int arr1[] = {2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2};
int arr2[] = {1, 2, 3, 2, 3, 1, 3};
int arr3[] = {5, 7, 2, 7, 5, 2, 5};
assert(func0(arr1, 13) == 5);
assert(func0(arr2, 7) == 3);
assert(func0(arr3, 7) == 5);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 13c6 <func0+0x106>
mov %esi,%edx
push %r12
lea -0x1(%rsi),%eax
mov %rdi,%r9
shr $0x2,%edx
push %rbp
lea 0x4(%rdi,%rax,4),%r12
mov %rax,%rbp
push %rbx
shl $0x4,%rdx
mov %esi,%ebx
add %rdi,%rdx
and $0xfffffffc,%ebx
mov (%r9),%r8d
cmp $0x3,%e... | func0:
endbr64
test esi, esi
jle loc_13B6
mov edx, esi
push r12
movsxd rax, esi
mov r12d, esi
shr edx, 2
push rbp
mov r8, rdi
mov r9d, esi
shl rdx, 4
push rbx
lea r11d, [rsi-1]
lea rbx, [rdi+rax*4]
add rdx, rdi
and r12d, 0FFFFFFFCh
nop dword ptr [rax+00h]
loc... | long long func0(unsigned int *a1, int a2)
{
const __m128i *v2; // r8
unsigned int v4; // r11d
unsigned int *v5; // rbx
const __m128i *v6; // rdx
unsigned int v7; // r12d
unsigned int v8; // esi
const __m128i *v9; // rax
__m128i v10; // xmm0
__m128i v11; // xmm2
__m128i v12; // xmm1
signed int v13... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013b6
MOV EDX,ESI
PUSH R12
MOVSXD RAX,ESI
MOV R12D,ESI
SHR EDX,0x2
PUSH RBP
MOV R8,RDI
MOV R9D,ESI
SHL RDX,0x4
PUSH RBX
LEA R11D,[RSI + -0x1]
LEA RBX,[RDI + RAX*0x4]
ADD RDX,RDI
AND R12D,0xfffffffc
NOP dword ptr [RAX]
LAB_001012f8:
MOV ESI,dword ptr [RDI]
CMP R11D,0x2
JBE 0x001013b0... | int func0(int *param_1,uint param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
bool bVar6;
int *piVar7;
uint uVar8;
int *piVar9;
byte bVar10;
byte bVar11;
byte bVar12;
byte bVar13;
if ((int)param_2 < 1) {
return -1;
}
piVar9 = param_1;
do {
iVar1 = *piV... |
7,264 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmp(const void *a, const void *b) {
long long num1 = *(const long long*)a;
long long num2 = *(const long long*)b;
return (num1 > num2) - (num1 < num2);
}
| long long func0(int n, int* primes, int primesSize) {
long long* uglies = malloc(n * sizeof(long long));
int* indices = calloc(primesSize, sizeof(int));
long long* values = malloc(primesSize * sizeof(long long));
int i, j;
uglies[0] = 1;
for (i = 0; i < primesSize; i++) {
va... | int main() {
int primes1[] = {2, 7, 13, 19};
int primesSize1 = sizeof(primes1) / sizeof(primes1[0]);
assert(func0(12, primes1, primesSize1) == 32);
assert(func0(10, primes1, primesSize1) == 26);
assert(func0(100, primes1, primesSize1) == 5408);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %edi,-0x34(%rbp)
mov %rsi,-0x40(%rbp)
mov %edx,-0x38(%rbp)
mov -0x34(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x20(%rbp)
mov -0x38(%rbp),%eax
cltq
mov $0x4,%esi
mov %rax,%rdi
callq 10c0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov [rbp+var_40], rsi
mov [rbp+var_38], edx
mov eax, [rbp+var_34]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov eax, [rbp+var_38]
cdqe
mov esi, 4; size
mov rdi, rax; nme... | long long func0(int a1, long long a2, int a3)
{
long long v3; // rdx
char *v4; // rax
int i; // [rsp+10h] [rbp-30h]
int j; // [rsp+10h] [rbp-30h]
int k; // [rsp+14h] [rbp-2Ch]
int m; // [rsp+14h] [rbp-2Ch]
long long v11; // [rsp+18h] [rbp-28h]
_QWORD *ptr; // [rsp+20h] [rbp-20h]
char *v13; // [rsp+28... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x38],EDX
MOV EAX,dword ptr [RBP + -0x34]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x38]
CDQE
MOV ESI,0x4
MOV RDI,RAX
CALL ... | int8 func0(int param_1,long param_2,int param_3)
{
int iVar1;
int8 uVar2;
int8 *__ptr;
void *__ptr_00;
long *__ptr_01;
int *piVar3;
int local_38;
int local_34;
long local_30;
__ptr = (int8 *)malloc((long)param_1 << 3);
__ptr_00 = calloc((long)param_3,4);
__ptr_01 = (long *)malloc((long)param... |
7,265 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmp(const void *a, const void *b) {
long long num1 = *(const long long*)a;
long long num2 = *(const long long*)b;
return (num1 > num2) - (num1 < num2);
}
| long long func0(int n, int* primes, int primesSize) {
long long* uglies = malloc(n * sizeof(long long));
int* indices = calloc(primesSize, sizeof(int));
long long* values = malloc(primesSize * sizeof(long long));
int i, j;
uglies[0] = 1;
for (i = 0; i < primesSize; i++) {
va... | int main() {
int primes1[] = {2, 7, 13, 19};
int primesSize1 = sizeof(primes1) / sizeof(primes1[0]);
assert(func0(12, primes1, primesSize1) == 32);
assert(func0(10, primes1, primesSize1) == 26);
assert(func0(100, primes1, primesSize1) == 5408);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,%r15d
mov %rsi,%r13
mov %edx,%ebp
movslq %edi,%rax
shl $0x3,%rax
mov %rax,0x8(%rsp)
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r14
movslq %ebp,%rbx
mov $0x4,%esi
mov %rbx,%r... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r15d, edi
mov r13, rsi
mov ebp, edx
movsxd rax, edi
shl rax, 3
mov [rsp+48h+var_40], rax
mov rdi, rax
call _malloc
mov r14, rax
movsxd rbx, ebp
mov esi, 4
mov rdi, rbx
cal... | long long func0(int a1, long long a2, int a3)
{
_QWORD *v5; // r14
long long v6; // r12
long long *v7; // rbx
long long v8; // rax
_QWORD *v9; // rdi
long long v10; // rdx
long long *v11; // rax
long long v12; // rax
long long v13; // r9
int v14; // ecx
long long v15; // rbp
long long v17; // [... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R15D,EDI
MOV R13,RSI
MOV EBP,EDX
MOVSXD RAX,EDI
SHL RAX,0x3
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,RAX
CALL 0x001010d0
MOV R14,RAX
MOVSXD RBX,EBP
MOV ESI,0x4
MOV RDI,RBX
CALL 0x001010c0
MOV R12,RAX
LEA RDI,[RBX*0x8]
CALL 0x001010d0
MOV... | int8 func0(int param_1,long param_2,uint param_3)
{
int iVar1;
int8 uVar2;
int8 *__ptr;
void *__ptr_00;
long *__ptr_01;
ulong uVar3;
long *plVar4;
long lVar5;
int iVar6;
long lVar7;
long *plVar8;
__ptr = (int8 *)malloc((long)param_1 * 8);
__ptr_00 = calloc((long)(int)param_3,4);
__ptr_01... |
7,266 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmp(const void *a, const void *b) {
long long num1 = *(const long long*)a;
long long num2 = *(const long long*)b;
return (num1 > num2) - (num1 < num2);
}
| long long func0(int n, int* primes, int primesSize) {
long long* uglies = malloc(n * sizeof(long long));
int* indices = calloc(primesSize, sizeof(int));
long long* values = malloc(primesSize * sizeof(long long));
int i, j;
uglies[0] = 1;
for (i = 0; i < primesSize; i++) {
va... | int main() {
int primes1[] = {2, 7, 13, 19};
int primesSize1 = sizeof(primes1) / sizeof(primes1[0]);
assert(func0(12, primes1, primesSize1) == 32);
assert(func0(10, primes1, primesSize1) == 26);
assert(func0(100, primes1, primesSize1) == 5408);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
movslq %edi,%r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
movslq %edx,%rbp
push %rbx
mov %rbp,%rbx
sub $0x18,%rsp
mov %r14d,0xc(%rsp)
shl $0x3,%r14
mov %r14,%rdi
callq 10d0 <malloc@plt>
mov $0x4,%esi
mov %rbp,%rdi
mov %rax,%r13
callq 10c0 <c... | func0:
endbr64
push r15
push r14
movsxd r14, edi
push r13
lea r10, ds:0[r14*8]
push r12
mov rdi, r10
mov r12, rsi
push rbp
push rbx
mov ebx, edx
sub rsp, 18h
mov [rsp+48h+var_3C], r14d
movsxd r14, ebx
mov [rsp+48h+var_48], r10
call _malloc
mov esi, 4
mov rdi, r... | long long func0(int a1, long long a2, int a3)
{
long long v4; // r14
_QWORD *v5; // r13
long long v6; // r15
long long v7; // rax
long long v8; // r10
long long *v10; // rbp
long long v11; // rax
_QWORD *v12; // rdi
long long v13; // r8
long long v14; // r9
long long *v15; // rax
long long v16;... | func0:
ENDBR64
PUSH R15
PUSH R14
MOVSXD R14,EDI
PUSH R13
LEA R10,[R14*0x8]
PUSH R12
MOV RDI,R10
MOV R12,RSI
PUSH RBP
PUSH RBX
MOV EBX,EDX
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],R14D
MOVSXD R14,EBX
MOV qword ptr [RSP],R10
CALL 0x001010d0
MOV ESI,0x4
MOV RDI,R14
MOV R13,RAX
CALL 0x001010c0
LEA RDI,[R14*0x8]
MOV R15,RAX
C... | int8 func0(int param_1,long param_2,int param_3)
{
int iVar1;
int8 uVar2;
int8 *__ptr;
void *__ptr_00;
long *__ptr_01;
size_t sVar3;
long *plVar4;
long lVar5;
int iVar6;
long lVar7;
long *plVar8;
long lVar9;
size_t __nmemb;
__nmemb = (size_t)param_3;
__ptr = (int8 *)malloc((long)param_... |
7,267 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int cmp(const void *a, const void *b) {
long long num1 = *(const long long*)a;
long long num2 = *(const long long*)b;
return (num1 > num2) - (num1 < num2);
}
| long long func0(int n, int* primes, int primesSize) {
long long* uglies = malloc(n * sizeof(long long));
int* indices = calloc(primesSize, sizeof(int));
long long* values = malloc(primesSize * sizeof(long long));
int i, j;
uglies[0] = 1;
for (i = 0; i < primesSize; i++) {
va... | int main() {
int primes1[] = {2, 7, 13, 19};
int primesSize1 = sizeof(primes1) / sizeof(primes1[0]);
assert(func0(12, primes1, primesSize1) == 32);
assert(func0(10, primes1, primesSize1) == 26);
assert(func0(100, primes1, primesSize1) == 5408);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
movslq %edi,%r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
movslq %edx,%rbp
push %rbx
mov %rbp,%rbx
sub $0x18,%rsp
mov %r14d,0xc(%rsp)
shl $0x3,%r14
mov %r14,%rdi
callq 10d0 <malloc@plt>
mov %rbp,%rdi
mov $0x4,%esi
mov %rax,%r13
callq 10c0 <c... | func0:
endbr64
push r15
movsxd r8, edi
push r14
push r13
mov r13, rsi
push r12
push rbp
movsxd rbp, edx
push rbx
mov r15, rbp
sub rsp, 18h
mov [rsp+48h+var_3C], r8d
shl r8, 3
mov rdi, r8; size
mov [rsp+48h+var_48], r8
call _malloc
mov esi, 4; size
mov rdi, rbp;... | long long func0(int a1, long long a2, int a3)
{
size_t v4; // rbp
_QWORD *v6; // r14
char *v7; // r12
long long *v8; // rax
long long v9; // r8
long long *v11; // rbx
long long v12; // rax
__m128i v13; // xmm0
__m128i v14; // xmm1
signed int v15; // eax
long long v16; // rdi
long long v17; // r... | func0:
ENDBR64
PUSH R15
MOVSXD R8,EDI
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
MOVSXD RBP,EDX
PUSH RBX
MOV R15,RBP
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],R8D
SHL R8,0x3
MOV RDI,R8
MOV qword ptr [RSP],R8
CALL 0x001010d0
MOV ESI,0x4
MOV RDI,RBP
MOV R14,RAX
CALL 0x001010c0
LEA RDI,[RBP*0x8]
MOV R12,RAX
CALL 0x00101... | int8 func0(int param_1,long param_2,uint param_3)
{
long *plVar1;
int *piVar2;
int iVar3;
int8 uVar4;
int iVar5;
int iVar6;
uint uVar7;
int8 *__ptr;
void *__ptr_00;
long *__ptr_01;
long lVar8;
long *plVar9;
long lVar10;
int iVar11;
size_t __nmemb;
long *plVar12;
__nmemb = (size_t)(... |
7,268 | func0 |
#include <assert.h>
| int func0(int n, int k) {
int arr[n];
int i = 0;
int odd = 1;
while (odd <= n) {
arr[i] = odd;
i += 1;
odd += 2;
}
int even = 2;
while (even <= n) {
arr[i] = even;
i += 1;
even += 2;
}
return arr[k - 1];
}
| int main() {
assert(func0(8,5) == 2);
assert(func0(7,2) == 3);
assert(func0(5,2) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %esi,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rsi
mov -0x44(%rbp),%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
movslq %eax,%rdx
mov... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_34], edi
mov [rbp+var_38], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rsi, rax
mov eax, [rbp+var_34]
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea rdx, ds:0[rax*... | long long func0(int a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
_BYTE v5[8]; // [rsp+8h] [rbp-40h] BYREF
int v6; // [rsp+10h] [rbp-38h]
int v7; // [rsp+14h] [rbp-34h]
int v8; // [rsp+24h] [rbp-24h]
int i; // [rsp+28h] [rbp-20h]
int j; // [rsp+2Ch] [rbp-1Ch]
long long v11; // [rsp+30h... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x34],EDI
MOV dword ptr [RBP + -0x38],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA RDX,[RAX*0x4... | int4 func0(int param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_48 [8];
int local_40;
int local_3c;
int local_2c;
int local_28;
int local_24;
long local_20;
int *local_18;
long local_10;
local_3c = param_1;
local_40 = param_2;
local_10 = *(l... |
7,269 | func0 |
#include <assert.h>
| int func0(int n, int k) {
int arr[n];
int i = 0;
int odd = 1;
while (odd <= n) {
arr[i] = odd;
i += 1;
odd += 2;
}
int even = 2;
while (even <= n) {
arr[i] = even;
i += 1;
even += 2;
}
return arr[k - 1];
}
| int main() {
assert(func0(8,5) == 2);
assert(func0(7,2) == 3);
assert(func0(5,2) == 3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %edi,%rax
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rcx
sub %rax,%rcx
mov %rcx,%rax
cmp %rax,%rsp
je ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov ecx, edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, edi
lea rax, ds:0Fh[rax*4]
mov rdi, rax
and rdi, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11A4:
cmp rsp... | long long func0(int a1, int a2)
{
long long v3; // rax
__int16 v4; // di
signed long long v5; // rax
void *v6; // rsp
int *v7; // rdx
int v8; // eax
unsigned int v9; // eax
int *v10; // rdx
int v11; // eax
_DWORD v14[2]; // [rsp+8h] [rbp-10h] BYREF
unsigned long long v15; // [rsp+10h] [rbp-8h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV ECX,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,EDI
LEA RAX,[0xf + RAX*0x4]
MOV RDI,RAX
AND RDI,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011a4:
CMP RSP,RDX
JZ 0x001011bb
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0... | int4 func0(int param_1,int param_2)
{
long lVar1;
int iVar2;
ulong uVar3;
int *piVar4;
int1 *puVar5;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = (long)param_1 * 4 + 0xf;
for (puVar5 = auStack_18; puVar5 != auStack_18 + -(uVar3 & 0xf... |
7,270 | func0 |
#include <assert.h>
| int func0(int n, int k) {
int arr[n];
int i = 0;
int odd = 1;
while (odd <= n) {
arr[i] = odd;
i += 1;
odd += 2;
}
int even = 2;
while (even <= n) {
arr[i] = even;
i += 1;
even += 2;
}
return arr[k - 1];
}
| int main() {
assert(func0(8,5) == 2);
assert(func0(7,2) == 3);
assert(func0(5,2) == 3);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %edi,%rax
mov %rsp,%rcx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je ... | func0:
endbr64
push rbp
mov ecx, edi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, edi
mov rdi, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rdi, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp rsp, rdi
jz ... | long long func0(int a1, int a2)
{
long long v3; // rdx
_DWORD *v4; // rdi
__int16 v5; // dx
signed long long v6; // rdx
void *v7; // rsp
int *v8; // rdx
int v9; // eax
int *v10; // rdx
int v11; // eax
_DWORD v14[1022]; // [rsp+8h] [rbp-1010h] BYREF
_QWORD v15[2]; // [rsp+1008h] [rbp-10h] BYREF
... | func0:
ENDBR64
PUSH RBP
MOV ECX,EDI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,EDI
MOV RDI,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RDI,RAX
AND RDX,-0x10
CMP RSP,RDI
JZ 0x00101275
LAB_00101260:
SUB RSP,0x1000
OR qword ptr [RSP + 0xff8],0... | int4 func0(int param_1,int param_2)
{
long lVar1;
int1 *puVar2;
int iVar3;
ulong uVar4;
int *piVar5;
int1 *puVar6;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar7;
puVar6 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (long)param_1 * 4 + 0xf;
puVar7 ... |
7,271 | func0 |
#include <assert.h>
| int func0(int n, int k) {
int arr[n];
int i = 0;
int odd = 1;
while (odd <= n) {
arr[i] = odd;
i += 1;
odd += 2;
}
int even = 2;
while (even <= n) {
arr[i] = even;
i += 1;
even += 2;
}
return arr[k - 1];
}
| int main() {
assert(func0(8,5) == 2);
assert(func0(7,2) == 3);
assert(func0(5,2) == 3);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movslq %edi,%rax
mov %rsp,%rcx
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%rsp
je ... | func0:
endbr64
push rbp
mov ecx, edi
mov edi, esi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsxd rax, ecx
mov rsi, rsp
lea rax, ds:0Fh[rax*4]
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rsi, rax
and rdx, 0FFFFFFFFFFFFFFF0h
cmp ... | long long func0(int a1, int a2)
{
long long v4; // rdx
_DWORD *v5; // rsi
__int16 v6; // dx
signed long long v7; // rdx
void *v8; // rsp
unsigned int v9; // r9d
unsigned int v10; // esi
__m128i si128; // xmm0
__m128i v12; // xmm1
__m128i *v13; // rax
__m128i v14; // xmm2
unsigned int v15; // ea... | func0:
ENDBR64
PUSH RBP
MOV ECX,EDI
MOV EDI,ESI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSXD RAX,ECX
MOV RSI,RSP
LEA RAX,[0xf + RAX*0x4]
MOV RDX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RDX,-0x10
CMP RSP,RSI
JZ 0x001011b7
LAB_001011a2:
SUB RSP,0x1000
OR qword ptr [RS... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 func0(int param_1,int param_2)
{
long lVar1;
int *puVar2;
int iVar3;
int iVar4;
int iVar5;
int *piVar6;
int *piVar7;
int iVar8;
ulong uVar9;
int *puVar10;
uint uVar12;
uint uVar13;
uint uVar14;
long i... |
7,272 | func0 |
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n < 0) {
return 0;
}
if (n <= 1) {
return 1;
}
double x = (n * log10((double)n / M_E) + log10(2 * M_PI * n) / 2.0);
return (int)floor(x) + 1;
}
| int main() {
assert(func0(7) == 4);
assert(func0(5) == 3);
assert(func0(4) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jns 11a5 <func0+0x1c>
mov $0x0,%eax
jmp 121d <func0+0x94>
cmpl $0x1,-0x14(%rbp)
jg 11b2 <func0+0x29>
mov $0x1,%eax
jmp 121d <func0+0x94>
cvtsi2sdl -0x14(%rbp),%xmm3
movsd %xmm3,-0x20(%rbp)... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jns short loc_11A8
mov eax, 0
jmp locret_1251
loc_11A8:
cmp [rbp+var_14], 1
jg short loc_11B8
mov eax, 1
jmp locret_1251
loc_11B8:
pxor xmm4, xmm4
cvtsi2sd xmm4, [rbp+var_14]
mo... | long long func0(int a1)
{
double v2; // [rsp+0h] [rbp-20h]
double x; // [rsp+18h] [rbp-8h]
if ( a1 < 0 )
return 0LL;
if ( a1 <= 1 )
return 1LL;
v2 = log10((double)a1 / 2.718281828459045) * (double)a1;
x = log10((double)a1 * 6.283185307179586) / 2.0 + v2;
return (unsigned int)((int)floor(x) + 1);... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JNS 0x001011a8
MOV EAX,0x0
JMP 0x00101251
LAB_001011a8:
CMP dword ptr [RBP + -0x14],0x1
JG 0x001011b8
MOV EAX,0x1
JMP 0x00101251
LAB_001011b8:
PXOR XMM4,XMM4
CVTSI2SD XMM4,dword ptr [RBP + -0x14]
MOVSD qword... | int func0(int param_1)
{
int iVar1;
double dVar2;
double dVar3;
if (param_1 < 0) {
iVar1 = 0;
}
else if (param_1 < 2) {
iVar1 = 1;
}
else {
dVar2 = log10((double)param_1 / DAT_00102058);
dVar3 = log10((double)param_1 * DAT_00102060);
dVar2 = floor(dVar3 / DAT_00102068 + dVar2 * (... |
7,273 | func0 |
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n < 0) {
return 0;
}
if (n <= 1) {
return 1;
}
double x = (n * log10((double)n / M_E) + log10(2 * M_PI * n) / 2.0);
return (int)floor(x) + 1;
}
| int main() {
assert(func0(7) == 4);
assert(func0(5) == 3);
assert(func0(4) == 2);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
test %edi,%edi
js 1246 <func0+0xdd>
mov $0x1,%eax
cmp $0x1,%edi
jle 1246 <func0+0xdd>
sub $0x18,%rsp
pxor %xmm5,%xmm5
cvtsi2sd %edi,%xmm5
movsd %xmm5,(%rsp)
movapd %xmm5,%xmm0
divsd 0xed3(%rip),%xmm0
callq 1070 <log10@plt>
movsd %xmm0,0x8(%rsp)
movsd (%rsp),%xmm6... | func0:
endbr64
mov eax, 0
test edi, edi
js locret_1241
mov eax, 1
cmp edi, 1
jle locret_1241
push rbx
sub rsp, 10h
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
movsd [rsp+18h+var_10], xmm0
divsd xmm0, cs:qword_2050
call _log10
movq rbx, xmm0
movsd xmm0, [rsp+18h+var_10]
mulsd xmm0,... | long long func0(int a1)
{
long long result; // rax
double v2; // rbx
__m128d v3; // xmm0
double v4; // xmm3_8
__m128d v5; // xmm1
result = 0LL;
if ( a1 >= 0 )
{
result = 1LL;
if ( a1 > 1 )
{
v2 = log10((double)a1 / 2.718281828459045);
v3.m128d_f64[0] = (double)a1 * v2 + log10((... | func0:
ENDBR64
MOV EAX,0x0
TEST EDI,EDI
JS 0x00101241
MOV EAX,0x1
CMP EDI,0x1
JLE 0x00101241
PUSH RBX
SUB RSP,0x10
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MOVSD qword ptr [RSP + 0x8],XMM0
DIVSD XMM0,qword ptr [0x00102050]
CALL 0x00101070
MOVQ RBX,XMM0
MOVSD XMM0,qword ptr [RSP + 0x8]
MULSD XMM0,qword ptr [0x00102058]
CALL 0x0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(int param_1)
{
int iVar1;
double dVar2;
double dVar3;
double dVar4;
iVar1 = 0;
if ((-1 < param_1) && (iVar1 = 1, 1 < param_1)) {
dVar2 = (double)param_1;
dVar3 = log10(dVar2 / _DAT_00102050);
dVar... |
7,274 | func0 |
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n < 0) {
return 0;
}
if (n <= 1) {
return 1;
}
double x = (n * log10((double)n / M_E) + log10(2 * M_PI * n) / 2.0);
return (int)floor(x) + 1;
}
| int main() {
assert(func0(7) == 4);
assert(func0(5) == 3);
assert(func0(4) == 2);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
js 12f0 <func0+0x20>
cmp $0x1,%edi
jle 12e8 <func0+0x18>
jmpq 1210 <func0.part.0>
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
xchg %ax,%ax
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
pxor xmm5, xmm5
sub rsp, 18h
cvtsi2sd xmm5, edi
movapd xmm0, xmm5
movsd [rsp+18h+var_18], xmm5
divsd xmm0, cs:qword_2050
call _log10
movsd xmm6, [rsp+18h+var_18]
mulsd xmm6, cs:qword_2058
movsd [rsp+18h+var_10], xmm0
movapd xmm0, xmm6
call _log10
movsd xmm5, [rsp+18h+var_18]
mul... | long long func0_part_0(int a1)
{
__m128d v1; // xmm0
__m128d v2; // xmm1
double v4; // [rsp+8h] [rbp-10h]
v4 = log10((double)a1 / 2.718281828459045);
v1.m128d_f64[0] = (double)a1 * v4 + log10((double)a1 * 6.283185307179586) * 0.5;
if ( fabs(v1.m128d_f64[0]) < 4.503599627370496e15 )
{
v2 = 0LL;
v... | func0.part.0:
PXOR XMM5,XMM5
SUB RSP,0x18
CVTSI2SD XMM5,EDI
MOVAPD XMM0,XMM5
MOVSD qword ptr [RSP],XMM5
DIVSD XMM0,qword ptr [0x00102050]
CALL 0x00101070
MOVSD XMM6,qword ptr [RSP]
MULSD XMM6,qword ptr [0x00102058]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVAPD XMM0,XMM6
CALL 0x00101070
MOVSD XMM5,qword ptr [RSP]
MULSD XMM5,q... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0_part_0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
dVar3 = (double)param_1;
dVar1 = log10(dVar3 / _DAT_00102050);
dVar2 = log10(dVar3 * _DAT_00102058);
dVar1 = dVar3 * dVar1 + dVar2 * _DAT_0010... |
7,275 | func0 |
#include <assert.h>
#include <math.h>
| int func0(int n) {
if (n < 0) {
return 0;
}
if (n <= 1) {
return 1;
}
double x = (n * log10((double)n / M_E) + log10(2 * M_PI * n) / 2.0);
return (int)floor(x) + 1;
}
| int main() {
assert(func0(7) == 4);
assert(func0(5) == 3);
assert(func0(4) == 2);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
js 13b0 <func0+0xe0>
mov $0x1,%eax
cmp $0x1,%edi
jle 13b0 <func0+0xe0>
pxor %xmm5,%xmm5
sub $0x18,%rsp
cvtsi2sd %edi,%xmm5
movapd %xmm5,%xmm0
movsd %xmm5,(%rsp)
divsd 0xd6f(%rip),%xmm0
callq 1070 <log10@plt>
movsd (%rsp),%xmm6
mulsd 0xd65(%rip),%xm... | func0_part_0:
pxor xmm5, xmm5
sub rsp, 18h
cvtsi2sd xmm5, edi
movapd xmm0, xmm5
movsd [rsp+18h+var_18], xmm5
divsd xmm0, cs:qword_2058; x
call _log10
movsd xmm6, [rsp+18h+var_18]
mulsd xmm6, cs:qword_2060
movsd [rsp+18h+var_10], xmm0
movapd xmm0, xmm6; x
call _log10
movsd xmm5, [rsp+18h+var_1... | long long func0_part_0(int a1)
{
__m128d v1; // xmm0
__m128d v2; // xmm1
double v4; // [rsp+8h] [rbp-10h]
v4 = log10((double)a1 / 2.718281828459045);
v1.m128d_f64[0] = (double)a1 * v4 + log10((double)a1 * 6.283185307179586) * 0.5;
if ( fabs(v1.m128d_f64[0]) < 4.503599627370496e15 )
{
v2 = 0LL;
v... | func0.part.0:
PXOR XMM5,XMM5
SUB RSP,0x18
CVTSI2SD XMM5,EDI
MOVAPD XMM0,XMM5
MOVSD qword ptr [RSP],XMM5
DIVSD XMM0,qword ptr [0x00102058]
CALL 0x00101070
MOVSD XMM6,qword ptr [RSP]
MULSD XMM6,qword ptr [0x00102060]
MOVSD qword ptr [RSP + 0x8],XMM0
MOVAPD XMM0,XMM6
CALL 0x00101070
MOVSD XMM5,qword ptr [RSP]
MULSD XMM5,q... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0_part_0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
dVar3 = (double)param_1;
dVar1 = log10(dVar3 / _DAT_00102058);
dVar2 = log10(dVar3 * _DAT_00102060);
dVar1 = dVar3 * dVar1 + dVar2 * _DAT_0010... |
7,276 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int dep[], int n) {
qsort(arr, n, sizeof(int), compare);
qsort(dep, n, sizeof(int), compare);
int plat_needed = 1, result = 1;
int i = 1, j = 0;
while (i < n && j < n) {
if (arr[i] <= dep[j]) {
plat_needed++;
i++;
... | int main() {
int arr1[] = {900, 940, 950, 1100, 1500, 1800};
int dep1[] = {910, 1200, 1120, 1130, 1900, 2000};
assert(func0(arr1, dep1, 6) == 3);
int arr2[] = {100, 200, 300, 400};
int dep2[] = {700, 800, 900, 1000};
assert(func0(arr2, dep2, 4) == 4);
int arr3[] = {5, 6, 7... | 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,%rsi
mov -0x18(%rbp),%rax
lea -0x4a(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 1070 <qsort@plt>
mov -0x24(%rbp),%eax
movslq %eax,%rs... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+base], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov eax, [rbp+var_24]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov ... | long long func0(void *a1, void *a2, int a3)
{
int v5; // [rsp+20h] [rbp-10h]
int v6; // [rsp+24h] [rbp-Ch]
int v7; // [rsp+28h] [rbp-8h]
int v8; // [rsp+2Ch] [rbp-4h]
qsort(a1, a3, 4uLL, compare);
qsort(a2, a3, 4uLL, compare);
v5 = 1;
v6 = 1;
v7 = 1;
v8 = 0;
while ( v7 < a3 && v8 < a3 )
{
... | 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 RSI,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x101189]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x00101070
MOV EAX,dword ptr [RBP + ... | int func0(void *param_1,void *param_2,int param_3)
{
int local_18;
int local_14;
int local_10;
int local_c;
qsort(param_1,(long)param_3,4,compare);
qsort(param_2,(long)param_3,4,compare);
local_18 = 1;
local_14 = 1;
local_10 = 1;
local_c = 0;
while ((local_10 < param_3 && (local_c < param_3)))... |
7,277 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int dep[], int n) {
qsort(arr, n, sizeof(int), compare);
qsort(dep, n, sizeof(int), compare);
int plat_needed = 1, result = 1;
int i = 1, j = 0;
while (i < n && j < n) {
if (arr[i] <= dep[j]) {
plat_needed++;
i++;
... | int main() {
int arr1[] = {900, 940, 950, 1100, 1500, 1800};
int dep1[] = {910, 1200, 1120, 1130, 1900, 2000};
assert(func0(arr1, dep1, 6) == 3);
int arr2[] = {100, 200, 300, 400};
int dep2[] = {700, 800, 900, 1000};
assert(func0(arr2, dep2, 4) == 4);
int arr3[] = {5, 6, 7... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%r12
mov %edx,%ebx
movslq %edx,%r13
lea -0x29(%rip),%rcx
mov $0x4,%edx
mov %r13,%rsi
callq 1070 <qsort@plt>
lea -0x3d(%rip),%rcx
mov $0x4,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 1070 <qs... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbp, rdi
mov r12, rsi
mov ebx, edx
movsxd r13, edx
lea r14, compare
mov rcx, r14
mov edx, 4
mov rsi, r13
call _qsort
mov rcx, r14
mov edx, 4
mov rsi, r13
mov rdi, r12
call _qsort
cmp ebx... | long long func0(long long a1, long long a2, int a3)
{
long long v5; // r13
int v6; // edx
int v7; // eax
int v8; // r8d
int v9; // esi
int v10; // ecx
v5 = a3;
qsort(a1, a3, 4LL, compare);
qsort(a2, v5, 4LL, compare);
if ( a3 <= 1 )
{
return 1;
}
else
{
v6 = 0;
v7 = 1;
v8 =... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV R12,RSI
MOV EBX,EDX
MOVSXD R13,EDX
LEA R14,[0x101189]
MOV RCX,R14
MOV EDX,0x4
MOV RSI,R13
CALL 0x00101070
MOV RCX,R14
MOV EDX,0x4
MOV RSI,R13
MOV RDI,R12
CALL 0x00101070
CMP EBX,0x1
JLE 0x0010121f
MOV EDX,0x0
MOV EAX,0x1
MOV R8D,0x1
MOV ESI,0x1... | int func0(void *param_1,void *param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
qsort(param_1,(long)param_3,4,compare);
qsort(param_2,(long)param_3,4,compare);
if (param_3 < 2) {
iVar5 = 1;
}
else {
iVar3 = 0;
iVar1 = 1;
iVar5 = 1;
iVar4 = 1;
d... |
7,278 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int dep[], int n) {
qsort(arr, n, sizeof(int), compare);
qsort(dep, n, sizeof(int), compare);
int plat_needed = 1, result = 1;
int i = 1, j = 0;
while (i < n && j < n) {
if (arr[i] <= dep[j]) {
plat_needed++;
i++;
... | int main() {
int arr1[] = {900, 940, 950, 1100, 1500, 1800};
int dep1[] = {910, 1200, 1120, 1130, 1900, 2000};
assert(func0(arr1, dep1, 6) == 3);
int arr2[] = {100, 200, 300, 400};
int dep2[] = {700, 800, 900, 1000};
assert(func0(arr2, dep2, 4) == 4);
int arr3[] = {5, 6, 7... | O2 | c | func0:
endbr64
push %r13
movslq %edx,%r13
lea -0x20(%rip),%rcx
mov $0x4,%edx
push %r12
mov %rsi,%r12
mov %r13,%rsi
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <qsort@plt>
mov $0x4,%edx
mov %r13,%rsi
mov %r12,%rdi
lea -0x4d(%rip),%rcx
callq 1070 <qsort@plt>
cmp $... | func0:
endbr64
push r14
lea r14, compare
push r13
movsxd r13, edx
mov rcx, r14
mov edx, 4
push r12
mov r12, rsi
mov rsi, r13
push rbp
mov rbp, rdi
push rbx
call _qsort
mov rcx, r14
mov edx, 4
mov rsi, r13
mov rdi, r12
call _qsort
cmp r13d, 1
jle shor... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // r13
int v5; // edx
int v6; // eax
unsigned int v7; // r8d
int v8; // esi
int v9; // ecx
int v10; // ecx
v3 = a3;
qsort(a1, a3, 4LL, compare);
qsort(a2, v3, 4LL, compare);
if ( (int)v3 <= 1 )
return 1LL;
v5 = 0;
v6 = 1... | func0:
ENDBR64
PUSH R14
LEA R14,[0x101350]
PUSH R13
MOVSXD R13,EDX
MOV RCX,R14
MOV EDX,0x4
PUSH R12
MOV R12,RSI
MOV RSI,R13
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x00101070
MOV RCX,R14
MOV EDX,0x4
MOV RSI,R13
MOV RDI,R12
CALL 0x00101070
CMP R13D,0x1
JLE 0x00101408
MOV RBX,R13
XOR EDX,EDX
MOV EAX,0x1
MOV R8D,0x1
MOV ESI,0x... | int func0(void *param_1,void *param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
qsort(param_1,(long)param_3,4,compare);
qsort(param_2,(long)param_3,4,compare);
if (param_3 < 2) {
return 1;
}
iVar3 = 0;
iVar1 = 1;
iVar5 = 1;
iVar4 = 1;
do {
while (*(int... |
7,279 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
| int func0(int arr[], int dep[], int n) {
qsort(arr, n, sizeof(int), compare);
qsort(dep, n, sizeof(int), compare);
int plat_needed = 1, result = 1;
int i = 1, j = 0;
while (i < n && j < n) {
if (arr[i] <= dep[j]) {
plat_needed++;
i++;
... | int main() {
int arr1[] = {900, 940, 950, 1100, 1500, 1800};
int dep1[] = {910, 1200, 1120, 1130, 1900, 2000};
assert(func0(arr1, dep1, 6) == 3);
int arr2[] = {100, 200, 300, 400};
int dep2[] = {700, 800, 900, 1000};
assert(func0(arr2, dep2, 4) == 4);
int arr3[] = {5, 6, 7... | O3 | c | func0:
endbr64
push %r13
movslq %edx,%r13
lea -0x20(%rip),%rcx
mov $0x4,%edx
push %r12
mov %rsi,%r12
mov %r13,%rsi
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <qsort@plt>
mov $0x4,%edx
mov %r13,%rsi
mov %r12,%rdi
lea -0x4d(%rip),%rcx
callq 1070 <qsort@plt>
mov $... | func0:
endbr64
push r14
lea r14, compare
push r13
movsxd r13, edx
mov rcx, r14; compar
mov edx, 4; size
push r12
mov r12, rsi
mov rsi, r13; nmemb
push rbp
mov rbp, rdi
push rbx
call _qsort
mov rcx, r14; compar
mov edx, 4; size
mov rsi, r13; nmemb
mov rdi, r12; ... | long long func0(void *a1, void *a2, int a3)
{
size_t v3; // r13
int v6; // edx
int v7; // eax
unsigned int v8; // esi
int v9; // ecx
long long v10; // r8
long long v11; // rdi
int v12; // edi
int v13; // r8d
v3 = a3;
qsort(a1, a3, 4uLL, compare);
qsort(a2, v3, 4uLL, compare);
if ( (int)v3 <=... | func0:
ENDBR64
PUSH R14
LEA R14,[0x1012e0]
PUSH R13
MOVSXD R13,EDX
MOV RCX,R14
MOV EDX,0x4
PUSH R12
MOV R12,RSI
MOV RSI,R13
PUSH RBP
MOV RBP,RDI
PUSH RBX
CALL 0x00101070
MOV RCX,R14
MOV EDX,0x4
MOV RSI,R13
MOV RDI,R12
CALL 0x00101070
CMP R13D,0x1
JLE 0x001013a0
MOV RBX,R13
XOR EDX,EDX
MOV EAX,0x1
MOV ESI,0x1
MOV ECX,0x... | int func0(void *param_1,void *param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
long lVar7;
qsort(param_1,(long)param_3,4,compare);
qsort(param_2,(long)param_3,4,compare);
if (param_3 < 2) {
iVar4 = 1;
}
else {
iVar3 = 0;
iVar1 = 1;
iVa... |
7,280 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare_arrays(int* arr1, int* arr2, int len) {
for (int i = 0; i < len; i++) {
if (arr1[i] != arr2[i]) {
return 0;
}
}
return 1;
}
| int* func0(int* xs, int length) {
int* copy = malloc(length * sizeof(int));
for (int i = 0; i < length; i++) {
copy[i] = xs[i];
}
return copy;
}
| int main() {
int xs1[] = {1, 2, 3};
int* result1 = func0(xs1, 3);
assert(compare_arrays(result1, xs1, 3));
int xs2[] = {4, 8, 2, 10, 15, 18};
int* result2 = func0(xs2, 6);
assert(compare_arrays(result2, xs2, 6));
int xs3[] = {4, 5, 6};
int* result3 = func0(xs3, 3);
asser... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1271 <func0+0x62>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rd... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_1271
loc_1240:
mov eax, [rbp+var_C]
cdqe
lea rdx... | _DWORD * func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v4; // [rsp+18h] [rbp-8h]
v4 = malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
v4[i] = *(_DWORD *)(4LL * i + a1);
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101271
LAB_00101240:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA... | void * func0(long param_1,int param_2)
{
void *pvVar1;
int4 local_14;
pvVar1 = malloc((long)param_2 << 2);
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
*(int4 *)((long)pvVar1 + (long)local_14 * 4) =
*(int4 *)(param_1 + (long)local_14 * 4);
}
return pvVar1;
} |
7,281 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare_arrays(int* arr1, int* arr2, int len) {
for (int i = 0; i < len; i++) {
if (arr1[i] != arr2[i]) {
return 0;
}
}
return 1;
}
| int* func0(int* xs, int length) {
int* copy = malloc(length * sizeof(int));
for (int i = 0; i < length; i++) {
copy[i] = xs[i];
}
return copy;
}
| int main() {
int xs1[] = {1, 2, 3};
int* result1 = func0(xs1, 3);
assert(compare_arrays(result1, xs1, 3));
int xs2[] = {4, 8, 2, 10, 15, 18};
int* result2 = func0(xs2, 6);
assert(compare_arrays(result2, xs2, 6));
int xs3[] = {4, 5, 6};
int* result3 = func0(xs3, 3);
asser... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebp,%ebp
jle 121a <func0+0x39>
lea -0x1(%rbp),%esi
mov $0x0,%edx
mov (%rbx,%rdx,4),%ecx
mov %ecx,(%rax,%rdx,4)
mov %rdx,%rcx
add $0x1,%rdx
cmp... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, esi
movsxd rdi, esi
shl rdi, 2
call _malloc
test ebx, ebx
jle short loc_1211
mov esi, ebx
mov edx, 0
loc_1201:
mov ecx, [rbp+rdx*4+0]
mov [rax+rdx*4], ecx
add rdx, 1
cmp rdx, rsi
jnz short loc_... | long long func0(long long a1, int a2)
{
long long result; // rax
long long i; // rdx
result = malloc(4LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_DWORD *)(result + 4 * i) = *(_DWORD *)(a1 + 4 * i);
}
return result;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x00101211
MOV ESI,EBX
MOV EDX,0x0
LAB_00101201:
MOV ECX,dword ptr [RBP + RDX*0x4]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x00101201
LAB_00101211:
ADD RSP,0x8
POP RBX
P... | void func0(long param_1,uint param_2)
{
void *pvVar1;
ulong uVar2;
pvVar1 = malloc((long)(int)param_2 << 2);
if (0 < (int)param_2) {
uVar2 = 0;
do {
*(int4 *)((long)pvVar1 + uVar2 * 4) = *(int4 *)(param_1 + uVar2 * 4);
uVar2 = uVar2 + 1;
} while (uVar2 != param_2);
}
return;
} |
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.