index int64 0 66.5k | func_name stringlengths 2 5.36k | func_dep stringlengths 16 2.19k | func stringlengths 8 55.3k | test stringlengths 0 7.07k | opt stringclasses 4
values | language stringclasses 2
values | asm stringlengths 0 45.4k | ida_asm stringlengths 0 44.7k | ida_pseudo stringlengths 0 44.3k | ghidra_asm stringlengths 0 49.1k | ghidra_pseudo stringlengths 0 64.7k |
|---|---|---|---|---|---|---|---|---|---|---|---|
6,982 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* test_str, int K) {
// Make a copy of the input string to tokenize
char temp_copy[1000];
strncpy(temp_copy, test_str, sizeof(temp_copy));
temp_copy[sizeof(temp_copy) - 1] = '\0';
// Allocate memory for the result
char* res = malloc(strlen(test_str) + 1);
if (!... | int main() {
char* result1 = func0("The person is most value tet", 3);
assert(strcmp(result1, "person is most value") == 0);
free(result1);
char* result2 = func0("If you told me about this ok", 4);
assert(strcmp(result2, "If you me about ok") == 0);
free(result2);
char* result3 = ... | O2 | c | func0:
endbr64
push %r13
mov $0x3e8,%edx
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %esi,%ebx
mov %rdi,%rsi
sub $0x3f8,%rsp
mov %fs:0x28,%rax
mov %rax,0x3e8(%rsp)
xor %eax,%eax
mov %rsp,%r13
mov %r13,%rdi
callq 10f0 <strncpy@plt>
mov %rbp,%rdi
movb $0x0,0x3e7(%rsp)
callq... | func0:
endbr64
push r14
mov edx, 3E8h
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov ebx, esi
mov rsi, rdi
sub rsp, 3F0h
mov rax, fs:28h
mov [rsp+418h+var_30], rax
xor eax, eax
mov r14, rsp
mov rdi, r14
call _strncpy
mov rdi, rbp
mov [rsp+418h+var_... | _BYTE * func0(long long a1, int a2)
{
long long v2; // rax
_BYTE *v3; // rax
_BYTE *v4; // r12
long long i; // rbp
long long v6; // rax
long long v7; // rax
_BYTE *v9; // rax
_BYTE v10[1000]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v11; // [rsp+3E8h] [rbp-30h]
v11 = __readfsqword(0x28u);
... | func0:
ENDBR64
PUSH R14
MOV EDX,0x3e8
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV EBX,ESI
MOV RSI,RDI
SUB RSP,0x3f0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x3e8],RAX
XOR EAX,EAX
MOV R14,RSP
MOV RDI,R14
CALL 0x00101100
MOV RDI,RBP
MOV byte ptr [RSP + 0x3e7],0x0
CALL 0x00101120
LEA RDI,[RAX + 0x1]
CALL ... | char * func0(char *param_1,int param_2)
{
size_t sVar1;
char *__s;
char *pcVar2;
long in_FS_OFFSET;
char acStack_418 [999];
int1 local_31;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
strncpy(acStack_418,param_1,1000);
local_31 = 0;
sVar1 = strlen(param_1);
__s = (char *)malloc(... |
6,983 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* test_str, int K) {
// Make a copy of the input string to tokenize
char temp_copy[1000];
strncpy(temp_copy, test_str, sizeof(temp_copy));
temp_copy[sizeof(temp_copy) - 1] = '\0';
// Allocate memory for the result
char* res = malloc(strlen(test_str) + 1);
if (!... | int main() {
char* result1 = func0("The person is most value tet", 3);
assert(strcmp(result1, "person is most value") == 0);
free(result1);
char* result2 = func0("If you told me about this ok", 4);
assert(strcmp(result2, "If you me about ok") == 0);
free(result2);
char* result3 = ... | O3 | c | func0:
endbr64
push %r13
mov $0x3e8,%edx
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %esi,%ebx
mov %rdi,%rsi
sub $0x3f8,%rsp
mov %fs:0x28,%rax
mov %rax,0x3e8(%rsp)
xor %eax,%eax
mov %rsp,%r13
mov %r13,%rdi
callq 10f0 <strncpy@plt>
mov %rbp,%rdi
movb $0x0,0x3e7(%rsp)
callq... | func0:
endbr64
push r15
mov edx, 3E8h; n
push r14
mov r14d, esi
mov rsi, rdi; src
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 3F8h
mov rax, fs:28h
mov [rsp+428h+var_40], rax
xor eax, eax
mov r15, rsp
mov rdi, r15; dest
call _strncpy
mov rdi,... | const char * func0(char *s, int a2)
{
size_t v2; // r13
const char *v3; // rax
const char *v4; // rbp
char *i; // rbx
size_t v6; // rax
long long v7; // rax
size_t v8; // rax
const char *v9; // rax
char v11[1000]; // [rsp+0h] [rbp-428h] BYREF
unsigned long long v12; // [rsp+3E8h] [rbp-40h]
v12 = ... | func0:
ENDBR64
PUSH R15
MOV EDX,0x3e8
PUSH R14
MOV R14D,ESI
MOV RSI,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x3f8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x3e8],RAX
XOR EAX,EAX
MOV R15,RSP
MOV RDI,R15
CALL 0x00101110
MOV RDI,RBX
MOV byte ptr [RSP + 0x3e7],0x0
CALL 0x00101120
LEA R13,[RAX + ... | char * func0(char *param_1,int param_2)
{
size_t sVar1;
char *__s;
char *__s_00;
size_t sVar2;
long lVar3;
long in_FS_OFFSET;
char acStack_428 [999];
int local_41;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
strncpy(acStack_428,param_1,1000);
local_41 = 0;
sVar1 = strlen(para... |
6,984 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char substring[100];
int start;
int end;
} Occurrence;
| Occurrence func0(const char *text, const char *pattern) {
Occurrence result;
char *pos = strstr(text, pattern);
if (pos) {
result.start = pos - text;
result.end = result.start + strlen(pattern);
strncpy(result.substring, pos, strlen(pattern));
result.substring[strlen(p... | int main() {
Occurrence res1 = func0("python programming, python language", "python");
assert(strcmp(res1.substring, "python") == 0);
assert(res1.start == 0);
assert(res1.end == 6);
Occurrence res2 = func0("python programming,programming language", "programming");
assert(strcmp(res2.subs... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xb8,%rsp
mov %rdi,-0xa8(%rbp)
mov %rsi,-0xb0(%rbp)
mov %rdx,-0xb8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0xb8(%rbp),%rdx
mov -0xb0(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10f0 <strstr@plt>
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0B8h
mov [rbp+var_A8], rdi
mov [rbp+haystack], rsi
mov [rbp+needle], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rdx, [rbp+needle]
mov rax, [rbp+haystack]
mov rsi, rdx; needle
mov rdi, rax; haysta... | _QWORD * func0(_QWORD *a1, const char *a2, const char *a3)
{
size_t v3; // rax
long long v4; // rbx
long long v5; // rbx
long long v6; // rbx
long long v7; // rbx
long long v8; // rbx
long long v9; // rbx
long long v10; // rbx
const char *src; // [rsp+28h] [rbp-98h]
char dest[8]; // [rsp+30h] [rbp-9... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RBP + -0xa8],RDI
MOV qword ptr [RBP + -0xb0],RSI
MOV qword ptr [RBP + -0xb8],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RBP + -0xb8]
MOV RAX,qword ptr [RBP + -0xb0]
MOV RSI,RDX
MOV RDI,RAX
CALL 0... | int8 * func0(int8 *param_1,char *param_2,char *param_3)
{
int iVar1;
char *__src;
size_t sVar2;
long in_FS_OFFSET;
char local_98;
int7 uStack_97;
int8 local_90;
int8 local_88;
int8 local_80;
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int8 local_58;
int8 local_50;
int8 l... |
6,985 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char substring[100];
int start;
int end;
} Occurrence;
| Occurrence func0(const char *text, const char *pattern) {
Occurrence result;
char *pos = strstr(text, pattern);
if (pos) {
result.start = pos - text;
result.end = result.start + strlen(pattern);
strncpy(result.substring, pos, strlen(pattern));
result.substring[strlen(p... | int main() {
Occurrence res1 = func0("python programming, python language", "python");
assert(strcmp(res1.substring, "python") == 0);
assert(res1.start == 0);
assert(res1.end == 6);
Occurrence res2 = func0("python programming,programming language", "programming");
assert(strcmp(res2.subs... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %rdi,%rbx
mov %rsi,%r12
mov %rdx,%rbp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
mov %rdx,%rsi
mov %r12,%rdi
callq 10b0 <strstr@plt>
test %rax,%rax
je 12b7 <func0+0x10e>
mov %rax,%rsi
mov %... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
add rsp, 0FFFFFFFFFFFFFF80h
mov rbx, rdi
mov r13, rsi
mov rbp, rdx
mov rax, fs:28h
mov [rsp+0A8h+var_30], rax
xor eax, eax
mov rsi, rdx
mov rdi, r13
call _strstr
test rax, rax
jz loc_12D5
mov r1... | __m128i * func0(__m128i *a1, long long a2, long long a3)
{
long long v4; // rax
long long v5; // r12
long long v6; // rax
__m128i v8; // [rsp+0h] [rbp-A8h] BYREF
__m128i v9; // [rsp+10h] [rbp-98h] BYREF
__m128i v10; // [rsp+20h] [rbp-88h] BYREF
__m128i v11; // [rsp+30h] [rbp-78h] BYREF
__m128i v12; // [... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
ADD RSP,-0x80
MOV RBX,RDI
MOV R13,RSI
MOV RBP,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV RSI,RDX
MOV RDI,R13
CALL 0x001010f0
TEST RAX,RAX
JZ 0x001012d5
MOV R12,RAX
MOV R14,RAX
SUB R14,R13
MOV dword ptr [RSP + 0x64],R14D
MOV ... | int8 * func0(int8 *param_1,char *param_2,char *param_3)
{
char *pcVar1;
size_t sVar2;
int iVar3;
long in_FS_OFFSET;
int1 local_a8;
int7 uStack_a7;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
... |
6,986 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char substring[100];
int start;
int end;
} Occurrence;
| Occurrence func0(const char *text, const char *pattern) {
Occurrence result;
char *pos = strstr(text, pattern);
if (pos) {
result.start = pos - text;
result.end = result.start + strlen(pattern);
strncpy(result.substring, pos, strlen(pattern));
result.substring[strlen(p... | int main() {
Occurrence res1 = func0("python programming, python language", "python");
assert(strcmp(res1.substring, "python") == 0);
assert(res1.start == 0);
assert(res1.end == 6);
Occurrence res2 = func0("python programming,programming language", "programming");
assert(strcmp(res2.subs... | O2 | c | func0:
endbr64
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
mov %rdx,%rsi
mov %rbx,%rdi
add $0xffffffffffffff80,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
callq 10d0 <strstr@plt>
test %rax,%rax
je 1500 <func0+0xf0>
... | func0:
endbr64
push r14
push r13
mov r13, rdx
push r12
mov r12, rdi
push rbp
push rbx
mov rbx, rsi
mov rsi, rdx
mov rdi, rbx
add rsp, 0FFFFFFFFFFFFFF80h
mov rax, fs:28h
mov [rsp+0A8h+var_30], rax
xor eax, eax
call _strstr
test rax, rax
jz loc_1500
mov r1... | __m128i * func0(__m128i *a1, long long a2, long long a3)
{
long long v4; // rax
long long v5; // rbp
int v6; // r14d
long long v7; // rbx
__m128i v8; // xmm0
__m128i v9; // xmm1
__m128i v10; // xmm2
__int32 v11; // eax
__m128i v12; // xmm3
__m128i v13; // xmm4
__m128i v14; // xmm5
__m128i v16; /... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV RBX,RSI
MOV RSI,RDX
MOV RDI,RBX
ADD RSP,-0x80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
CALL 0x001010d0
TEST RAX,RAX
JZ 0x00101500
MOV R14,RAX
MOV RDI,R13
MOV RBP,RAX
SUB R14,RBX
MOV dword ptr [RSP + 0x6... | int8 * func0(int8 *param_1,char *param_2,char *param_3)
{
char *pcVar1;
size_t sVar2;
int iVar3;
long in_FS_OFFSET;
int1 local_a8;
int7 uStack_a7;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
... |
6,987 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
typedef struct {
char substring[100];
int start;
int end;
} Occurrence;
| Occurrence func0(const char *text, const char *pattern) {
Occurrence result;
char *pos = strstr(text, pattern);
if (pos) {
result.start = pos - text;
result.end = result.start + strlen(pattern);
strncpy(result.substring, pos, strlen(pattern));
result.substring[strlen(p... | int main() {
Occurrence res1 = func0("python programming, python language", "python");
assert(strcmp(res1.substring, "python") == 0);
assert(res1.start == 0);
assert(res1.end == 6);
Occurrence res2 = func0("python programming,programming language", "programming");
assert(strcmp(res2.subs... | O3 | c | func0:
endbr64
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
mov %rdx,%rsi
mov %rbx,%rdi
add $0xffffffffffffff80,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
callq 10d0 <strstr@plt>
test %rax,%rax
je 1500 <func0+0xf0>
... | func0:
endbr64
push r14
push r13
mov r13, rsi
mov rsi, rdx; needle
push r12
mov r12, rdx
push rbp
push rbx
mov rbx, rdi
mov rdi, r13; haystack
add rsp, 0FFFFFFFFFFFFFF80h
mov rax, fs:28h
mov [rsp+0A8h+var_30], rax
xor eax, eax
call _strstr
test rax, rax
jz l... | long long func0(long long a1, const char *a2, const char *a3)
{
char *v4; // rax
char *v5; // rbp
int v6; // r14d
size_t v7; // r12
__m128i v8; // xmm1
__m128i v9; // xmm2
__m128i v10; // xmm3
__m128i v11; // xmm4
__m128i v12; // xmm5
__m128i v13; // xmm6
__m128i v15; // [rsp+0h] [rbp-A8h] BYREF
... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RSI
MOV RSI,RDX
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RDI,R13
ADD RSP,-0x80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
CALL 0x001010d0
TEST RAX,RAX
JZ 0x001014f0
MOV R14,RAX
MOV RDI,R12
MOV RBP,RAX
SUB R14,R13
MOV dword ptr [RSP + 0x6... | int8 * func0(int8 *param_1,char *param_2,char *param_3)
{
char *pcVar1;
size_t sVar2;
int iVar3;
long in_FS_OFFSET;
int local_a8;
int7 uStack_a7;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
i... |
6,988 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char* email) {
const char* regex_pattern = "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$";
regex_t regex;
int ret;
ret = regcomp(®ex, regex_pattern, REG_EXTENDED | REG_NOSUB);
if (ret) {
return "Invalid Email";
}
ret = regexec(®ex, email, 0, NULL,... | int main() {
assert(strcmp(func0("ankitrai326@gmail.com"), "Valid Email") == 0);
assert(strcmp(func0("my.ownsite@ourearth.org"), "Valid Email") == 0);
assert(strcmp(func0("ankitaoie326.com"), "Invalid Email") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xdf9(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x9,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10d0 <regcomp@plt>
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aAZ09AZ09WW23; "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w"...
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 9; cfla... | const char * func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-5Ch]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
if ( regcomp(&preg, "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$", 9) )
return "Invalid Email";
v2 = regexec(&preg, a1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x9
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010d0
MOV dword p... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_58,"^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$",9);
if (iVar1 == 0) {
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)... |
6,989 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char* email) {
const char* regex_pattern = "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$";
regex_t regex;
int ret;
ret = regcomp(®ex, regex_pattern, REG_EXTENDED | REG_NOSUB);
if (ret) {
return "Invalid Email";
}
ret = regexec(®ex, email, 0, NULL,... | int main() {
assert(strcmp(func0("ankitrai326@gmail.com"), "Valid Email") == 0);
assert(strcmp(func0("my.ownsite@ourearth.org"), "Valid Email") == 0);
assert(strcmp(func0("ankitaoie326.com"), "Invalid Email") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x9,%edx
lea 0xe6b(%rip),%rsi
callq 10c0 <regcomp@plt>
mov %eax,%edx
lea 0xe01(%rip),%rax
test %edx,%edx
je 121e <func0+0x55>
mov 0x48(%rsp),... | func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov rdi, rsp
mov edx, 9
lea rsi, aAZ09AZ09WW23; "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w"...
call _regcomp
mov edx, eax
lea rax, aInvalidEmail; "Invalid Emai... | const char * func0(long long a1)
{
int v1; // edx
const char *result; // rax
int v3; // ebx
_QWORD v4[13]; // [rsp+0h] [rbp-68h] BYREF
v4[9] = __readfsqword(0x28u);
v1 = regcomp(v4, "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$", 9LL);
result = "Invalid Email";
if ( !v1 )
{
v3 = regexec(v4, a1, ... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x9
LEA RSI,[0x102080]
CALL 0x001010d0
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JZ 0x0010123e
LAB_00101227:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
J... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$",9);
pcVar2 = "Invalid Email";
if (iVar1 == 0) {
iVar1 = regexec(&rSt... |
6,990 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char* email) {
const char* regex_pattern = "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$";
regex_t regex;
int ret;
ret = regcomp(®ex, regex_pattern, REG_EXTENDED | REG_NOSUB);
if (ret) {
return "Invalid Email";
}
ret = regexec(®ex, email, 0, NULL,... | int main() {
assert(strcmp(func0("ankitrai326@gmail.com"), "Valid Email") == 0);
assert(strcmp(func0("my.ownsite@ourearth.org"), "Valid Email") == 0);
assert(strcmp(func0("ankitaoie326.com"), "Invalid Email") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x9,%edx
lea 0xd9e(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10c0 <regcomp@plt>
test %eax,%eax
je 1310 <func0+0x60>
lea 0xd14(%rip),%rax
mov 0x48(%rsp),... | func0:
endbr64
push r12
mov edx, 9
lea rsi, aAZ09AZ09WW23; "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w"...
push rbp
mov rbp, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12
call _regcomp
test eax, eax
jz short loc_1320
l... | const char * func0(long long a1)
{
const char *result; // rax
int v2; // ebp
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v3[9] = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v3, "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$", 9LL) )
return "Invalid Email";
v2 = regexec(v3, a1, 0LL, 0LL, 0LL);
reg... | func0:
ENDBR64
PUSH R12
MOV EDX,0x9
LEA RSI,[0x102080]
PUSH RBP
MOV RBP,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010d0
TEST EAX,EAX
JZ 0x00101320
LAB_001012f9:
LEA RAX,[0x102004]
LAB_00101300:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword p... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$",9);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t... |
6,991 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char* email) {
const char* regex_pattern = "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$";
regex_t regex;
int ret;
ret = regcomp(®ex, regex_pattern, REG_EXTENDED | REG_NOSUB);
if (ret) {
return "Invalid Email";
}
ret = regexec(®ex, email, 0, NULL,... | int main() {
assert(strcmp(func0("ankitrai326@gmail.com"), "Valid Email") == 0);
assert(strcmp(func0("my.ownsite@ourearth.org"), "Valid Email") == 0);
assert(strcmp(func0("ankitaoie326.com"), "Invalid Email") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x9,%edx
lea 0xd9e(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10c0 <regcomp@plt>
test %eax,%eax
je 1310 <func0+0x60>
lea 0xd14(%rip),%rax
mov 0x48(%rsp),... | func0:
endbr64
push rbp
mov edx, 9; cflags
lea rsi, pattern; "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w"...
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
test eax, eax
jz short loc_1... | const char * func0(char *string)
{
int v2; // ebx
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
if ( regcomp(&_0, "^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$", 9) )
return "Invalid Email";
v2 = regexec(&_0, string, 0LL, 0LL, 0... | func0:
ENDBR64
PUSH RBP
MOV EDX,0x9
LEA RSI,[0x102080]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010d0
TEST EAX,EAX
JZ 0x00101320
LAB_001012f8:
LEA RAX,[0x102004]
LAB_001012ff:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword p... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$",9);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t... |
6,992 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(const int* nums, int size) {
for (int i = 0; i < size; i++) {
if (nums[i] % 2 != i % 2) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {2, 1, 4, 3, 6, 7, 6, 3};
int arr2[] = {4, 1, 2};
int arr3[] = {1, 2, 3};
assert(func0(arr1, sizeof(arr1)/sizeof(arr1[0])));
assert(func0(arr2, sizeof(arr2)/sizeof(arr2[0])));
assert(!func0(arr3, sizeof(arr3)/sizeof(arr3[0])));
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c1 <func0+0x58>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %ed... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11CB
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
... | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) % 2 != i % 2 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cb
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
... | int8 func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 1;
}
if (*(int *)(param_1 + (long)local_c * 4) % 2 != local_c % 2) break;
local_c = local_c + 1;
}
return 0;
} |
6,993 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(const int* nums, int size) {
for (int i = 0; i < size; i++) {
if (nums[i] % 2 != i % 2) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {2, 1, 4, 3, 6, 7, 6, 3};
int arr2[] = {4, 1, 2};
int arr3[] = {1, 2, 3};
assert(func0(arr1, sizeof(arr1)/sizeof(arr1[0])));
assert(func0(arr2, sizeof(arr2)/sizeof(arr2[0])));
assert(!func0(arr3, sizeof(arr3)/sizeof(arr3[0])));
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ae <func0+0x45>
lea -0x1(%rsi),%r8d
mov $0x0,%ecx
jmp 117f <func0+0x16>
mov %rax,%rcx
mov (%rdi,%rcx,4),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
mov %ecx,%esi
shr $0x1f,%esi
lea (%rsi,%rcx,1),%edx
and $... | func0:
endbr64
test esi, esi
jle short loc_11AB
mov esi, esi
mov ecx, 0
loc_1178:
mov eax, [rdi+rcx*4]
mov edx, eax
shr edx, 1Fh
add eax, edx
and eax, 1
sub eax, edx
mov r8d, ecx
shr r8d, 1Fh
lea edx, [r8+rcx]
and edx, 1
sub edx, r8d
cmp eax, edx
jnz sh... | long long func0(long long a1, int a2)
{
long long v2; // rcx
if ( a2 <= 0 )
return 1LL;
v2 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v2) % 2 == (int)v2 % 2 )
{
if ( ++v2 == a2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011ab
MOV ESI,ESI
MOV ECX,0x0
LAB_00101178:
MOV EAX,dword ptr [RDI + RCX*0x4]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
AND EAX,0x1
SUB EAX,EDX
MOV R8D,ECX
SHR R8D,0x1f
LEA EDX,[R8 + RCX*0x1]
AND EDX,0x1
SUB EDX,R8D
CMP EAX,EDX
JNZ 0x001011b1
ADD RCX,0x1
CMP RCX,RSI
JNZ 0x00101178
MOV EA... | int8 func0(long param_1,uint param_2)
{
uint uVar1;
ulong uVar2;
if ((int)param_2 < 1) {
return 1;
}
uVar2 = 0;
do {
uVar1 = (uint)(uVar2 >> 0x1f) & 1;
if (*(int *)(param_1 + uVar2 * 4) % 2 != (uVar1 + (int)uVar2 & 1) - uVar1) {
return 0;
}
uVar2 = uVar2 + 1;
} while (uVar2 !... |
6,994 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(const int* nums, int size) {
for (int i = 0; i < size; i++) {
if (nums[i] % 2 != i % 2) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {2, 1, 4, 3, 6, 7, 6, 3};
int arr2[] = {4, 1, 2};
int arr3[] = {1, 2, 3};
assert(func0(arr1, sizeof(arr1)/sizeof(arr1[0])));
assert(func0(arr2, sizeof(arr2)/sizeof(arr2[0])));
assert(!func0(arr3, sizeof(arr3)/sizeof(arr3[0])));
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1270 <func0+0x40>
sub $0x1,%esi
xor %edx,%edx
jmp 124c <func0+0x1c>
lea 0x1(%rdx),%rax
cmp %rsi,%rdx
je 1270 <func0+0x40>
mov %rax,%rdx
mov (%rdi,%rdx,4),%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %ecx,%eax
and $0x1,%eax
sub %ecx,%eax
mov %edx... | func0:
endbr64
test esi, esi
jle short loc_1268
movsxd rsi, esi
xor edx, edx
jmp short loc_1249
loc_1240:
add rdx, 1
cmp rdx, rsi
jz short loc_1268
loc_1249:
mov eax, [rdi+rdx*4]
mov ecx, eax
shr ecx, 1Fh
add eax, ecx
and eax, 1
sub eax, ecx
mov ecx, edx
and ... | long long func0(long long a1, int a2)
{
long long v2; // rdx
if ( a2 <= 0 )
return 1LL;
v2 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v2) % 2 == (v2 & 1) )
{
if ( ++v2 == a2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101268
MOVSXD RSI,ESI
XOR EDX,EDX
JMP 0x00101249
LAB_00101240:
ADD RDX,0x1
CMP RDX,RSI
JZ 0x00101268
LAB_00101249:
MOV EAX,dword ptr [RDI + RDX*0x4]
MOV ECX,EAX
SHR ECX,0x1f
ADD EAX,ECX
AND EAX,0x1
SUB EAX,ECX
MOV ECX,EDX
AND ECX,0x1
CMP EAX,ECX
JZ 0x00101240
XOR EAX,EAX
RET
LAB_0010... | int8 func0(long param_1,int param_2)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) % 2 != ((uint)lVar1 & 1)) {
return 0;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_2);
}
return 1;
} |
6,995 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(const int* nums, int size) {
for (int i = 0; i < size; i++) {
if (nums[i] % 2 != i % 2) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {2, 1, 4, 3, 6, 7, 6, 3};
int arr2[] = {4, 1, 2};
int arr3[] = {1, 2, 3};
assert(func0(arr1, sizeof(arr1)/sizeof(arr1[0])));
assert(func0(arr2, sizeof(arr2)/sizeof(arr2[0])));
assert(!func0(arr3, sizeof(arr3)/sizeof(arr3[0])));
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1270 <func0+0x40>
sub $0x1,%esi
xor %edx,%edx
jmp 124c <func0+0x1c>
lea 0x1(%rdx),%rax
cmp %rsi,%rdx
je 1270 <func0+0x40>
mov %rax,%rdx
mov (%rdi,%rdx,4),%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %ecx,%eax
and $0x1,%eax
sub %ecx,%eax
mov %edx... | func0:
endbr64
test esi, esi
jle short loc_1178
movsxd rsi, esi
xor edx, edx
jmp short loc_1159
loc_1150:
add rdx, 1
cmp rsi, rdx
jz short loc_1178
loc_1159:
mov eax, [rdi+rdx*4]
mov ecx, eax
shr ecx, 1Fh
add eax, ecx
and eax, 1
sub eax, ecx
mov ecx, edx
and ... | long long func0(long long a1, int a2)
{
long long v2; // rdx
if ( a2 <= 0 )
return 1LL;
v2 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v2) % 2 == (v2 & 1) )
{
if ( a2 == ++v2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101178
MOVSXD RSI,ESI
XOR EDX,EDX
JMP 0x00101159
LAB_00101150:
ADD RDX,0x1
CMP RSI,RDX
JZ 0x00101178
LAB_00101159:
MOV EAX,dword ptr [RDI + RDX*0x4]
MOV ECX,EAX
SHR ECX,0x1f
ADD EAX,ECX
AND EAX,0x1
SUB EAX,ECX
MOV ECX,EDX
AND ECX,0x1
CMP EAX,ECX
JZ 0x00101150
XOR EAX,EAX
RET
LAB_0010... | int8 func0(long param_1,int param_2)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) % 2 != ((uint)lVar1 & 1)) {
return 0;
}
lVar1 = lVar1 + 1;
} while (param_2 != lVar1);
}
return 1;
} |
6,996 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *test_str) {
int res = 0;
const char *vow_list = "aeiou";
int len = strlen(test_str);
for (int idx = 1; idx < len - 1; idx++) {
if (strchr(vow_list, test_str[idx]) == NULL &&
(strchr(vow_list, test_str[idx - 1]) != NULL || strchr(vow_list, test_str[idx + ... | int main() {
assert(func0("bestinstareels") == 7);
assert(func0("partofthejourneyistheend") == 12);
assert(func0("amazonprime") == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x14(%rbp)
lea 0xe61(%rip),%rax
mov %rax,-0x8(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0xc(%rbp)
movl $0x1,-0x10(%rbp)
jmpq 1246 <func0+0xbd>
mov -0x10(%rbp),%eax
m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_14], 0
lea rax, aAeiou; "aeiou"
mov [rbp+var_8], rax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_C], eax
mov [rbp+var_10], 1
jmp loc_1246
loc_11C6:
mov eax, [rbp+var_10]
m... | long long func0(const char *a1)
{
unsigned int v2; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int v4; // [rsp+24h] [rbp-Ch]
v2 = 0;
v4 = strlen(a1);
for ( i = 1; i < v4 - 1; ++i )
{
if ( !strchr("aeiou", a1[i]) && (strchr("aeiou", a1[i - 1]) || strchr("aeiou", a1[i + 1])) )
++v2;
}... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x14],0x0
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x10],0x1
JMP 0x00101246
LAB_001011c6:
MOV E... | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
int local_1c;
int local_18;
local_1c = 0;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
local_18 = 1;
do {
if (iVar1 + -1 <= local_18) {
pcVar3 = strchr("aeiou",(int)*param_1);
if (pcVar3 == (char *)0x0) {
p... |
6,997 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *test_str) {
int res = 0;
const char *vow_list = "aeiou";
int len = strlen(test_str);
for (int idx = 1; idx < len - 1; idx++) {
if (strchr(vow_list, test_str[idx]) == NULL &&
(strchr(vow_list, test_str[idx - 1]) != NULL || strchr(vow_list, test_str[idx + ... | int main() {
assert(func0("bestinstareels") == 7);
assert(func0("partofthejourneyistheend") == 12);
assert(func0("amazonprime") == 5);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r14
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
cmp $0x2,%ebp
jle 11fd <func0+0x94>
mov %r14,%rbx
lea -0x3(%rbp),%eax
lea ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r13, rdi
call _strlen
mov r14, rax
cmp eax, 2
jle short loc_120B
mov rbx, r13
lea eax, [rax-3]
lea r12, [r13+rax+1]
mov r15d, 0
lea rbp, aAeiou; "aeiou"
jmp short loc_11... | long long func0(char *a1)
{
int v1; // eax
int v2; // r14d
char *v3; // rbx
long long v4; // r12
unsigned int v5; // r15d
v1 = strlen();
v2 = v1;
if ( v1 <= 2 )
{
v5 = 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[v1 - 3 + 1];
v5 = 0;
do
{
if ( !strchr("aeiou", (unsign... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R13,RDI
CALL 0x00101070
MOV R14,RAX
CMP EAX,0x2
JLE 0x0010120b
MOV RBX,R13
LEA EAX,[RAX + -0x3]
LEA R12,[R13 + RAX*0x1 + 0x1]
MOV R15D,0x0
LEA RBP,[0x102004]
JMP 0x001011d2
LAB_001011c5:
ADD R15D,0x1
LAB_001011c9:
ADD RBX,0x1
CMP RBX,... | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
int iVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 3) {
iVar5 = 0;
}
else {
iVar5 = 0;
pcVar4 = param_1;
do {
pcVar3 = strchr("aeiou",(int)pcVar4[1]);
if ((pcVar3 == (char... |
6,998 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *test_str) {
int res = 0;
const char *vow_list = "aeiou";
int len = strlen(test_str);
for (int idx = 1; idx < len - 1; idx++) {
if (strchr(vow_list, test_str[idx]) == NULL &&
(strchr(vow_list, test_str[idx - 1]) != NULL || strchr(vow_list, test_str[idx + ... | int main() {
assert(func0("bestinstareels") == 7);
assert(func0("partofthejourneyistheend") == 12);
assert(func0("amazonprime") == 5);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %rax,%r14
cmp $0x2,%eax
jle 1350 <func0+0x120>
lea -0x3(%rax),%eax
mov %r13,%rbx
lea 0xda1(%rip),%rbp
xor %r15d,%r15d
lea 0x1(%r13,%rax,1),%r12
jm... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 8
call _strlen
mov r13, rax
cmp eax, 2
jle loc_1340
lea eax, [rax-3]
mov rbx, r12
lea r15, aAeiou; "aeiou"
xor r14d, r14d
lea rbp, [r12+rax+1]
jmp short loc_1279
lo... | long long func0(char *a1)
{
int v1; // eax
int v2; // r13d
char *v3; // rbx
unsigned int v4; // r14d
long long v5; // rbp
v1 = strlen();
v2 = v1;
if ( v1 <= 2 )
{
v4 = 0;
}
else
{
v3 = a1;
v4 = 0;
v5 = (long long)&a1[v1 - 3 + 1];
do
{
while ( strchr("aeiou", (unsi... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
MOV R13,RAX
CMP EAX,0x2
JLE 0x00101340
LEA EAX,[RAX + -0x3]
MOV RBX,R12
LEA R15,[0x102004]
XOR R14D,R14D
LEA RBP,[R12 + RAX*0x1 + 0x1]
JMP 0x00101279
LAB_00101270:
ADD RBX,0x1
CMP RBX,RBP
JZ 0x001012a7
LAB_00101... | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
int iVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 3) {
iVar5 = 0;
}
else {
iVar5 = 0;
pcVar4 = param_1;
do {
while ((pcVar3 = strchr("aeiou",(int)pcVar4[1]), pcVar3 == (char *)... |
6,999 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
| int func0(const char *test_str) {
int res = 0;
const char *vow_list = "aeiou";
int len = strlen(test_str);
for (int idx = 1; idx < len - 1; idx++) {
if (strchr(vow_list, test_str[idx]) == NULL &&
(strchr(vow_list, test_str[idx - 1]) != NULL || strchr(vow_list, test_str[idx + ... | int main() {
assert(func0("bestinstareels") == 7);
assert(func0("partofthejourneyistheend") == 12);
assert(func0("amazonprime") == 5);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %rax,%r14
cmp $0x2,%eax
jle 1350 <func0+0x120>
lea -0x3(%rax),%eax
mov %r13,%rbx
lea 0xda1(%rip),%rbp
xor %r15d,%r15d
lea 0x1(%r13,%rax,1),%r12
jm... | func0:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 8
call _strlen
mov r14, rax
cmp eax, 2
jle loc_1340
lea eax, [rax-3]
mov rbx, r13
lea rbp, s; "aeiou"
xor r15d, r15d
lea r12, [r13+rax+1]
jmp short loc_1279
loc_127... | long long func0(const char *a1)
{
int v1; // eax
int v2; // r14d
char *v3; // rbx
unsigned int v4; // r15d
long long v5; // r12
v1 = strlen(a1);
v2 = v1;
if ( v1 <= 2 )
{
v4 = 0;
}
else
{
v3 = (char *)a1;
v4 = 0;
v5 = (long long)&a1[v1 - 3 + 1];
do
{
while ( strch... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
MOV R14,RAX
CMP EAX,0x2
JLE 0x00101340
LEA EAX,[RAX + -0x3]
MOV RBX,R13
LEA RBP,[0x102004]
XOR R15D,R15D
LEA R12,[R13 + RAX*0x1 + 0x1]
JMP 0x00101279
LAB_00101270:
ADD RBX,0x1
CMP R12,RBX
JZ 0x001012a7
LAB_00101... | int func0(char *param_1)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
int iVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 3) {
iVar5 = 0;
}
else {
iVar5 = 0;
pcVar4 = param_1;
do {
while ((pcVar3 = strchr("aeiou",(int)pcVar4[1]), pcVar3 == (char *)... |
7,000 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int compare(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int func0(int* arr, int n) {
qsort(arr, n, sizeof(int), compare);
int sum = arr[0];
for (int i = 0; i < n - 1; i++) {
if (arr[i] != arr[i + 1]) {
sum += arr[i + 1];
}
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3, 1, 1, 4, 5, 6};
int arr2[] = {1, 10, 9, 4, 2, 10, 10, 45, 4};
int arr3[] = {12, 10, 9, 45, 2, 10, 10, 45, 10};
assert(func0(arr1, 8) == 21);
assert(func0(arr2, 9) == 71);
assert(func0(arr3, 9) == 78);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rsi
mov -0x18(%rbp),%rax
lea -0x46(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 1070 <qsort@plt>
mov -0x18(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x8(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+base], rdi
mov [rbp+var_1C], esi
mov eax, [rbp+var_1C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov rax, [rbp+base]
mov ... | long long func0(_DWORD *a1, int a2)
{
unsigned int v3; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
qsort(a1, a2, 4uLL, compare);
v3 = *a1;
for ( i = 0; i < a2 - 1; ++i )
{
if ( a1[i] != a1[i + 1] )
v3 += a1[i + 1];
}
return v3;
} | 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]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x101189]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x00101070
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
M... | int func0(int *param_1,int param_2)
{
int local_10;
int local_c;
qsort(param_1,(long)param_2,4,compare);
local_10 = *param_1;
for (local_c = 0; local_c < param_2 + -1; local_c = local_c + 1) {
if (param_1[local_c] != param_1[(long)local_c + 1]) {
local_10 = local_10 + param_1[(long)local_c + 1];... |
7,001 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int compare(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int func0(int* arr, int n) {
qsort(arr, n, sizeof(int), compare);
int sum = arr[0];
for (int i = 0; i < n - 1; i++) {
if (arr[i] != arr[i + 1]) {
sum += arr[i + 1];
}
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3, 1, 1, 4, 5, 6};
int arr2[] = {1, 10, 9, 4, 2, 10, 10, 45, 4};
int arr3[] = {12, 10, 9, 45, 2, 10, 10, 45, 10};
assert(func0(arr1, 8) == 21);
assert(func0(arr2, 9) == 71);
assert(func0(arr3, 9) == 78);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
movslq %esi,%rsi
lea -0x22(%rip),%rcx
mov $0x4,%edx
callq 1070 <qsort@plt>
mov (%rbx),%edx
cmp $0x1,%ebp
jle 11db <func0+0x49>
mov %rbx,%rax
lea -0x2(%rbp),%ecx
lea 0x4(%rbx,%rcx,4),%rdi
mov 0x4(%rax),%... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, esi
movsxd rsi, esi
lea rcx, compare
mov edx, 4
call _qsort
mov edx, [rbx]
cmp ebp, 1
jle short loc_11DB
mov rax, rbx
lea ecx, [rbp-2]
lea rdi, [rbx+rcx*4+4]
loc_11C7:
mov ecx, [rax+4]
lea esi... | long long func0(unsigned int *a1, int a2)
{
unsigned int v2; // edx
unsigned int *v3; // rax
long long v4; // rdi
unsigned int v5; // ecx
qsort(a1, a2, 4LL, compare);
v2 = *a1;
if ( a2 > 1 )
{
v3 = a1;
v4 = (long long)&a1[a2 - 2 + 1];
do
{
v5 = v3[1];
if ( *v3 != v5 )
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,ESI
MOVSXD RSI,ESI
LEA RCX,[0x101189]
MOV EDX,0x4
CALL 0x00101070
MOV EDX,dword ptr [RBX]
CMP EBP,0x1
JLE 0x001011db
MOV RAX,RBX
LEA ECX,[RBP + -0x2]
LEA RDI,[RBX + RCX*0x4 + 0x4]
LAB_001011c7:
MOV ECX,dword ptr [RAX + 0x4]
LEA ESI,[RDX + RCX*0x1]
CMP dwo... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
qsort(param_1,(long)param_2,4,compare);
iVar2 = *param_1;
if (1 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
do {
if (*param_1 != param_1[1]) {
iVar2 = iVar2 + param_1[1];
}
param_1 = param_1 + 1;
... |
7,002 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int compare(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int func0(int* arr, int n) {
qsort(arr, n, sizeof(int), compare);
int sum = arr[0];
for (int i = 0; i < n - 1; i++) {
if (arr[i] != arr[i + 1]) {
sum += arr[i + 1];
}
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3, 1, 1, 4, 5, 6};
int arr2[] = {1, 10, 9, 4, 2, 10, 10, 45, 4};
int arr3[] = {12, 10, 9, 45, 2, 10, 10, 45, 10};
assert(func0(arr1, 8) == 21);
assert(func0(arr2, 9) == 71);
assert(func0(arr3, 9) == 78);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
movslq %esi,%rsi
lea -0x1f(%rip),%rcx
mov $0x4,%edx
push %rbx
mov %rsi,%rbp
mov %rdi,%rbx
sub $0x8,%rsp
callq 1070 <qsort@plt>
mov (%rbx),%r8d
cmp $0x1,%ebp
jle 1377 <func0+0x57>
lea 0x4(%rbx),%rdi
lea -0x2(%rbp),%eax
mov %r8d,%ecx
lea (%rdi,%rax,4),%rsi... | func0:
endbr64
push rbp
movsxd rsi, esi
lea rcx, compare
mov edx, 4
push rbx
mov rbp, rsi
mov rbx, rdi
sub rsp, 8
call _qsort
mov r8d, [rbx]
cmp ebp, 1
jle short loc_1377
lea rdi, [rbx+4]
lea eax, [rbp-2]
mov ecx, r8d
lea rsi, [rdi+rax*4]
jmp short loc_1366
... | long long func0(unsigned int *a1, int a2)
{
unsigned int v3; // r8d
int *v4; // rdi
unsigned int i; // ecx
unsigned int v6; // eax
qsort(a1, a2, 4LL, compare);
v3 = *a1;
if ( a2 > 1 )
{
v4 = (int *)(a1 + 1);
for ( i = v3; ; i = v6 )
{
v6 = *v4;
if ( *v4 != i )
v3 += *v4... | func0:
ENDBR64
PUSH RBP
MOVSXD RSI,ESI
LEA RCX,[0x101310]
MOV EDX,0x4
PUSH RBX
MOV RBP,RSI
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101070
MOV R8D,dword ptr [RBX]
CMP EBP,0x1
JLE 0x00101377
LEA RDI,[RBX + 0x4]
LEA EAX,[RBP + -0x2]
MOV ECX,R8D
LEA RSI,[RDI + RAX*0x4]
JMP 0x00101366
LAB_00101360:
ADD RDI,0x4
MOV ECX,EAX
LAB_0010... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
qsort(param_1,(long)param_2,4,compare);
iVar4 = *param_1;
if (1 < param_2) {
param_1 = param_1 + 1;
piVar1 = param_1 + (param_2 - 2);
iVar3 = iVar4;
while( true ) {
iVar2 = *param_1;
if (iVa... |
7,003 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int compare(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
| int func0(int* arr, int n) {
qsort(arr, n, sizeof(int), compare);
int sum = arr[0];
for (int i = 0; i < n - 1; i++) {
if (arr[i] != arr[i + 1]) {
sum += arr[i + 1];
}
}
return sum;
}
| int main() {
int arr1[] = {1, 2, 3, 1, 1, 4, 5, 6};
int arr2[] = {1, 10, 9, 4, 2, 10, 10, 45, 4};
int arr3[] = {12, 10, 9, 45, 2, 10, 10, 45, 10};
assert(func0(arr1, 8) == 21);
assert(func0(arr2, 9) == 71);
assert(func0(arr3, 9) == 78);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
movslq %esi,%rsi
lea -0x1f(%rip),%rcx
mov $0x4,%edx
push %rbx
mov %rsi,%rbp
mov %rdi,%rbx
sub $0x8,%rsp
callq 1070 <qsort@plt>
lea -0x1(%rbp),%ecx
mov (%rbx),%r8d
test %ecx,%ecx
jle 13af <func0+0xdf>
sub $0x2,%ebp
cmp $0x2,%ebp
jbe 13b9 <func0+0xe9>
mov ... | func0:
endbr64
push rbp
movsxd rsi, esi; nmemb
lea rcx, compare; compar
mov edx, 4; size
push rbx
mov rbp, rsi
mov rbx, rdi
sub rsp, 8
call _qsort
mov ecx, [rbx]
cmp ebp, 1
jle loc_13B5
lea esi, [rbp-1]
sub ebp, 2
cmp ebp, 2
jbe loc_13BE
mov edx, esi
mov ... | long long func0(_DWORD *a1, int a2)
{
unsigned int v4; // ecx
int v5; // esi
_DWORD *v6; // rax
__m128i v7; // xmm1
__m128i v8; // xmm2
__m128i v9; // xmm0
__m128i v10; // xmm1
signed int v11; // eax
long long v12; // rdx
int v13; // edi
int v14; // r8d
int v15; // eax
qsort(a1, a2, 4uLL, co... | func0:
ENDBR64
PUSH RBP
MOVSXD RSI,ESI
LEA RCX,[0x1012c0]
MOV EDX,0x4
PUSH RBX
MOV RBP,RSI
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101070
MOV ECX,dword ptr [RBX]
CMP EBP,0x1
JLE 0x001013b5
LEA ESI,[RBP + -0x1]
SUB EBP,0x2
CMP EBP,0x2
JBE 0x001013be
MOV EDX,ESI
MOV RAX,RBX
PXOR XMM1,XMM1
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RBX
NOP... | uint func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
uint *puVar9;
uint uVar10;
uint *puVar11;
uint uVar12;
uint uVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
qsort(param_1,(l... |
7,004 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int **group;
int *groupSize;
int numGroups;
} PackResult;
int compare_arrays(int a[], int b[], int a_size, int b_size) {
if (a_size != b_size)
return 0;
for (int i = 0; i < a_size; i++) {
... | PackResult* func0(int list1[], int size) {
PackResult *result = malloc(sizeof(PackResult));
result->group = malloc(sizeof(int*) * size);
result->groupSize = malloc(sizeof(int) * size);
result->numGroups = 0;
if (size == 0) {
return result;
}
int current_value = list1[0];
... | int main() {
// Test Case 1
int input1[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
int size1 = sizeof(input1)/sizeof(input1[0]);
PackResult* result1 = func0(input1, size1);
assert(result1->numGroups == 11);
assert(compare_arrays(result1->group[0], (int[]){0, 0}, result1->groupSiz... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov $0x18,%edi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rdx
mov -0x18(%rbp),%rax
mo... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov edi, 18h; size
call _malloc
mov [rbp+var_18], rax
mov eax, [rbp+var_3C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_18]
mo... | _QWORD * func0(int *a1, int a2)
{
void **v3; // rbx
int v4; // eax
void **v5; // rbx
int v6; // [rsp+1Ch] [rbp-24h]
int v7; // [rsp+20h] [rbp-20h]
int i; // [rsp+24h] [rbp-1Ch]
_QWORD *v9; // [rsp+28h] [rbp-18h]
v9 = malloc(0x18uLL);
*v9 = malloc(8LL * a2);
v9[1] = malloc(4LL * a2);
*((_DWORD *)v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV EDI,0x18
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [R... | long * func0(int *param_1,int param_2)
{
int iVar1;
long lVar2;
long *plVar3;
void *pvVar4;
int local_2c;
int local_28;
int local_24;
plVar3 = (long *)malloc(0x18);
pvVar4 = malloc((long)param_2 << 3);
*plVar3 = (long)pvVar4;
pvVar4 = malloc((long)param_2 << 2);
plVar3[1] = (long)pvVar4;
*... |
7,005 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int **group;
int *groupSize;
int numGroups;
} PackResult;
int compare_arrays(int a[], int b[], int a_size, int b_size) {
if (a_size != b_size)
return 0;
for (int i = 0; i < a_size; i++) {
... | PackResult* func0(int list1[], int size) {
PackResult *result = malloc(sizeof(PackResult));
result->group = malloc(sizeof(int*) * size);
result->groupSize = malloc(sizeof(int) * size);
result->numGroups = 0;
if (size == 0) {
return result;
}
int current_value = list1[0];
... | int main() {
// Test Case 1
int input1[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
int size1 = sizeof(input1)/sizeof(input1[0]);
PackResult* result1 = func0(input1, size1);
assert(result1->numGroups == 11);
assert(compare_arrays(result1->group[0], (int[]){0, 0}, result1->groupSiz... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r15
mov %esi,%r14d
mov $0x18,%edi
callq 10b0 <malloc@plt>
mov %rax,%rbx
movslq %r14d,%r13
lea 0x0(,%r13,8),%rdi
callq 10b0 <malloc@plt>
mov %rax,%rbp
mov %rax,(%rbx)
shl $0x2,%r13
... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r15, rdi
mov r14d, esi
mov edi, 18h
call _malloc
mov rbx, rax
movsxd r13, r14d
lea rdi, ds:0[r13*8]
call _malloc
mov rbp, rax
mov [rbx], rax
shl r13, 2
mov rdi, r13
call ... | long long func0(int *a1, int a2)
{
long long v2; // rbx
_QWORD *v3; // rbp
long long v4; // r13
int v6; // r12d
_DWORD *v7; // rax
int *v8; // rbp
int v9; // edx
int v10; // eax
_QWORD *v11; // r15
_DWORD *v12; // rax
int v13; // eax
v2 = malloc(24LL);
v3 = (_QWORD *)malloc(8LL * a2);
*(_Q... | ||
7,006 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int **group;
int *groupSize;
int numGroups;
} PackResult;
int compare_arrays(int a[], int b[], int a_size, int b_size) {
if (a_size != b_size)
return 0;
for (int i = 0; i < a_size; i++) {
... | PackResult* func0(int list1[], int size) {
PackResult *result = malloc(sizeof(PackResult));
result->group = malloc(sizeof(int*) * size);
result->groupSize = malloc(sizeof(int) * size);
result->numGroups = 0;
if (size == 0) {
return result;
}
int current_value = list1[0];
... | int main() {
// Test Case 1
int input1[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
int size1 = sizeof(input1)/sizeof(input1[0]);
PackResult* result1 = func0(input1, size1);
assert(result1->numGroups == 11);
assert(compare_arrays(result1->group[0], (int[]){0, 0}, result1->groupSiz... | O2 | c | func0:
endbr64
push %r15
push %r14
movslq %esi,%r14
push %r13
push %r12
mov %rdi,%r12
mov $0x18,%edi
push %rbp
mov %r14,%rbp
push %rbx
sub $0x28,%rsp
callq 10b0 <malloc@plt>
lea 0x0(,%r14,8),%rdi
shl $0x2,%r14
mov %rax,%r15
callq 10b0 <malloc@plt>
mov %r14,%rdi
mov %rax,(%r15)
m... | func0:
endbr64
push r15
push r14
mov r14, rdi
mov edi, 18h
push r13
movsxd r13, esi
push r12
push rbp
mov rbp, r13
push rbx
sub rsp, 28h
call _malloc
lea rdi, ds:0[r13*8]
shl r13, 2
mov r12, rax
call _malloc
mov rdi, r13
mov [r12], rax
mov [rsp+58h+var_48... | long long func0(int *a1, int a2)
{
long long v3; // r13
long long v4; // r12
long long v5; // rax
long long v6; // rax
_DWORD *v8; // rax
_QWORD *v9; // rcx
int v10; // esi
int *v11; // rdx
int *v12; // rbx
int v13; // r15d
long long v14; // r14
int v15; // eax
long long v16; // r9
int v17;... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
MOV EDI,0x18
PUSH R13
MOVSXD R13,ESI
PUSH R12
PUSH RBP
MOV RBP,R13
PUSH RBX
SUB RSP,0x28
CALL 0x001010b0
LEA RDI,[R13*0x8]
SHL R13,0x2
MOV R12,RAX
CALL 0x001010b0
MOV RDI,R13
MOV qword ptr [R12],RAX
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001010b0
MOV dword ptr [R12 + 0x10],0x... | int8 * func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int8 *puVar3;
int8 *puVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int iVar8;
long lVar9;
size_t __size;
long lVar10;
int iVar11;
puVar3 = (int8 *)malloc(0x18);
__size = (long)param_2 << 2;
puVar4 = (int8 *)malloc((long)par... |
7,007 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int **group;
int *groupSize;
int numGroups;
} PackResult;
int compare_arrays(int a[], int b[], int a_size, int b_size) {
if (a_size != b_size)
return 0;
for (int i = 0; i < a_size; i++) {
... | PackResult* func0(int list1[], int size) {
PackResult *result = malloc(sizeof(PackResult));
result->group = malloc(sizeof(int*) * size);
result->groupSize = malloc(sizeof(int) * size);
result->numGroups = 0;
if (size == 0) {
return result;
}
int current_value = list1[0];
... | int main() {
// Test Case 1
int input1[] = {0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4};
int size1 = sizeof(input1)/sizeof(input1[0]);
PackResult* result1 = func0(input1, size1);
assert(result1->numGroups == 11);
assert(compare_arrays(result1->group[0], (int[]){0, 0}, result1->groupSiz... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
mov $0x18,%edi
push %r13
push %r12
movslq %esi,%r12
push %rbp
mov %r12,%r13
push %rbx
sub $0x28,%rsp
callq 10b0 <malloc@plt>
lea 0x0(,%r12,8),%rdi
shl $0x2,%r12
mov %rax,%rbp
callq 10b0 <malloc@plt>
mov %r12,%rdi
mov %rax,0x8(%rsp... | func0:
endbr64
push r15
mov r15, rdi
mov edi, 18h; size
push r14
push r13
movsxd r13, esi
push r12
mov r14, r13
push rbp
lea rbp, ds:0[r13*4]
push rbx
sub rsp, 28h
call _malloc
lea rdi, ds:0[r13*8]; size
mov r12, rax
call _malloc
mov rdi, rbp; size
mov [rsp+5... | _DWORD * func0(int *a1, int a2)
{
_DWORD *v2; // r12
_QWORD *v3; // rax
int *v4; // rax
int v6; // ebx
int *v7; // r13
_DWORD *v8; // rax
_QWORD *v9; // rcx
int *v10; // rbp
long long v11; // r14
int v12; // r15d
int v13; // eax
long long v14; // r8
int v15; // edi
_DWORD *v16; // rax
int ... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
MOV EDI,0x18
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOV R14,R13
PUSH RBP
LEA RBP,[R13*0x4]
PUSH RBX
SUB RSP,0x28
CALL 0x001010b0
LEA RDI,[R13*0x8]
MOV R12,RAX
CALL 0x001010b0
MOV RDI,RBP
MOV qword ptr [RSP + 0x18],RBP
MOV qword ptr [R12],RAX
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00... | int8 * func0(int *param_1,int param_2)
{
size_t __size;
int iVar1;
int iVar2;
int8 *puVar3;
int8 *puVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int iVar8;
long lVar9;
long lVar10;
int iVar11;
__size = (long)param_2 * 4;
puVar3 = (int8 *)malloc(0x18);
puVar4 = (int8 *)malloc((long)para... |
7,008 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
// Structure to hold key-value pairs
typedef struct {
char key[100];
int count;
} DictEntry;
// Function to convert integer list to string key
void int_list_to_key(int *list, int size, char *key) {
strcpy(key, "(... | DictEntry* func0(int **list1, int *sizes, int n, int *unique_count) {
DictEntry *result = malloc(n * sizeof(DictEntry));
*unique_count = 0;
for(int i = 0; i < n; i++) {
char key[100];
int_list_to_key(list1[i], sizes[i], key);
int found = 0;
for(int j = 0; j < *unique_c... | int main() {
// Test case 1
int list1_case1_data[][3] = { {1, 3}, {5, 7}, {1, 3}, {13, 15, 17}, {5, 7}, {9, 11} };
int sizes_case1[] = {2, 2, 2, 3, 2, 2};
int *list1_case1[6];
for(int i = 0; i < 6; i++) {
list1_case1[i] = list1_case1_data[i];
}
int unique_count1;
DictEnt... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xb0,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %edx,-0xa4(%rbp)
mov %rcx,-0xb0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0xa4(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov [rbp+var_A4], edx
mov [rbp+var_B0], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_A4]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rd... | _DWORD * func0(long long a1, long long a2, int a3, int *a4)
{
int i; // [rsp+2Ch] [rbp-84h]
int v8; // [rsp+30h] [rbp-80h]
int j; // [rsp+34h] [rbp-7Ch]
_DWORD *v10; // [rsp+38h] [rbp-78h]
char s2[104]; // [rsp+40h] [rbp-70h] BYREF
unsigned long long v12; // [rsp+A8h] [rbp-8h]
v12 = __readfsqword(0x28u);... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV dword ptr [RBP + -0xa4],EDX
MOV qword ptr [RBP + -0xb0],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0xa4]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
A... | void * func0(long param_1,long param_2,int param_3,int *param_4)
{
bool bVar1;
int iVar2;
void *pvVar3;
long in_FS_OFFSET;
int local_8c;
int local_84;
char local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pvVar3 = malloc((long)param_3 * 0x68);
*param_4 = 0;
local_8c ... |
7,009 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
// Structure to hold key-value pairs
typedef struct {
char key[100];
int count;
} DictEntry;
// Function to convert integer list to string key
void int_list_to_key(int *list, int size, char *key) {
strcpy(key, "(... | DictEntry* func0(int **list1, int *sizes, int n, int *unique_count) {
DictEntry *result = malloc(n * sizeof(DictEntry));
*unique_count = 0;
for(int i = 0; i < n; i++) {
char key[100];
int_list_to_key(list1[i], sizes[i], key);
int found = 0;
for(int j = 0; j < *unique_c... | int main() {
// Test case 1
int list1_case1_data[][3] = { {1, 3}, {5, 7}, {1, 3}, {13, 15, 17}, {5, 7}, {9, 11} };
int sizes_case1[] = {2, 2, 2, 3, 2, 2};
int *list1_case1[6];
for(int i = 0; i < 6; i++) {
list1_case1[i] = list1_case1_data[i];
}
int unique_count1;
DictEnt... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,0x18(%rsp)
mov %rsi,0x20(%rsp)
mov %edx,%ebx
mov %rcx,%r15
mov %rcx,0x10(%rsp)
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
movslq %edx,%rax
lea (%rax,%rax,2),%rdx
lea (... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0A8h
mov [rsp+0D8h+var_C0], rdi
mov [rsp+0D8h+var_B8], rsi
mov ebx, edx
mov r14, rcx
mov [rsp+0D8h+var_C8], rcx
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
xor eax, eax
movsxd rax, edx
lea... | long long func0(long long a1, long long a2, int a3, int *a4)
{
long long i; // r14
int v7; // r15d
long long v8; // rbx
long long v10; // [rsp+8h] [rbp-D0h]
long long v12; // [rsp+28h] [rbp-B0h]
_BYTE v13[104]; // [rsp+30h] [rbp-A8h] BYREF
unsigned long long v14; // [rsp+98h] [rbp-40h]
v14 = __readfsq... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV EBX,EDX
MOV R14,RCX
MOV qword ptr [RSP + 0x10],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
MOVSXD RAX,EDX
LEA RDX,[RAX + RAX*0x2]
LEA RDI,[RA... | char * func0(long param_1,long param_2,uint param_3,uint *param_4)
{
uint uVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
ulong uVar5;
long in_FS_OFFSET;
char local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
pcVar3 = (char *)malloc((long)(int)param_3 * 0x68);
*param_4 = ... |
7,010 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
// Structure to hold key-value pairs
typedef struct {
char key[100];
int count;
} DictEntry;
// Function to convert integer list to string key
void int_list_to_key(int *list, int size, char *key) {
strcpy(key, "(... | DictEntry* func0(int **list1, int *sizes, int n, int *unique_count) {
DictEntry *result = malloc(n * sizeof(DictEntry));
*unique_count = 0;
for(int i = 0; i < n; i++) {
char key[100];
int_list_to_key(list1[i], sizes[i], key);
int found = 0;
for(int j = 0; j < *unique_c... | int main() {
// Test case 1
int list1_case1_data[][3] = { {1, 3}, {5, 7}, {1, 3}, {13, 15, 17}, {5, 7}, {9, 11} };
int sizes_case1[] = {2, 2, 2, 3, 2, 2};
int *list1_case1[6];
for(int i = 0; i < 6; i++) {
list1_case1[i] = list1_case1_data[i];
}
int unique_count1;
DictEnt... | O2 | c | func0:
endbr64
push %r15
mov %rcx,%r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %edx,%ebx
sub $0x98,%rsp
mov %rdi,0x8(%rsp)
mov %rsi,0x10(%rsp)
mov %rcx,(%rsp)
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor %eax,%eax
movslq %edx,%rax
lea (%rax,%rax,2),%rdx
lea (%rax,... | func0:
endbr64
push r15
movsxd rdx, edx
mov r15, rcx
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdx
sub rsp, 98h
mov [rsp+0C8h+var_C0], rdi
mov [rsp+0C8h+var_B8], rsi
mov [rsp+0C8h+var_C8], rcx
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
lea ... | long long func0(long long a1, long long a2, int a3, int *a4)
{
long long v6; // rax
long long v7; // r14
long long v8; // r12
int v9; // r13d
long long v10; // r15
long long v13; // [rsp+18h] [rbp-B0h]
_BYTE v14[104]; // [rsp+20h] [rbp-A8h] BYREF
unsigned long long v15; // [rsp+88h] [rbp-40h]
v15 = ... | func0:
ENDBR64
PUSH R15
MOVSXD RDX,EDX
MOV R15,RCX
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDX
SUB RSP,0x98
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
LEA RAX,[RDX + RDX*0x2]
MOV qword ptr [RSP ... | char * func0(long param_1,long param_2,int param_3,uint *param_4)
{
uint uVar1;
int iVar2;
char *pcVar3;
long lVar4;
long lVar5;
char *__s1;
long in_FS_OFFSET;
char local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
pcVar3 = (char *)malloc((long)param_3 * 0x68);
*param... |
7,011 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
// Structure to hold key-value pairs
typedef struct {
char key[100];
int count;
} DictEntry;
// Function to convert integer list to string key
void int_list_to_key(int *list, int size, char *key) {
strcpy(key, "(... | DictEntry* func0(int **list1, int *sizes, int n, int *unique_count) {
DictEntry *result = malloc(n * sizeof(DictEntry));
*unique_count = 0;
for(int i = 0; i < n; i++) {
char key[100];
int_list_to_key(list1[i], sizes[i], key);
int found = 0;
for(int j = 0; j < *unique_c... | int main() {
// Test case 1
int list1_case1_data[][3] = { {1, 3}, {5, 7}, {1, 3}, {13, 15, 17}, {5, 7}, {9, 11} };
int sizes_case1[] = {2, 2, 2, 3, 2, 2};
int *list1_case1[6];
for(int i = 0; i < 6; i++) {
list1_case1[i] = list1_case1_data[i];
}
int unique_count1;
DictEnt... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rcx,%r14
push %r13
push %r12
push %rbp
push %rbx
mov %edx,%ebx
sub $0xd8,%rsp
mov %rdi,0x28(%rsp)
mov %rsi,0x30(%rsp)
mov %rcx,0x10(%rsp)
mov %fs:0x28,%rax
mov %rax,0xc8(%rsp)
xor %eax,%eax
movslq %edx,%rax
lea (%rax,%rax,2),%rdx
lea (... | func0:
endbr64
push r15
mov r15, rdi
push r14
mov r14, rcx
push r13
mov r13, rsi
push r12
push rbp
movsxd rbp, edx
push rbx
sub rsp, 0A8h
mov [rsp+0D8h+var_C0], rcx
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
xor eax, eax
lea rax, [rbp+rbp*2+0]
lea rax, [rbp+rax... | char * func0(_QWORD *a1, unsigned int *a2, int a3, int *a4)
{
unsigned int *v6; // r13
long long v7; // rbp
char *v8; // rax
long long v9; // r12
char *v10; // r14
long long v12; // rdx
unsigned long long v13; // rdx
int v14; // [rsp+Ch] [rbp-CCh]
char *s1; // [rsp+10h] [rbp-C8h]
size_t v17; // [rsp... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
PUSH R14
MOV R14,RCX
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
MOVSXD RBP,EDX
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RSP + 0x18],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
LEA RAX,[RBP + RBP*0x2]
LEA RAX,[RBP + RAX*0x4]
SHL RAX,0x3
MOV RDI,RAX
MOV qword ptr... | char * func0(int8 *param_1,int4 *param_2,int param_3,int *param_4)
{
int4 *puVar1;
int iVar2;
int iVar3;
size_t __size;
char *pcVar4;
ulong uVar5;
long lVar6;
size_t sVar7;
ulong uVar8;
char *__s1;
long in_FS_OFFSET;
char local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET +... |
7,012 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int first;
int second;
} Pair;
| Pair *func0(Pair test_list[], int size) {
Pair *res = (Pair*)malloc(sizeof(Pair) * size * (size - 1) / 2);
int index = 0;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
res[index].first = test_list[i].first + test_list[j].first;
res[index].second ... | int main() {
Pair test1[] = {{2, 4}, {6, 7}, {5, 1}, {6, 10}};
Pair test2[] = {{3, 5}, {7, 8}, {6, 2}, {7, 11}};
Pair test3[] = {{4, 6}, {8, 9}, {7, 3}, {8, 12}};
Pair *result1 = func0(test1, 4);
Pair expected1[] = {{8, 11}, {7, 5}, {8, 14}, {11, 8}, {12, 17}, {11, 11}};
for (int i =... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
movslq %eax,%rdx
mov -0x2c(%rbp),%eax
sub $0x1,%eax
cltq
imul %rdx,%rax
shl $0x3,%rax
shr %rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov eax, [rbp+var_2C]
movsxd rdx, eax
mov eax, [rbp+var_2C]
sub eax, 1
cdqe
imul rax, rdx
shl rax, 3
shr rax, 1
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov ... | _DWORD * func0(long long a1, int a2)
{
int v3; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
_DWORD *v6; // [rsp+28h] [rbp-8h]
v6 = malloc((unsigned long long)(8 * a2 * (long long)(a2 - 1)) >> 1);
v3 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV EAX,dword ptr [RBP + -0x2c]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
CDQE
IMUL RAX,RDX
SHL RAX,0x3
SHR RAX,0x1
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [... | void * func0(long param_1,int param_2)
{
void *pvVar1;
int local_1c;
int local_18;
int local_14;
pvVar1 = malloc((ulong)((long)(param_2 + -1) * (long)param_2 * 8) >> 1);
local_1c = 0;
for (local_18 = 0; local_14 = local_18, local_18 < param_2; local_18 = local_18 + 1) {
while (local_14 = local_14 ... |
7,013 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int first;
int second;
} Pair;
| Pair *func0(Pair test_list[], int size) {
Pair *res = (Pair*)malloc(sizeof(Pair) * size * (size - 1) / 2);
int index = 0;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
res[index].first = test_list[i].first + test_list[j].first;
res[index].second ... | int main() {
Pair test1[] = {{2, 4}, {6, 7}, {5, 1}, {6, 10}};
Pair test2[] = {{3, 5}, {7, 8}, {6, 2}, {7, 11}};
Pair test3[] = {{4, 6}, {8, 9}, {7, 3}, {8, 12}};
Pair *result1 = func0(test1, 4);
Pair expected1[] = {{8, 11}, {7, 5}, {8, 14}, {11, 8}, {12, 17}, {11, 11}};
for (int i =... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %esi,%ebx
lea -0x1(%rsi),%edi
movslq %edi,%rdi
movslq %esi,%rax
imul %rax,%rdi
shl $0x3,%rdi
shr %rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 1272 <func0+0... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, esi
lea edi, [rsi-1]
movsxd rdi, edi
movsxd rax, esi
imul rdi, rax
shl rdi, 3
shr rdi, 1
call _malloc
mov r12, rax
test ebx, ebx
jle short loc_1272
mov r... | long long func0(_DWORD *a1, int a2)
{
long long v2; // rax
long long v3; // r12
int v5; // r10d
int v6; // r11d
long long v7; // r14
int v8; // r8d
int v9; // edi
_DWORD *v10; // rax
_DWORD *v11; // rdx
v2 = malloc((unsigned long long)(8 * a2 * (long long)(a2 - 1)) >> 1);
v3 = v2;
if ( a2 > 0 ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
LEA EDI,[RSI + -0x1]
MOVSXD RDI,EDI
MOVSXD RAX,ESI
IMUL RDI,RAX
SHL RDI,0x3
SHR RDI,0x1
CALL 0x001010d0
MOV R12,RAX
TEST EBX,EBX
JLE 0x00101272
MOV R9,RBP
MOV R10D,0x0
MOV R11D,0x0
LEA R15D,[RBX + -0x1]
LEA R14,[RAX... | void * func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
void *pvVar3;
int *piVar4;
int *piVar5;
int iVar6;
int iVar7;
pvVar3 = malloc((ulong)((long)(param_2 + -1) * (long)param_2 * 8) >> 1);
if (0 < param_2) {
iVar6 = 0;
iVar7 = 0;
while (iVar6 = iVar6 + 1, param_2 != iVar6) {
... |
7,014 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int first;
int second;
} Pair;
| Pair *func0(Pair test_list[], int size) {
Pair *res = (Pair*)malloc(sizeof(Pair) * size * (size - 1) / 2);
int index = 0;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
res[index].first = test_list[i].first + test_list[j].first;
res[index].second ... | int main() {
Pair test1[] = {{2, 4}, {6, 7}, {5, 1}, {6, 10}};
Pair test2[] = {{3, 5}, {7, 8}, {6, 2}, {7, 11}};
Pair test3[] = {{4, 6}, {8, 9}, {7, 3}, {8, 12}};
Pair *result1 = func0(test1, 4);
Pair expected1[] = {{8, 11}, {7, 5}, {8, 14}, {11, 8}, {12, 17}, {11, 11}};
for (int i =... | O2 | c | func0:
endbr64
movslq %esi,%rax
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
lea -0x1(%rax),%ebp
movslq %ebp,%rdi
push %rbx
mov %rax,%rbx
imul %rax,%rdi
shl $0x3,%rdi
shr %rdi
callq 10d0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 1603 <func0+0xa3>
xor %eax,%eax
mov ... | func0:
endbr64
movsxd rax, esi
push r14
push r13
mov r13, rdi
push r12
push rbp
lea ebp, [rax-1]
movsxd rdi, ebp
push rbx
mov rbx, rax
imul rdi, rax
shl rdi, 3
shr rdi, 1
call _malloc
mov r12, rax
test ebx, ebx
jle short loc_1606
xor r10d, r10d
mov r9, r13
l... | long long func0(_DWORD *a1, int a2)
{
long long v2; // rax
long long v3; // r12
long long v5; // r14
int v6; // r11d
int i; // r10d
int v8; // r8d
int v9; // edi
long long v10; // rax
_DWORD *v11; // rdx
int v12; // ecx
int v13; // eax
v2 = malloc((unsigned long long)(8 * a2 * (long long)(a2 -... | func0:
ENDBR64
MOVSXD RAX,ESI
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
LEA EBP,[RAX + -0x1]
MOVSXD RDI,EBP
PUSH RBX
MOV RBX,RAX
IMUL RDI,RAX
SHL RDI,0x3
SHR RDI,0x1
CALL 0x001010d0
MOV R12,RAX
TEST EBX,EBX
JLE 0x00101606
XOR R10D,R10D
MOV R9,R13
LEA R14,[RAX + 0x8]
XOR R11D,R11D
ADD R10D,0x1
LEA R13D,[RBX + 0x1]... | void * func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
void *pvVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int iVar7;
int iVar8;
pvVar3 = malloc((ulong)((long)(param_2 + -1) * (long)param_2 * 8) >> 1);
if (0 < param_2) {
iVar8 = 0;
iVar7 = 1;
if (param_2 != 1) {
do {
... |
7,015 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int first;
int second;
} Pair;
| Pair *func0(Pair test_list[], int size) {
Pair *res = (Pair*)malloc(sizeof(Pair) * size * (size - 1) / 2);
int index = 0;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
res[index].first = test_list[i].first + test_list[j].first;
res[index].second ... | int main() {
Pair test1[] = {{2, 4}, {6, 7}, {5, 1}, {6, 10}};
Pair test2[] = {{3, 5}, {7, 8}, {6, 2}, {7, 11}};
Pair test3[] = {{4, 6}, {8, 9}, {7, 3}, {8, 12}};
Pair *result1 = func0(test1, 4);
Pair expected1[] = {{8, 11}, {7, 5}, {8, 14}, {11, 8}, {12, 17}, {11, 11}};
for (int i =... | O3 | c | func0:
endbr64
movslq %esi,%rax
push %r14
push %r13
push %r12
lea -0x1(%rax),%r12d
push %rbp
mov %rax,%rbp
push %rbx
mov %rdi,%rbx
movslq %r12d,%rdi
imul %rax,%rdi
shl $0x3,%rdi
shr %rdi
callq 10d0 <malloc@plt>
cmp $0x1,%ebp
jle 16cb <func0+0xfb>
mov %r12d,%r10d
lea 0x8(%rbx),%r8... | func0:
endbr64
movsxd rax, esi
push r14
push r13
lea r13d, [rax-1]
push r12
mov r12, rax
push rbp
mov rbp, rdi
movsxd rdi, r13d
imul rdi, rax
push rbx
shl rdi, 3
shr rdi, 1; size
call _malloc
mov rbx, rax
test r12d, r12d
jle loc_1539
cmp r12d, 1
jz loc_1539... | _QWORD * func0(long long a1, int a2)
{
_QWORD *v3; // rbx
unsigned int v4; // r8d
long long v5; // rcx
long long v6; // r9
int v7; // r11d
__m128i v8; // xmm2
long long v9; // r10
long long v10; // rax
__m128i v11; // xmm1
long long v12; // rsi
v3 = malloc((unsigned long long)(8 * a2 * (long long... | func0:
ENDBR64
MOVSXD RAX,ESI
PUSH R14
PUSH R13
LEA R13D,[RAX + -0x1]
PUSH R12
MOV R12,RAX
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,R13D
IMUL RDI,RAX
PUSH RBX
SHL RDI,0x3
SHR RDI,0x1
CALL 0x001010d0
MOV RBX,RAX
TEST R12D,R12D
JLE 0x00101539
CMP R12D,0x1
JZ 0x00101539
MOV R8D,R13D
LEA RCX,[RBP + 0x8]
MOV R14D,R12D
MOV R9D,0x1
XO... | void * func0(long param_1,uint param_2)
{
int *piVar1;
int *piVar2;
int8 uVar3;
int iVar4;
int iVar5;
int iVar6;
void *pvVar7;
long lVar8;
long lVar9;
ulong uVar10;
ulong uVar11;
int iVar12;
uint uVar13;
int iVar14;
int iVar15;
uVar13 = param_2 - 1;
pvVar7 = malloc((ulong)((long)(i... |
7,016 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
int count = 0;
for (int i = 1; i < ((int)sqrt(n)) + 2; i++) {
if (n % i == 0) {
if (n / i == i) {
count++;
} else {
count += 2;
}
}
}
if (count % 2 == 0) {
return "Even";
} e... | int main() {
assert(strcmp(func0(10), "Even") == 0);
assert(strcmp(func0(100), "Odd") == 0);
assert(strcmp(func0(125), "Even") == 0);
printf("All test cases passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 11ef <func0+0x46>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 11eb <func0+0x42>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
cmp %ea... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_11EF
loc_11C8:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_11EB
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_... | const char * func0(int a1)
{
int v2; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v2 = 0;
for ( i = 1; i <= (int)sqrt((double)a1) + 1; ++i )
{
if ( !(a1 % i) )
{
if ( i == a1 / i )
++v2;
else
v2 += 2;
}
}
if ( (v2 & 1) != 0 )
return "Odd";
else
retu... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011ef
LAB_001011c8:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x001011eb
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dwo... | int * func0(int param_1)
{
byte bVar1;
int *puVar2;
double dVar3;
int local_c;
bVar1 = 0;
for (local_c = 1; dVar3 = sqrt((double)param_1), local_c <= (int)dVar3 + 1; local_c = local_c + 1)
{
if ((param_1 % local_c == 0) && (local_c == param_1 / local_c)) {
bVar1 = bVar1 + 1;
}
}
if (... |
7,017 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
int count = 0;
for (int i = 1; i < ((int)sqrt(n)) + 2; i++) {
if (n % i == 0) {
if (n / i == i) {
count++;
} else {
count += 2;
}
}
}
if (count % 2 == 0) {
return "Even";
} e... | int main() {
assert(strcmp(func0(10), "Even") == 0);
assert(strcmp(func0(100), "Odd") == 0);
assert(strcmp(func0(125), "Even") == 0);
printf("All test cases passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,%ebp
pxor %xmm3,%xmm3
cvtsi2sd %edi,%xmm3
movsd %xmm3,0x8(%rsp)
movapd %xmm3,%xmm0
sqrtsd %xmm0,%xmm0
cvttsd2si %xmm0,%r13d
add $0x1,%r13d
mov $0x1,%ebx
mov $0x0,%r12d
jmp 11c8 <func0+0x3f>
add $0x1,%ebx
pxor ... | func0:
endbr64
push r12
push rbp
push rbx
mov ebp, edi
mov ebx, 1
mov r12d, 0
jmp short loc_11C3
loc_11C0:
add ebx, 1
loc_11C3:
pxor xmm0, xmm0
cvtsi2sd xmm0, ebp
pxor xmm1, xmm1
ucomisd xmm1, xmm0
ja short loc_1206
sqrtsd xmm0, xmm0
loc_11D9:
cvttsd2si eax, xmm0
add eax, 1
... | const char * func0(int a1)
{
int v1; // ebx
char v2; // r12
double v3; // xmm0_8
double v4; // xmm0_8
const char *result; // rax
v1 = 1;
v2 = 0;
while ( 1 )
{
v3 = (double)a1;
v4 = (double)a1 < 0.0 ? sqrt(v3) : sqrt(v3);
if ( (int)v4 + 1 < v1 )
break;
if ( !(a1 % v1) )
v2 ... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV EBP,EDI
MOV EBX,0x1
MOV R12D,0x0
JMP 0x001011c3
LAB_001011c0:
ADD EBX,0x1
LAB_001011c3:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBP
PXOR XMM1,XMM1
UCOMISD XMM1,XMM0
JA 0x00101206
SQRTSD XMM0,XMM0
LAB_001011d9:
CVTTSD2SI EAX,XMM0
ADD EAX,0x1
CMP EAX,EBX
JL 0x0010120d
MOV EAX,EBP
CDQ
ID... | int * func0(int param_1)
{
int *puVar1;
int iVar2;
byte bVar3;
double dVar4;
iVar2 = 1;
bVar3 = 0;
while( true ) {
dVar4 = (double)param_1;
if (dVar4 < 0.0) {
dVar4 = sqrt(dVar4);
}
else {
dVar4 = SQRT(dVar4);
}
if ((int)dVar4 + 1 < iVar2) break;
if (param_1 % i... |
7,018 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
int count = 0;
for (int i = 1; i < ((int)sqrt(n)) + 2; i++) {
if (n % i == 0) {
if (n / i == i) {
count++;
} else {
count += 2;
}
}
}
if (count % 2 == 0) {
return "Even";
} e... | int main() {
assert(strcmp(func0(10), "Even") == 0);
assert(strcmp(func0(100), "Odd") == 0);
assert(strcmp(func0(125), "Even") == 0);
printf("All test cases passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm1,%xmm1
push %r12
pxor %xmm2,%xmm2
cvtsi2sd %edi,%xmm1
push %rbp
xor %ebp,%ebp
push %rbx
mov $0x1,%ebx
movapd %xmm1,%xmm0
sub $0x10,%rsp
sqrtsd %xmm0,%xmm0
cvttsd2si %xmm0,%r12d
add $0x1,%r12d
jmp 12c2 <func0+0x52>
nopw 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %eb... | func0:
endbr64
push rbp
pxor xmm1, xmm1
xor ebp, ebp
pxor xmm2, xmm2
push rbx
cvtsi2sd xmm1, edi
mov ebx, 1
sub rsp, 18h
jmp short loc_12BA
loc_12A0:
mov eax, edi
cdq
idiv ebx
test edx, edx
jnz short loc_12B7
mov edx, ebp
xor ebp, ebp
cmp eax, ebx
setnz bpl
lea ... | const char * func0(int a1)
{
char v1; // bp
double v2; // xmm1_8
int i; // ebx
double v4; // xmm0_8
const char *result; // rax
v1 = 0;
v2 = (double)a1;
for ( i = 1; ; ++i )
{
v4 = v2 < 0.0 ? sqrt(v2) : sqrt(v2);
if ( (int)v4 + 1 < i )
break;
if ( !(a1 % i) )
v1 += (a1 / i != i... | func0:
ENDBR64
PUSH RBP
PXOR XMM1,XMM1
XOR EBP,EBP
PXOR XMM2,XMM2
PUSH RBX
CVTSI2SD XMM1,EDI
MOV EBX,0x1
SUB RSP,0x18
JMP 0x001012ba
LAB_001012a0:
MOV EAX,EDI
CDQ
IDIV EBX
TEST EDX,EDX
JNZ 0x001012b7
MOV EDX,EBP
XOR EBP,EBP
CMP EAX,EBX
SETNZ BPL
LEA EBP,[RBP + RDX*0x1 + 0x1]
LAB_001012b7:
ADD EBX,0x1
LAB_001012ba:
UCOM... | int * func0(int param_1)
{
int *puVar1;
int iVar2;
byte bVar3;
double dVar4;
double __x;
bVar3 = 0;
__x = (double)param_1;
iVar2 = 1;
while( true ) {
if (__x < 0.0) {
dVar4 = sqrt(__x);
}
else {
dVar4 = SQRT(__x);
}
if ((int)dVar4 + 1 < iVar2) break;
if (param_1... |
7,019 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <string.h>
| char* func0(int n) {
int count = 0;
for (int i = 1; i < ((int)sqrt(n)) + 2; i++) {
if (n % i == 0) {
if (n / i == i) {
count++;
} else {
count += 2;
}
}
}
if (count % 2 == 0) {
return "Even";
} e... | int main() {
assert(strcmp(func0(10), "Even") == 0);
assert(strcmp(func0(100), "Odd") == 0);
assert(strcmp(func0(125), "Even") == 0);
printf("All test cases passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm1,%xmm1
push %r12
cvtsi2sd %edi,%xmm1
push %rbp
push %rbx
movapd %xmm1,%xmm0
sub $0x10,%rsp
sqrtsd %xmm0,%xmm0
cvttsd2si %xmm0,%esi
pxor %xmm0,%xmm0
ucomisd %xmm1,%xmm0
lea 0x1(%rsi),%ebp
ja 12f3 <func0+0x83>
add $0x2,%esi
mov $0x1,%ecx
xor %ebx,%ebx
lea 0xd56(%ri... | func0:
endbr64
pxor xmm1, xmm1
push r12
pxor xmm0, xmm0
cvtsi2sd xmm1, edi
push rbp
sub rsp, 18h
ucomisd xmm0, xmm1
ja short loc_12FF
sqrtsd xmm1, xmm1
mov ecx, 1
xor ebp, ebp
cvttsd2si esi, xmm1
test esi, esi
jns short loc_12BA
jmp short loc_12F0
loc_12B8:
mov ecx, eax
loc_... | const char * func0(int a1)
{
double v1; // xmm1_8
int v2; // ecx
char v3; // bp
int v4; // esi
const char *result; // rax
int v6; // r12d
v1 = (double)a1;
if ( (double)a1 < 0.0 )
{
v6 = 1;
v3 = 0;
while ( v6 <= (int)sqrt(v1) + 1 )
{
if ( !(a1 % v6) )
v3 += (v6 != a1 / v6... | func0:
ENDBR64
PXOR XMM1,XMM1
PUSH R12
PXOR XMM0,XMM0
CVTSI2SD XMM1,EDI
PUSH RBP
SUB RSP,0x18
UCOMISD XMM0,XMM1
JA 0x001012ff
SQRTSD XMM1,XMM1
MOV ECX,0x1
XOR EBP,EBP
CVTTSD2SI ESI,XMM1
TEST ESI,ESI
JNS 0x001012ba
JMP 0x001012f0
LAB_001012b8:
MOV ECX,EAX
LAB_001012ba:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x001012d... | int * func0(int param_1)
{
bool bVar1;
byte bVar2;
int iVar3;
double dVar4;
double __x;
__x = (double)param_1;
if (__x < 0.0) {
bVar2 = 0;
for (iVar3 = 1; dVar4 = sqrt(__x), iVar3 <= (int)dVar4 + 1; iVar3 = iVar3 + 1) {
if (param_1 % iVar3 == 0) {
bVar2 = (iVar3 == param_1 / iVar... |
7,020 | func0 |
#include <assert.h>
| int func0(int arr[], int l) {
int Sum = 0;
for (int i = 0; i < l; i++) {
Sum += ((((i + 1) * (l - i) + 1) / 2) * arr[i]);
}
return Sum;
}
| int main() {
int arr1[] = {1, 2, 4};
int arr2[] = {1, 2, 1, 2};
int arr3[] = {1, 7};
assert(func0(arr1, 3) == 14);
assert(func0(arr2, 4) == 15);
assert(func0(arr3, 2) == 8);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c5 <func0+0x5c>
mov -0x4(%rbp),%eax
lea 0x1(%rax),%edx
mov -0x1c(%rbp),%eax
sub -0x4(%rbp),%eax
imul %edx,%eax
add $0x1,%eax
mov %eax,%edx
shr $0x1f,%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11C5
loc_1188:
mov eax, [rbp+var_4]
lea edx, [rax+1]
mov eax, [rbp+var_1C]
sub eax, [rbp+var_4]
imul eax, edx
add eax, 1
mov edx, eax... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 += ((i + 1) * (a2 - i) + 1) / 2 * *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c5
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,dword ptr [RBP + -0x4]
IMUL EAX,EDX
AD... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 +
*(int *)(param_1 + (long)local_c * 4) *
(((param_2 - local_c) * (local_c + 1) + 1) / 2);
}
return local_1... |
7,021 | func0 |
#include <assert.h>
| int func0(int arr[], int l) {
int Sum = 0;
for (int i = 0; i < l; i++) {
Sum += ((((i + 1) * (l - i) + 1) / 2) * arr[i]);
}
return Sum;
}
| int main() {
int arr1[] = {1, 2, 4};
int arr2[] = {1, 2, 1, 2};
int arr3[] = {1, 7};
assert(func0(arr1, 3) == 14);
assert(func0(arr2, 4) == 15);
assert(func0(arr3, 2) == 8);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11af <func0+0x46>
lea -0x1(%rsi),%r9d
add $0x2,%r9
mov $0x1,%ecx
mov $0x0,%r8d
add $0x1,%esi
mov %esi,%eax
sub %ecx,%eax
imul %ecx,%eax
lea 0x1(%rax),%edx
mov %edx,%eax
shr $0x1f,%eax
add %edx,%eax
sar %eax
imul -0x4(%rdi,%rcx,4),%eax
add ... | func0:
endbr64
test esi, esi
jle short loc_11AB
lea r9d, [rsi+1]
mov ecx, 1
mov r8d, 0
add esi, 1
loc_1183:
mov edx, esi
sub edx, ecx
imul edx, ecx
add edx, 1
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
imul eax, [rdi+rcx*4-4]
add r8d, eax
add rcx, ... | long long func0(long long a1, int a2)
{
long long v2; // r9
long long v3; // rcx
unsigned int v4; // r8d
int v5; // esi
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = (unsigned int)(a2 + 1);
v3 = 1LL;
v4 = 0;
v5 = a2 + 1;
do
{
v4 += *(_DWORD *)(a1 + 4 * v3 - 4) * (((int)v... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011ab
LEA R9D,[RSI + 0x1]
MOV ECX,0x1
MOV R8D,0x0
ADD ESI,0x1
LAB_00101183:
MOV EDX,ESI
SUB EDX,ECX
IMUL EDX,ECX
ADD EDX,0x1
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
IMUL EAX,dword ptr [RDI + RCX*0x4 + -0x4]
ADD R8D,EAX
ADD RCX,0x1
CMP RCX,R9
JNZ 0x00101183
LAB_001011a7:
MOV... | int func0(long param_1,int param_2)
{
ulong uVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
uVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + ((((param_2 + 1) - (int)uVar1) * (int)uVar1 + 1) / 2) *
*(int *)(param_1 + -4 + uVar1 * 4);
uVar1 = uVar1 + 1;
... |
7,022 | func0 |
#include <assert.h>
| int func0(int arr[], int l) {
int Sum = 0;
for (int i = 0; i < l; i++) {
Sum += ((((i + 1) * (l - i) + 1) / 2) * arr[i]);
}
return Sum;
}
| int main() {
int arr1[] = {1, 2, 4};
int arr2[] = {1, 2, 1, 2};
int arr3[] = {1, 7};
assert(func0(arr1, 3) == 14);
assert(func0(arr2, 4) == 15);
assert(func0(arr3, 2) == 8);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1188 <func0+0x48>
lea -0x1(%rsi),%ecx
mov $0x1,%edx
xor %r8d,%r8d
add $0x1,%esi
add $0x2,%rcx
nopw 0x0(%rax,%rax,1)
mov %esi,%eax
sub %edx,%eax
imul %edx,%eax
add $0x1,%eax
sar %eax
imul -0x4(%rdi,%rdx,4),%eax
add $0x1,%rdx
add %eax,%r8d
cmp ... | func0:
endbr64
test esi, esi
jle short loc_12B8
lea ecx, [rsi+1]
mov edx, 1
xor r8d, r8d
mov rsi, rcx
nop word ptr [rax+rax+00000000h]
loc_1290:
mov eax, esi
sub eax, edx
imul eax, edx
add eax, 1
sar eax, 1
imul eax, [rdi+rdx*4-4]
add rdx, 1
add r8d, eax
cmp ... | long long func0(long long a1, int a2)
{
long long v2; // rcx
long long v3; // rdx
unsigned int v4; // r8d
int v5; // esi
int v6; // eax
if ( a2 <= 0 )
return 0LL;
v2 = (unsigned int)(a2 + 1);
v3 = 1LL;
v4 = 0;
v5 = a2 + 1;
do
{
v6 = *(_DWORD *)(a1 + 4 * v3 - 4) * (((int)v3 * (v5 - (int... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012b8
LEA ECX,[RSI + 0x1]
MOV EDX,0x1
XOR R8D,R8D
MOV RSI,RCX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101290:
MOV EAX,ESI
SUB EAX,EDX
IMUL EAX,EDX
ADD EAX,0x1
SAR EAX,0x1
IMUL EAX,dword ptr [RDI + RDX*0x4 + -0x4]
ADD RDX,0x1
ADD R8D,EAX
CMP RCX,RDX
JNZ 0x00101290
MOV EAX,R8D
RET
LAB_0... | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
ulong uVar3;
int iVar4;
if (0 < param_2) {
uVar3 = 1;
iVar4 = 0;
do {
iVar2 = (int)uVar3;
lVar1 = uVar3 * 4;
uVar3 = uVar3 + 1;
iVar4 = iVar4 + ((int)(((param_2 + 1U) - iVar2) * iVar2 + 1) >> 1) *
... |
7,023 | func0 |
#include <assert.h>
| int func0(int arr[], int l) {
int Sum = 0;
for (int i = 0; i < l; i++) {
Sum += ((((i + 1) * (l - i) + 1) / 2) * arr[i]);
}
return Sum;
}
| int main() {
int arr1[] = {1, 2, 4};
int arr2[] = {1, 2, 1, 2};
int arr3[] = {1, 7};
assert(func0(arr1, 3) == 14);
assert(func0(arr2, 4) == 15);
assert(func0(arr3, 2) == 8);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 12b0 <func0+0x170>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 12b9 <func0+0x179>
mov %esi,%edx
movd %esi,%xmm5
pxor %xmm2,%xmm2
mov %rdi,%rax
shr $0x2,%edx
pshufd $0x0,%xmm5,%xmm6
movdqa 0xe9b(%rip),%xmm3
movdqa 0xea3(%rip),%xmm5
shl $0x4,%rdx
movdqa 0xea7(%rip... | func0:
endbr64
mov edx, esi
test esi, esi
jle loc_12C0
lea eax, [rsi-1]
cmp eax, 2
jbe loc_12C9
mov ecx, esi
movd xmm5, esi
pxor xmm2, xmm2
mov rax, rdi
shr ecx, 2
movdqa xmm3, cs:xmmword_2010
movdqa xmm6, cs:xmmword_2020
pshufd xmm7, xmm5, 0
shl rcx, 4
movdqa xmm4, cs:x... | long long func0(long long a1, signed int a2)
{
__m128i v3; // xmm2
long long v4; // rax
__m128i si128; // xmm3
__m128i v6; // xmm6
__m128i v7; // xmm7
__m128i v8; // xmm4
__m128i v9; // xmm0
__m128i v10; // xmm8
__m128i v11; // xmm0
__m128i v12; // xmm0
__m128i v13; // xmm0
signed int v14; // e... | func0:
ENDBR64
MOV EDX,ESI
TEST ESI,ESI
JLE 0x001012c0
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001012c9
MOV ECX,ESI
MOVD XMM5,ESI
PXOR XMM2,XMM2
MOV RAX,RDI
SHR ECX,0x2
MOVDQA XMM3,xmmword ptr [0x00102010]
MOVDQA XMM6,xmmword ptr [0x00102020]
PSHUFD XMM7,XMM5,0x0
SHL RCX,0x4
MOVDQA XMM4,xmmword ptr [0x00102030]
MOVDQA X... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(ulong *param_1,uint param_2)
{
long lVar1;
ulong *puVar2;
ulong *puVar3;
uint uVar4;
int iVar5;
int iVar7;
int iVar8;
int iVar9;
int auVar6 [16];
int auVar10 [16];
int iVar11;
int iVar12;
int iVar1... |
7,024 | func0 | #include <math.h>
#include <stdio.h>
#include <assert.h>
| void func0(int r, int g, int b, double *h, double *s, double *v) {
double rd = r / 255.0;
double gd = g / 255.0;
double bd = b / 255.0;
double mx = fmax(rd, fmax(gd, bd));
double mn = fmin(rd, fmin(gd, bd));
double df = mx - mn;
*h = 0;
if (df > 0) {
if (mx == rd) {
... | int main() {
double h, s, v;
func0(255, 255, 255, &h, &s, &v);
assert(h == 0 && s == 0.0 && v == 100.0);
func0(0, 215, 0, &h, &s, &v);
assert(h == 120.0 && s == 100.0 && v == 84.31372549019608);
func0(10, 215, 110, &h, &s, &v);
assert(h == 149.26829268292684 && s == 95.348837209... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x60,%rsp
mov %edi,-0x34(%rbp)
mov %esi,-0x38(%rbp)
mov %edx,-0x3c(%rbp)
mov %rcx,-0x48(%rbp)
mov %r8,-0x50(%rbp)
mov %r9,-0x58(%rbp)
cvtsi2sdl -0x34(%rbp),%xmm0
movsd 0xf09(%rip),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x30(%rbp)
cvtsi2sdl -0x38(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_34], edi
mov [rbp+var_38], esi
mov [rbp+var_3C], edx
mov [rbp+var_48], rcx
mov [rbp+var_50], r8
mov [rbp+var_58], r9
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_34]
movsd xmm1, cs:qword_20E0
divsd xmm0, xmm1
movsd [rb... | double * func0(int a1, int a2, int a3, double *a4, double *a5, double *a6)
{
double v6; // xmm0_8
double v7; // xmm0_8
double *result; // rax
double v12; // [rsp+30h] [rbp-30h]
double x; // [rsp+38h] [rbp-28h]
double y; // [rsp+40h] [rbp-20h]
double v15; // [rsp+48h] [rbp-18h]
double v16; // [rsp+58h] [... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV dword ptr [RBP + -0x34],EDI
MOV dword ptr [RBP + -0x38],ESI
MOV dword ptr [RBP + -0x3c],EDX
MOV qword ptr [RBP + -0x48],RCX
MOV qword ptr [RBP + -0x50],R8
MOV qword ptr [RBP + -0x58],R9
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x34]
MOVSD XMM1,qword ptr [0x0010... | void func0(int param_1,int param_2,int param_3,double *param_4,double *param_5,double *param_6)
{
double dVar1;
double __x;
double __y;
double dVar2;
double dVar3;
dVar1 = (double)param_1 / DAT_001020e0;
__x = (double)param_2 / DAT_001020e0;
__y = (double)param_3 / DAT_001020e0;
dVar2 = fmax(__x,_... |
7,025 | func0 | #include <math.h>
#include <stdio.h>
#include <assert.h>
| void func0(int r, int g, int b, double *h, double *s, double *v) {
double rd = r / 255.0;
double gd = g / 255.0;
double bd = b / 255.0;
double mx = fmax(rd, fmax(gd, bd));
double mn = fmin(rd, fmin(gd, bd));
double df = mx - mn;
*h = 0;
if (df > 0) {
if (mx == rd) {
... | int main() {
double h, s, v;
func0(255, 255, 255, &h, &s, &v);
assert(h == 0 && s == 0.0 && v == 100.0);
func0(0, 215, 0, &h, &s, &v);
assert(h == 120.0 && s == 100.0 && v == 84.31372549019608);
func0(10, 215, 110, &h, &s, &v);
assert(h == 149.26829268292684 && s == 95.348837209... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov %rcx,%rbx
mov %r8,%r12
mov %r9,%rbp
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
movsd 0xf1a(%rip),%xmm0
divsd %xmm0,%xmm1
movsd %xmm1,0x10(%rsp)
pxor %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
movapd %xmm1,%xmm5
divsd %xmm0,%xmm5
pxor %xmm1,%xmm1... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 30h
mov rbx, rcx
mov r12, r8
mov rbp, r9
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
movsd xmm0, cs:qword_20E8
divsd xmm1, xmm0
movsd [rsp+48h+var_38], xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
movapd xmm5, xmm1
divsd xmm5, xmm0
pxor xmm... | void func0(int a1, int a2, int a3, double *a4, double *a5, double *a6)
{
double v9; // xmm0_8
double v10; // xmm0_8
double v11; // xmm4_8
double v12; // xmm0_8
double v13; // [rsp+8h] [rbp-40h]
double v14; // [rsp+10h] [rbp-38h]
double v15; // [rsp+18h] [rbp-30h]
double v16; // [rsp+20h] [rbp-28h]
do... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV RBX,RCX
MOV R12,R8
MOV RBP,R9
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MOVSD XMM0,qword ptr [0x001020e8]
DIVSD XMM1,XMM0
MOVSD qword ptr [RSP + 0x10],XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
MOVAPD XMM5,XMM1
DIVSD XMM5,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDX
MOVAPD XMM6,XMM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int param_1,int param_2,int param_3,double *param_4,double *param_5,double *param_6)
{
double dVar1;
double dVar2;
double dVar3;
double __x;
double __y;
dVar3 = (double)param_1 / DAT_001020e8;
__x = (doubl... |
7,026 | func0 | #include <math.h>
#include <stdio.h>
#include <assert.h>
| void func0(int r, int g, int b, double *h, double *s, double *v) {
double rd = r / 255.0;
double gd = g / 255.0;
double bd = b / 255.0;
double mx = fmax(rd, fmax(gd, bd));
double mn = fmin(rd, fmin(gd, bd));
double df = mx - mn;
*h = 0;
if (df > 0) {
if (mx == rd) {
... | int main() {
double h, s, v;
func0(255, 255, 255, &h, &s, &v);
assert(h == 0 && s == 0.0 && v == 100.0);
func0(0, 215, 0, &h, &s, &v);
assert(h == 120.0 && s == 100.0 && v == 84.31372549019608);
func0(10, 215, 110, &h, &s, &v);
assert(h == 149.26829268292684 && s == 95.348837209... | O2 | c | func0:
endbr64
push %r12
pxor %xmm1,%xmm1
pxor %xmm3,%xmm3
pxor %xmm4,%xmm4
push %rbp
cvtsi2sd %edi,%xmm1
mov %r8,%r12
mov %r9,%rbp
push %rbx
cvtsi2sd %esi,%xmm3
mov %rcx,%rbx
cvtsi2sd %edx,%xmm4
sub $0x20,%rsp
movsd 0xd3b(%rip),%xmm0
divsd %xmm0,%xmm4
divsd %xmm0,%xmm3
movsd %xmm4,0x18(%rsp... | func0:
endbr64
push r12
pxor xmm1, xmm1
pxor xmm3, xmm3
pxor xmm4, xmm4
push rbp
cvtsi2sd xmm1, edi
mov r12, r8
mov rbp, r9
push rbx
cvtsi2sd xmm3, esi
mov rbx, rcx
cvtsi2sd xmm4, edx
sub rsp, 20h
movsd xmm0, cs:qword_20E0
divsd xmm4, xmm0
divsd xmm3, xmm0
movsd [rsp+38h+var_20... | void func0(int a1, int a2, int a3, double *a4, double *a5, double *a6)
{
double v9; // xmm0_8
double v10; // xmm0_8
double v11; // xmm0_8
double v12; // xmm2_8
double v13; // xmm5_8
double v14; // xmm6_8
double v15; // xmm0_8
double v16; // xmm0_8
double v17; // xmm0_8
double v18; // xmm4_8
doubl... | func0:
ENDBR64
PUSH R12
PXOR XMM1,XMM1
PXOR XMM3,XMM3
PXOR XMM4,XMM4
PUSH RBP
CVTSI2SD XMM1,EDI
MOV R12,R8
MOV RBP,R9
PUSH RBX
CVTSI2SD XMM3,ESI
MOV RBX,RCX
CVTSI2SD XMM4,EDX
SUB RSP,0x20
MOVSD XMM0,qword ptr [0x001020e0]
DIVSD XMM4,XMM0
DIVSD XMM3,XMM0
MOVSD qword ptr [RSP + 0x18],XMM4
DIVSD XMM1,XMM0
MOVAPD XMM0,XMM3... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int param_1,int param_2,int param_3,double *param_4,double *param_5,double *param_6)
{
double dVar1;
double dVar2;
double dVar3;
double __x;
double __y;
__y = (double)param_3 / DAT_001020e0;
__x = (double)... |
7,027 | func0 | #include <math.h>
#include <stdio.h>
#include <assert.h>
| void func0(int r, int g, int b, double *h, double *s, double *v) {
double rd = r / 255.0;
double gd = g / 255.0;
double bd = b / 255.0;
double mx = fmax(rd, fmax(gd, bd));
double mn = fmin(rd, fmin(gd, bd));
double df = mx - mn;
*h = 0;
if (df > 0) {
if (mx == rd) {
... | int main() {
double h, s, v;
func0(255, 255, 255, &h, &s, &v);
assert(h == 0 && s == 0.0 && v == 100.0);
func0(0, 215, 0, &h, &s, &v);
assert(h == 120.0 && s == 100.0 && v == 84.31372549019608);
func0(10, 215, 110, &h, &s, &v);
assert(h == 149.26829268292684 && s == 95.348837209... | O3 | c | func0:
endbr64
push %r12
pxor %xmm1,%xmm1
pxor %xmm3,%xmm3
pxor %xmm4,%xmm4
push %rbp
cvtsi2sd %edi,%xmm1
mov %r8,%r12
mov %r9,%rbp
push %rbx
cvtsi2sd %esi,%xmm3
mov %rcx,%rbx
cvtsi2sd %edx,%xmm4
sub $0x20,%rsp
movsd 0xd3b(%rip),%xmm0
divsd %xmm0,%xmm4
divsd %xmm0,%xmm3
movsd %xmm4,0x18(%rsp... | func0:
endbr64
push r12
pxor xmm1, xmm1
mov r12, rcx
push rbp
cvtsi2sd xmm1, edi
mov rbp, r8
push rbx
mov rbx, r9
sub rsp, 20h
movsd xmm0, cs:qword_20E0
divsd xmm1, xmm0
movsd [rsp+38h+y], xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, esi
movapd xmm5, xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, e... | void func0(int a1, int a2, int a3, double *a4, double *a5, double *a6)
{
double v9; // xmm0_8
double v10; // xmm0_8
double v11; // xmm0_8
double v12; // xmm3_8
double v13; // xmm3_8
long double v14; // fst6
char v16; // c2
long double v17; // fst7
long double v18; // fst6
char v20; // c2
long dou... | func0:
ENDBR64
PUSH R12
PXOR XMM1,XMM1
MOV R12,RCX
PUSH RBP
CVTSI2SD XMM1,EDI
MOV RBP,R8
PUSH RBX
MOV RBX,R9
SUB RSP,0x20
MOVSD XMM0,qword ptr [0x001020e0]
DIVSD XMM1,XMM0
MOVSD qword ptr [RSP],XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,ESI
MOVAPD XMM5,XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDX
DIVSD XMM5,XMM0
MOVAPD XMM6,XMM1
DIVSD... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int param_1,int param_2,int param_3,double *param_4,double *param_5,double *param_6)
{
ushort in_FPUStatusWord;
double dVar1;
double dVar2;
double dVar3;
double __x;
double __y;
double local_30;
dVar3 = ... |
7,028 | func0 | #include <assert.h>
| int func0(int list1[], int n) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < n; i++) {
if (list1[i] % 2 == 0 && first_even == -1) {
first_even = list1[i];
}
if (list1[i] % 2 != 0 && first_odd == -1) {
first_odd = list1[i];
}
... | int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int n1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, n1) == 4);
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int n2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, n2) == 2);
int list3[] = {1,5,7,9,10};
int n3 = siz... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0xffffffff,-0xc(%rbp)
movl $0xffffffff,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 121a <func0+0xb1>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0FFFFFFFFh
mov [rbp+var_8], 0FFFFFFFFh
mov [rbp+var_4], 0
jmp loc_121A
loc_1192:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax,... | long long func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-Ch]
int v4; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = -1;
v4 = -1;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 && v3 == -1 )
v3 = *(_DWORD *)(4LL * i + a1);
if ( (*(_DWORD *)(4LL * i ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0xffffffff
MOV dword ptr [RBP + -0x8],0xffffffff
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010121a
LAB_00101192:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18... | int func0(long param_1,int param_2)
{
int local_14;
int local_10;
int local_c;
local_14 = -1;
local_10 = -1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (((*(uint *)(param_1 + (long)local_c * 4) & 1) == 0) && (local_14 == -1)) {
local_14 = *(int *)(param_1 + (long)local_c ... |
7,029 | func0 | #include <assert.h>
| int func0(int list1[], int n) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < n; i++) {
if (list1[i] % 2 == 0 && first_even == -1) {
first_even = list1[i];
}
if (list1[i] % 2 != 0 && first_odd == -1) {
first_odd = list1[i];
}
... | int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int n1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, n1) == 4);
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int n2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, n2) == 2);
int list3[] = {1,5,7,9,10};
int n3 = siz... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11b9 <func0+0x50>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r8
mov $0xffffffff,%esi
mov $0xffffffff,%eax
jmp 11a5 <func0+0x3c>
cmp $0xffffffff,%esi
jne 1192 <func0+0x29>
test %edi,%edi
cmovne %ecx,%esi
cmp $0xffffffff,%eax
je 119c <fu... | func0:
endbr64
test esi, esi
jle short loc_11B9
mov rdx, rdi
lea eax, [rsi-1]
lea r8, [rdi+rax*4+4]
mov esi, 0FFFFFFFFh
mov eax, 0FFFFFFFFh
jmp short loc_11A5
loc_1188:
cmp esi, 0FFFFFFFFh
jnz short loc_1192
test edi, edi
cmovnz esi, ecx
loc_1192:
cmp eax, 0FFFFFFFFh
jz ... | long long func0(int *a1, int a2)
{
int *v2; // rdx
long long v3; // r8
int v4; // esi
int v5; // eax
int v6; // edi
if ( a2 <= 0 )
{
v4 = -1;
v5 = -1;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = -1;
v5 = -1;
do
{
v6 = *v2 & 1;
if ( v5 != -1 |... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011b9
MOV RDX,RDI
LEA EAX,[RSI + -0x1]
LEA R8,[RDI + RAX*0x4 + 0x4]
MOV ESI,0xffffffff
MOV EAX,0xffffffff
JMP 0x001011a5
LAB_00101188:
CMP ESI,-0x1
JNZ 0x00101192
TEST EDI,EDI
CMOVNZ ESI,ECX
LAB_00101192:
CMP EAX,-0x1
JZ 0x0010119c
CMP ESI,-0x1
JNZ 0x001011c3
LAB_0010119c:
ADD RDX,0... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
if (param_2 < 1) {
uVar5 = 0xffffffff;
uVar3 = 0xffffffff;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar5 = 0xffffffff;
uVar4 = 0xffffffff;
do {
uVar2 = *pa... |
7,030 | func0 | #include <assert.h>
| int func0(int list1[], int n) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < n; i++) {
if (list1[i] % 2 == 0 && first_even == -1) {
first_even = list1[i];
}
if (list1[i] % 2 != 0 && first_odd == -1) {
first_odd = list1[i];
}
... | int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int n1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, n1) == 4);
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int n2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, n2) == 2);
int list3[] = {1,5,7,9,10};
int n3 = siz... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1344 <func0+0x54>
lea -0x1(%rsi),%eax
mov $0xffffffff,%ecx
lea 0x4(%rdi,%rax,4),%rsi
mov $0xffffffff,%eax
jmp 1329 <func0+0x39>
nopl 0x0(%rax)
cmp $0xffffffff,%eax
cmove %edx,%eax
cmp $0xffffffff,%eax
je 1320 <func0+0x30>
cmp $0xffffffff,%ecx
jne ... | func0:
endbr64
test esi, esi
jle short loc_1344
lea eax, [rsi-1]
mov ecx, 0FFFFFFFFh
lea rsi, [rdi+rax*4+4]
mov eax, 0FFFFFFFFh
jmp short loc_1329
loc_1310:
cmp ecx, 0FFFFFFFFh
cmovz ecx, edx
loc_1316:
cmp ecx, 0FFFFFFFFh
jz short loc_1320
cmp eax, 0FFFFFFFFh
jnz short ... | long long func0(int *a1, int a2)
{
int v2; // ecx
long long v3; // rsi
int v4; // eax
if ( a2 <= 0 )
return 1LL;
v2 = -1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = -1;
do
{
if ( (*a1 & 1) != 0 )
{
if ( v4 == -1 )
v4 = *a1;
}
else if ( v2 == -1 )
{
v2 = *a1;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101344
LEA EAX,[RSI + -0x1]
MOV ECX,0xffffffff
LEA RSI,[RDI + RAX*0x4 + 0x4]
MOV EAX,0xffffffff
JMP 0x00101329
LAB_00101310:
CMP ECX,-0x1
CMOVZ ECX,EDX
LAB_00101316:
CMP ECX,-0x1
JZ 0x00101320
CMP EAX,-0x1
JNZ 0x00101340
LAB_00101320:
ADD RDI,0x4
CMP RDI,RSI
JZ 0x00101340
LAB_0010132... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint uVar4;
if (param_2 < 1) {
return 1;
}
uVar4 = 0xffffffff;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
uVar3 = 0xffffffff;
do {
uVar2 = *param_1;
if ((uVar2 & 1) == 0) {
if (uVar4 == 0xffffffff) {... |
7,031 | func0 | #include <assert.h>
| int func0(int list1[], int n) {
int first_even = -1;
int first_odd = -1;
for (int i = 0; i < n; i++) {
if (list1[i] % 2 == 0 && first_even == -1) {
first_even = list1[i];
}
if (list1[i] % 2 != 0 && first_odd == -1) {
first_odd = list1[i];
}
... | int main() {
int list1[] = {1,3,5,7,4,1,6,8};
int n1 = sizeof(list1) / sizeof(list1[0]);
assert(func0(list1, n1) == 4);
int list2[] = {1,2,3,4,5,6,7,8,9,10};
int n2 = sizeof(list2) / sizeof(list2[0]);
assert(func0(list2, n2) == 2);
int list3[] = {1,5,7,9,10};
int n3 = siz... | O3 | c | func0:
endbr64
test %esi,%esi
jle 12f4 <func0+0x54>
lea -0x1(%rsi),%eax
mov $0xffffffff,%ecx
lea 0x4(%rdi,%rax,4),%rsi
mov $0xffffffff,%eax
jmp 12d9 <func0+0x39>
nopl 0x0(%rax)
cmp $0xffffffff,%eax
cmove %edx,%eax
cmp $0xffffffff,%eax
je 12d0 <func0+0x30>
cmp $0xffffffff,%ecx
jne ... | func0:
endbr64
test esi, esi
jle short loc_12F4
movsxd rsi, esi
mov eax, 0FFFFFFFFh
mov ecx, 0FFFFFFFFh
lea rsi, [rdi+rsi*4]
jmp short loc_12D9
loc_12C0:
cmp eax, 0FFFFFFFFh
cmovz eax, edx
loc_12C6:
cmp ecx, 0FFFFFFFFh
jz short loc_12D0
cmp eax, 0FFFFFFFFh
jnz short loc_12... | long long func0(int *a1, int a2)
{
int v2; // eax
int v3; // ecx
int *v4; // rsi
if ( a2 <= 0 )
return 1LL;
v2 = -1;
v3 = -1;
v4 = &a1[a2];
do
{
if ( (*a1 & 1) != 0 )
{
if ( v2 == -1 )
v2 = *a1;
}
else if ( v3 == -1 )
{
v3 = *a1;
}
if ( v3 != -1 &&... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012f4
MOVSXD RSI,ESI
MOV EAX,0xffffffff
MOV ECX,0xffffffff
LEA RSI,[RDI + RSI*0x4]
JMP 0x001012d9
LAB_001012c0:
CMP EAX,-0x1
CMOVZ EAX,EDX
LAB_001012c6:
CMP ECX,-0x1
JZ 0x001012d0
CMP EAX,-0x1
JNZ 0x001012f0
LAB_001012d0:
ADD RDI,0x4
CMP RSI,RDI
JZ 0x001012f0
LAB_001012d9:
MOV EDX,d... | int func0(uint *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint uVar4;
if (param_2 < 1) {
return 1;
}
uVar3 = 0xffffffff;
uVar4 = 0xffffffff;
puVar1 = param_1 + param_2;
do {
uVar2 = *param_1;
if ((uVar2 & 1) == 0) {
if (uVar4 == 0xffffffff) {
uVar4 = ... |
7,032 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int* func0(const char *test_str, int *size) {
char *str = strdup(test_str);
str = strtok(str, "(), ");
int initial_size = 4, count = 0;
int *res = malloc(initial_size * sizeof(int));
while (str != NULL) {
if (count == initial_size) {
initial_size *= 2;
res =... | int main() {
int size;
int *result;
result = func0("(7, 8, 9)", &size);
assert(size == 3 && result[0] == 7 && result[1] == 8 && result[2] == 9);
free(result);
result = func0("(1, 2, 3)", &size);
assert(size == 3 && result[0] == 1 && result[1] == 2 && result[2] == 3);
free... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1130 <strdup@plt>
mov %rax,-0x20(%rbp)
mov -0x20(%rbp),%rax
lea 0xdaf(%rip),%rsi
mov %rax,%rdi
callq 1110 <strtok@plt>
mov %rax,-0x20(... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+s], rdi
mov [rbp+var_40], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strdup
mov [rbp+nptr], rax
mov rax, [rbp+nptr]
lea rdx, delim; "(), "
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov ... | void * func0(const char *a1, _DWORD *a2)
{
char *v2; // rax
int v3; // eax
int v5; // [rsp+18h] [rbp-28h]
int v6; // [rsp+1Ch] [rbp-24h]
const char *nptr; // [rsp+20h] [rbp-20h]
void *ptr; // [rsp+28h] [rbp-18h]
v2 = strdup(a1);
nptr = strtok(v2, "(), ");
v5 = 4;
v6 = 0;
ptr = malloc(0x10uLL);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101130
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101110
MOV qword ptr [... | void * func0(char *param_1,int *param_2)
{
int iVar1;
char *__s;
int local_30;
int local_2c;
char *local_28;
void *local_20;
__s = strdup(param_1);
local_28 = strtok(__s,"(), ");
local_30 = 4;
local_2c = 0;
local_20 = malloc(0x10);
while (local_28 != (char *)0x0) {
if (local_2c == local_... |
7,033 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int* func0(const char *test_str, int *size) {
char *str = strdup(test_str);
str = strtok(str, "(), ");
int initial_size = 4, count = 0;
int *res = malloc(initial_size * sizeof(int));
while (str != NULL) {
if (count == initial_size) {
initial_size *= 2;
res =... | int main() {
int size;
int *result;
result = func0("(7, 8, 9)", &size);
assert(size == 3 && result[0] == 7 && result[1] == 8 && result[2] == 9);
free(result);
result = func0("(1, 2, 3)", &size);
assert(size == 3 && result[0] == 1 && result[1] == 2 && result[2] == 3);
free... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rsi,0x8(%rsp)
callq 1130 <strdup@plt>
mov %rax,%rdi
lea 0xdb5(%rip),%rsi
callq 1120 <strtok@plt>
mov %rax,%rbx
mov $0x10,%edi
callq 1100 <malloc@plt>
mov %rax,%r13
mov $0x0,%r12d
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
call _strdup
mov rdi, rax
lea rsi, asc_2004; "(), "
call _strtok
mov rbx, rax
mov edi, 10h
call _malloc
mov r13, rax
mov r12d, 0
mov r15d, 4
mov ... | long long func0(long long a1, _DWORD *a2)
{
long long v2; // rax
long long v3; // rbx
long long v4; // r13
long long v5; // r12
int v6; // r15d
int v7; // r14d
v2 = strdup();
v3 = strtok(v2, "(), ");
v4 = malloc(16LL);
v5 = 0LL;
v6 = 4;
v7 = 0;
if ( v3 )
{
while ( 1 )
{
v7 = ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
CALL 0x00101130
MOV RDI,RAX
LEA RSI,[0x102004]
CALL 0x00101120
MOV RBX,RAX
MOV EDI,0x10
CALL 0x00101100
MOV R13,RAX
MOV R12D,0x0
MOV R15D,0x4
MOV R14D,0x0
TEST RBX,RBX
JNZ 0x001012ae
LAB_0010127b:
MOV RAX,qwo... | void * func0(char *param_1,int *param_2)
{
char *pcVar1;
void *__ptr;
long lVar2;
long lVar3;
int iVar4;
int iVar5;
pcVar1 = strdup(param_1);
pcVar1 = strtok(pcVar1,"(), ");
__ptr = malloc(0x10);
lVar3 = 0;
iVar5 = 4;
iVar4 = 0;
if (pcVar1 != (char *)0x0) {
while( true ) {
iVar4 ... |
7,034 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int* func0(const char *test_str, int *size) {
char *str = strdup(test_str);
str = strtok(str, "(), ");
int initial_size = 4, count = 0;
int *res = malloc(initial_size * sizeof(int));
while (str != NULL) {
if (count == initial_size) {
initial_size *= 2;
res =... | int main() {
int size;
int *result;
result = func0("(7, 8, 9)", &size);
assert(size == 3 && result[0] == 7 && result[1] == 8 && result[2] == 9);
free(result);
result = func0("(1, 2, 3)", &size);
assert(size == 3 && result[0] == 1 && result[1] == 2 && result[2] == 3);
free... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
sub $0x18,%rsp
mov %rsi,0x8(%rsp)
callq 1130 <strdup@plt>
lea 0xc5e(%rip),%rsi
mov %rax,%rdi
callq 1120 <strtok@plt>
mov $0x10,%edi
mov %rax,%r15
callq 1100 <malloc@plt>
movl $0x4,0x4(%rsp)
m... | func0:
endbr64
push r15
push r14
lea r14, asc_2004; "(), "
push r13
push r12
xor r12d, r12d
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
call _strdup
mov rsi, r14
mov rdi, rax
call _strtok
mov edi, 10h
mov r15, rax
call _malloc
mov [rsp+48h+var_... | long long func0(long long a1, _DWORD *a2)
{
int v2; // r12d
long long v3; // rax
long long v4; // r15
long long v5; // rbp
long long i; // r13
int v8; // [rsp+4h] [rbp-44h]
v2 = 0;
v3 = strdup();
v4 = strtok(v3, "(), ");
v8 = 4;
v5 = malloc(16LL);
if ( v4 )
{
for ( i = 0LL; ; ++i )
{... | func0:
ENDBR64
PUSH R15
PUSH R14
LEA R14,[0x102004]
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
CALL 0x00101130
MOV RSI,R14
MOV RDI,RAX
CALL 0x00101120
MOV EDI,0x10
MOV R15,RAX
CALL 0x00101100
MOV dword ptr [RSP + 0x4],0x4
MOV RBP,RAX
TEST R15,R15
JZ 0x00101430
XOR R13D,... | void * func0(char *param_1,int *param_2)
{
char *pcVar1;
void *__ptr;
long lVar2;
int iVar3;
long lVar4;
int local_44;
iVar3 = 0;
pcVar1 = strdup(param_1);
pcVar1 = strtok(pcVar1,"(), ");
__ptr = malloc(0x10);
local_44 = 4;
if (pcVar1 != (char *)0x0) {
lVar4 = 0;
while( true ) {
... |
7,035 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| int* func0(const char *test_str, int *size) {
char *str = strdup(test_str);
str = strtok(str, "(), ");
int initial_size = 4, count = 0;
int *res = malloc(initial_size * sizeof(int));
while (str != NULL) {
if (count == initial_size) {
initial_size *= 2;
res =... | int main() {
int size;
int *result;
result = func0("(7, 8, 9)", &size);
assert(size == 3 && result[0] == 7 && result[1] == 8 && result[2] == 9);
free(result);
result = func0("(1, 2, 3)", &size);
assert(size == 3 && result[0] == 1 && result[1] == 2 && result[2] == 3);
free... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
sub $0x18,%rsp
mov %rsi,0x8(%rsp)
callq 1130 <strdup@plt>
lea 0xc5e(%rip),%rsi
mov %rax,%rdi
callq 1120 <strtok@plt>
mov $0x10,%edi
mov %rax,%r15
callq 1100 <malloc@plt>
movl $0x4,0x4(%rsp)
m... | func0:
endbr64
push r15
push r14
lea r14, delim; "(), "
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rsi
call _strdup
mov rsi, r14; delim
mov rdi, rax; s
call _strtok
mov edi, 10h; size
mov rbx, rax
call _malloc
mov rbp, rax
test rb... | void * func0(const char *a1, _DWORD *a2)
{
char *v2; // rax
char *v3; // rbx
void *v4; // rbp
long long v5; // r13
int v6; // r12d
int v7; // eax
v2 = strdup(a1);
v3 = strtok(v2, "(), ");
v4 = malloc(0x10uLL);
if ( v3 )
{
v5 = 0LL;
v6 = 4;
while ( 1 )
{
if ( v6 == (_DWORD)v5... | func0:
ENDBR64
PUSH R15
PUSH R14
LEA R14,[0x102004]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RSI
CALL 0x00101130
MOV RSI,R14
MOV RDI,RAX
CALL 0x00101120
MOV EDI,0x10
MOV RBX,RAX
CALL 0x00101100
MOV RBP,RAX
TEST RBX,RBX
JZ 0x00101460
XOR R13D,R13D
MOV R12D,0x4
JMP 0x00101408
LAB_001013d... | void * func0(char *param_1,int *param_2)
{
int iVar1;
char *pcVar2;
void *__ptr;
long lVar3;
int iVar4;
long lVar5;
pcVar2 = strdup(param_1);
pcVar2 = strtok(pcVar2,"(), ");
__ptr = malloc(0x10);
if (pcVar2 == (char *)0x0) {
iVar1 = 0;
}
else {
lVar5 = 0;
iVar4 = 4;
do {
... |
7,036 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int* a, int n, int x) {
int i = 0;
for (; i < n; i++) {
if (a[i] > x) {
break;
}
}
return i;
}
| int main() {
int arr1[] = {1, 2, 4, 5};
int arr2[] = {1, 2, 4, 5};
int arr3[] = {1, 2, 4, 5};
assert(func0(arr1, 4, 6) == 4);
assert(func0(arr2, 4, 3) == 2);
assert(func0(arr3, 4, 7) == 4);
return EXIT_SUCCESS;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11a3 <func0+0x3a>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jl 11ad <func0+... | 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_4], 0
jmp short loc_11A3
loc_1184:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_20], eax... | long long func0(long long a1, int a2, int a3)
{
unsigned int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; (int)i < a2 && a3 >= *(_DWORD *)(4LL * (int)i + a1); ++i )
;
return i;
} | 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 + -0x4],0x0
JMP 0x001011a3
LAB_00101184:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dw... | int func0(long param_1,int param_2,int param_3)
{
int local_c;
local_c = 0;
while ((local_c < param_2 && (*(int *)(param_1 + (long)local_c * 4) <= param_3))) {
local_c = local_c + 1;
}
return local_c;
} |
7,037 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int* a, int n, int x) {
int i = 0;
for (; i < n; i++) {
if (a[i] > x) {
break;
}
}
return i;
}
| int main() {
int arr1[] = {1, 2, 4, 5};
int arr2[] = {1, 2, 4, 5};
int arr3[] = {1, 2, 4, 5};
assert(func0(arr1, 4, 6) == 4);
assert(func0(arr2, 4, 3) == 2);
assert(func0(arr3, 4, 7) == 4);
return EXIT_SUCCESS;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1195 <func0+0x2c>
lea -0x1(%rsi),%r8d
mov $0x0,%eax
jmp 117f <func0+0x16>
mov %rsi,%rax
mov %eax,%ecx
cmp %edx,(%rdi,%rax,4)
jg 1192 <func0+0x29>
lea 0x1(%rax),%ecx
lea 0x1(%rax),%rsi
cmp %r8,%rax
jne 117c <func0+0x13>
mov %ecx,%eax
retq
mov ... | func0:
endbr64
test esi, esi
jle short loc_1188
mov eax, 0
loc_1176:
cmp [rdi], edx
jg short locret_118D
add eax, 1
add rdi, 4
cmp esi, eax
jnz short loc_1176
mov eax, esi
retn
loc_1188:
mov eax, 0
locret_118D:
retn | long long func0(_DWORD *a1, int a2, int a3)
{
long long result; // rax
if ( a2 <= 0 )
return 0LL;
result = 0LL;
while ( *a1 <= a3 )
{
result = (unsigned int)(result + 1);
++a1;
if ( a2 == (_DWORD)result )
return (unsigned int)a2;
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101188
MOV EAX,0x0
LAB_00101176:
CMP dword ptr [RDI],EDX
JG 0x0010118d
ADD EAX,0x1
ADD RDI,0x4
CMP ESI,EAX
JNZ 0x00101176
MOV EAX,ESI
RET
LAB_00101188:
MOV EAX,0x0
LAB_0010118d:
RET | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
if (param_2 < 1) {
iVar1 = 0;
}
else {
iVar1 = 0;
while (*param_1 <= param_3) {
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
if (param_2 == iVar1) {
return param_2;
}
}
}
return iVar1;
} |
7,038 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int* a, int n, int x) {
int i = 0;
for (; i < n; i++) {
if (a[i] > x) {
break;
}
}
return i;
}
| int main() {
int arr1[] = {1, 2, 4, 5};
int arr2[] = {1, 2, 4, 5};
int arr3[] = {1, 2, 4, 5};
assert(func0(arr1, 4, 6) == 4);
assert(func0(arr2, 4, 3) == 2);
assert(func0(arr3, 4, 7) == 4);
return EXIT_SUCCESS;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 116c <func0+0x2c>
sub $0x1,%esi
xor %eax,%eax
jmp 1160 <func0+0x20>
lea 0x1(%rax),%r8d
lea 0x1(%rax),%rcx
cmp %rsi,%rax
je 1168 <func0+0x28>
mov %rcx,%rax
mov %eax,%r8d
cmp %edx,(%rdi,%rax,4)
jle 1150 <func0+0x10>
mov %r8d,%eax
retq
xor %r8d... | func0:
endbr64
xor eax, eax
test esi, esi
jg short loc_115B
jmp short locret_115F
loc_1150:
add eax, 1
add rdi, 4
cmp esi, eax
jz short locret_1160
loc_115B:
cmp [rdi], edx
jle short loc_1150
locret_115F:
retn
locret_1160:
retn | long long func0(_DWORD *a1, int a2, int a3)
{
long long result; // rax
result = 0LL;
if ( a2 > 0 )
{
do
{
if ( *a1 > a3 )
break;
result = (unsigned int)(result + 1);
++a1;
}
while ( a2 != (_DWORD)result );
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST ESI,ESI
JG 0x0010115b
JMP 0x0010115f
LAB_00101150:
ADD EAX,0x1
ADD RDI,0x4
CMP ESI,EAX
JZ 0x00101160
LAB_0010115b:
CMP dword ptr [RDI],EDX
JLE 0x00101150
LAB_0010115f:
RET
LAB_00101160:
RET | void func0(int *param_1,int param_2,int param_3)
{
int iVar1;
iVar1 = 0;
if (0 < param_2) {
while (*param_1 <= param_3) {
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
if (param_2 == iVar1) {
return;
}
}
}
return;
} |
7,039 | func0 |
#include <assert.h>
#include <stdlib.h>
| int func0(int* a, int n, int x) {
int i = 0;
for (; i < n; i++) {
if (a[i] > x) {
break;
}
}
return i;
}
| int main() {
int arr1[] = {1, 2, 4, 5};
int arr2[] = {1, 2, 4, 5};
int arr3[] = {1, 2, 4, 5};
assert(func0(arr1, 4, 6) == 4);
assert(func0(arr2, 4, 3) == 2);
assert(func0(arr3, 4, 7) == 4);
return EXIT_SUCCESS;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 116c <func0+0x2c>
sub $0x1,%esi
xor %eax,%eax
jmp 1160 <func0+0x20>
lea 0x1(%rax),%r8d
lea 0x1(%rax),%rcx
cmp %rsi,%rax
je 1168 <func0+0x28>
mov %rcx,%rax
mov %eax,%r8d
cmp %edx,(%rdi,%rax,4)
jle 1150 <func0+0x10>
mov %r8d,%eax
retq
xor %r8d... | func0:
endbr64
xor eax, eax
test esi, esi
jg short loc_115B
retn
loc_1150:
add eax, 1
add rdi, 4
cmp esi, eax
jz short locret_1160
loc_115B:
cmp [rdi], edx
jle short loc_1150
retn
locret_1160:
retn | long long func0(_DWORD *a1, int a2, int a3)
{
long long result; // rax
result = 0LL;
if ( a2 > 0 )
{
do
{
if ( *a1 > a3 )
break;
result = (unsigned int)(result + 1);
++a1;
}
while ( a2 != (_DWORD)result );
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST ESI,ESI
JG 0x0010115b
RET
LAB_00101150:
ADD EAX,0x1
ADD RDI,0x4
CMP ESI,EAX
JZ 0x00101160
LAB_0010115b:
CMP dword ptr [RDI],EDX
JLE 0x00101150
RET
LAB_00101160:
RET | void func0(int *param_1,int param_2,int param_3)
{
int iVar1;
iVar1 = 0;
if (param_2 < 1) {
return;
}
do {
if (param_3 < *param_1) {
return;
}
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
} while (param_2 != iVar1);
return;
} |
7,040 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
int reti;
char* patterns = "ab{3}";
reti = regcomp(®ex, patterns, REG_EXTENDED);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Regex compilation error";
}
reti = regexec(®ex, text, 0, NU... | int main() {
assert(strcmp(func0("ac"), "Not matched!") == 0);
assert(strcmp(func0("dc"), "Not matched!") == 0);
assert(strcmp(func0("abbbba"), "Found a match!") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xdd9(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10e0 <regcomp@plt>
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aAb3; "ab{3}"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax;... | const char * func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-5Ch]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
if ( regcomp(&preg, "ab{3}", 1) )
{
fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start);
return "Regex co... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010e0
MOV dword p... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_58,"ab{3}",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if (... |
7,041 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
int reti;
char* patterns = "ab{3}";
reti = regcomp(®ex, patterns, REG_EXTENDED);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Regex compilation error";
}
reti = regexec(®ex, text, 0, NU... | int main() {
assert(strcmp(func0("ac"), "Not matched!") == 0);
assert(strcmp(func0("dc"), "Not matched!") == 0);
assert(strcmp(func0("abbbba"), "Found a match!") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1,%edx
lea 0xe23(%rip),%rsi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 1271 <func0+0x88>
mov %rsp,%rbp
mov $0x0,%r8d
mov $0x0,%ecx
mov $... | func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov rdi, rsp
mov edx, 1
lea rsi, aAb3; "ab{3}"
call _regcomp
test eax, eax
jnz short loc_1291
mov rbp, rsp
mov r8d, 0
mov ecx, 0
mov edx, 0
mo... | const char * func0(long long a1)
{
int v1; // ebx
const char *result; // rax
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v3[9] = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v3, "ab{3}", 1LL) )
{
fwrite("Could not compile regex\n", 1LL, 24LL, stderr);
return "Regex compilation error";
}
else... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102038]
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x00101291
MOV RBP,RSP
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101100
MOV EBX,EAX
MOV ... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"ab{3}",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
... |
7,042 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
int reti;
char* patterns = "ab{3}";
reti = regcomp(®ex, patterns, REG_EXTENDED);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Regex compilation error";
}
reti = regexec(®ex, text, 0, NU... | int main() {
assert(strcmp(func0("ac"), "Not matched!") == 0);
assert(strcmp(func0("dc"), "Not matched!") == 0);
assert(strcmp(func0("abbbba"), "Found a match!") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd56(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 1358 <func0+0x88>
xor %edx,%edx
xor %r8d,%r8d
xor %... | func0:
endbr64
push r12
mov edx, 1
lea rsi, aAb3; "ab{3}"
push rbp
mov rbp, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12
call _regcomp
test eax, eax
jnz short loc_1368
xor edx, edx
xor r8d, r8d
xor ecx, ... | const char * func0(long long a1)
{
int v1; // ebp
const char *result; // rax
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v3[9] = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v3, "ab{3}", 1LL) )
{
fwrite("Could not compile regex\n", 1LL, 24LL, stderr);
return "Regex compilation error";
}
else... | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
LEA RSI,[0x102038]
PUSH RBP
MOV RBP,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x00101368
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBP
MOV RDI,R12
CALL 0x00101100
MOV RDI,R12
MOV ... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"ab{3}",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
... |
7,043 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char* func0(const char* text) {
regex_t regex;
int reti;
char* patterns = "ab{3}";
reti = regcomp(®ex, patterns, REG_EXTENDED);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Regex compilation error";
}
reti = regexec(®ex, text, 0, NU... | int main() {
assert(strcmp(func0("ac"), "Not matched!") == 0);
assert(strcmp(func0("dc"), "Not matched!") == 0);
assert(strcmp(func0("abbbba"), "Found a match!") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd56(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 1358 <func0+0x88>
xor %edx,%edx
xor %r8d,%r8d
xor %... | func0:
endbr64
push rbp
mov edx, 1; cflags
lea rsi, pattern; "ab{3}"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
test eax, eax
jnz short loc_1360
xor edx, edx; nmatch
xor ... | const char * func0(char *string)
{
int v1; // ebx
const char *result; // rax
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
if ( regcomp(&_0, "ab{3}", 1) )
{
fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start);
re... | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x102038]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x00101360
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101100
MOV RDI,RBP
MOV ... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"ab{3}",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
... |
7,044 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
struct dynamicTuple {
char elements[100];
};
| struct dynamicTuple func0(char test_list[][100], int listSize, char test_str[]) {
struct dynamicTuple result;
strcpy(result.elements, "");
for (int i = 0; i < listSize; i++) {
strcat(result.elements, test_list[i]);
strcat(result.elements, ", ");
}
strcat(result.elements, test_... | int main() {
char list1[2][100] = {"WEB", "is"};
char list2[2][100] = {"We", "are"};
char list3[2][100] = {"Part", "is"};
struct dynamicTuple result;
result = func0(list1, 2, "best");
assert(strcmp(result.elements, "WEB, is, best") == 0);
result = func0(list2, 2, "Developers");
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %edx,-0xa4(%rbp)
mov %rcx,-0xb0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movb $0x0,-0x80(%rbp)
movl $0x0,-0x84(%rbp)
jmp 126a <func0+0xc1>
mov -0x84(%r... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov [rbp+var_A4], edx
mov [rbp+src], rcx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+dest], 0
mov [rbp+var_84], 0
jmp short loc_1277
loc_1213:
mov... | long long func0(long long a1, long long a2, int a3, const char *a4)
{
long long v4; // rbx
long long v5; // rbx
long long v6; // rbx
long long v7; // rbx
long long v8; // rbx
long long v9; // rbx
int i; // [rsp+2Ch] [rbp-84h]
char dest[8]; // [rsp+30h] [rbp-80h] BYREF
long long v15; // [rsp+38h] [rbp... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV dword ptr [RBP + -0xa4],EDX
MOV qword ptr [RBP + -0xb0],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV byte ptr [RBP + -0x80],0x0
MOV dword ptr [RBP + -0x84],0x0... | int8 * func0(int8 *param_1,long param_2,int param_3,char *param_4)
{
size_t sVar1;
long in_FS_OFFSET;
int local_8c;
char local_88;
int auStack_87 [7];
int8 local_80;
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int8 local_58;
int8 local_50;
int8 local_48;
int8 local_40;
int... |
7,045 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
struct dynamicTuple {
char elements[100];
};
| struct dynamicTuple func0(char test_list[][100], int listSize, char test_str[]) {
struct dynamicTuple result;
strcpy(result.elements, "");
for (int i = 0; i < listSize; i++) {
strcat(result.elements, test_list[i]);
strcat(result.elements, ", ");
}
strcat(result.elements, test_... | int main() {
char list1[2][100] = {"WEB", "is"};
char list2[2][100] = {"We", "are"};
char list3[2][100] = {"Part", "is"};
struct dynamicTuple result;
result = func0(list1, 2, "best");
assert(strcmp(result.elements, "WEB, is, best") == 0);
result = func0(list2, 2, "Developers");
... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x70,%rsp
mov %rdi,%r12
mov %rcx,%r14
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
movb $0x0,(%rsp)
test %edx,%edx
jle 11fa <func0+0x71>
mov %rsi,%rbx
lea -0x1(%rdx),%eax
lea (%rax,%rax,4),%rax
lea ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r12, rdi
mov r15, rcx
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
mov byte ptr [rsp+0A8h+var_A8], 0
test edx, edx
jle short loc_121F
mov rbx, rsi
lea eax, [rdx-1... | __m128i * func0(__m128i *a1, long long a2, int a3, long long a4)
{
long long v5; // rbx
long long v6; // r14
__m128i v8; // [rsp+0h] [rbp-A8h] BYREF
__m128i v9; // [rsp+10h] [rbp-98h] BYREF
__m128i v10; // [rsp+20h] [rbp-88h] BYREF
__m128i v11; // [rsp+30h] [rbp-78h] BYREF
__m128i v12; // [rsp+40h] [rbp-6... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R12,RDI
MOV R15,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV byte ptr [RSP],0x0
TEST EDX,EDX
JLE 0x0010121f
MOV RBX,RSI
LEA EAX,[RDX + -0x1]
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA R14,[RS... | int8 * func0(int8 *param_1,long param_2,int param_3,int8 param_4)
{
long lVar1;
long in_FS_OFFSET;
int1 local_a8;
int7 uStack_a7;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
int8... |
7,046 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
struct dynamicTuple {
char elements[100];
};
| struct dynamicTuple func0(char test_list[][100], int listSize, char test_str[]) {
struct dynamicTuple result;
strcpy(result.elements, "");
for (int i = 0; i < listSize; i++) {
strcat(result.elements, test_list[i]);
strcat(result.elements, ", ");
}
strcat(result.elements, test_... | int main() {
char list1[2][100] = {"WEB", "is"};
char list2[2][100] = {"We", "are"};
char list3[2][100] = {"Part", "is"};
struct dynamicTuple result;
result = func0(list1, 2, "best");
assert(strcmp(result.elements, "WEB, is, best") == 0);
result = func0(list2, 2, "Developers");
... | O2 | c | func0:
endbr64
push %r15
push %r14
mov %rcx,%r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rbp
movb $0x0,(%rsp)
test %edx,%edx
jle 15c0 <func0+0xc0>
lea -0x1(%rdx),%eax
mov %rsi,%r15
le... | func0:
endbr64
push r15
push r14
mov r14, rcx
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+var_s68], rax
xor eax, eax
mov rbp, rsp
mov byte ptr [rsp+var_s0], 0
test edx, edx
jle short loc_15AD
lea eax, [rdx-1]
mov ... | __m128i * func0(__m128i *a1, long long a2, int a3, long long a4)
{
long long v5; // r15
long long v6; // r13
long long v7; // rax
long long v8; // rsi
long long v9; // rax
__m128i v10; // xmm0
__m128i v11; // xmm1
__m128i v12; // xmm2
__m128i v13; // xmm3
__m128i v14; // xmm4
__m128i v15; // xmm5
... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RCX
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV byte ptr [RSP],0x0
TEST EDX,EDX
JLE 0x001015ad
LEA EAX,[RDX + -0x1]
MOV R15,RSI
LEA RBX,[0x102004]
MOV RBP,RSP
LEA RAX,[RAX + R... | int8 * func0(int8 *param_1,long param_2,int param_3,int8 param_4)
{
size_t sVar1;
long lVar2;
long lVar3;
long in_FS_OFFSET;
char local_a8;
int7 uStack_a7;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uSta... |
7,047 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
struct dynamicTuple {
char elements[100];
};
| struct dynamicTuple func0(char test_list[][100], int listSize, char test_str[]) {
struct dynamicTuple result;
strcpy(result.elements, "");
for (int i = 0; i < listSize; i++) {
strcat(result.elements, test_list[i]);
strcat(result.elements, ", ");
}
strcat(result.elements, test_... | int main() {
char list1[2][100] = {"WEB", "is"};
char list2[2][100] = {"We", "are"};
char list3[2][100] = {"Part", "is"};
struct dynamicTuple result;
result = func0(list1, 2, "best");
assert(strcmp(result.elements, "WEB, is, best") == 0);
result = func0(list2, 2, "Developers");
... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rcx,%r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rbp
movb $0x0,(%rsp)
test %edx,%edx
jle 15c0 <func0+0xc0>
lea -0x1(%rdx),%eax
mov %rsi,%r15
le... | func0:
endbr64
push r15
mov r15, rcx
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+var_s68], rax
xor eax, eax
mov rbp, rsp
mov byte ptr [rsp+var_s0], 0
test edx, edx
jle short loc_15AD
movsxd rdx, edx
mov rbx... | __m128i * func0(__m128i *a1, long long a2, int a3, long long a4)
{
long long v5; // rbx
long long v6; // r14
size_t v7; // rax
long long v8; // rsi
long long v9; // rax
__m128i v10; // xmm0
__m128i v11; // xmm1
__m128i v12; // xmm2
__m128i v13; // xmm3
__m128i v14; // xmm4
__m128i v15; // xmm5
_... | func0:
ENDBR64
PUSH R15
MOV R15,RCX
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV byte ptr [RSP],0x0
TEST EDX,EDX
JLE 0x001015ad
MOVSXD RDX,EDX
MOV RBX,RSI
LEA R13,[0x102004]
MOV RBP,RSP
LEA RAX,[RDX + RDX*0x4... | int8 * func0(int8 *param_1,long param_2,int param_3,int8 param_4)
{
size_t sVar1;
long lVar2;
long lVar3;
long in_FS_OFFSET;
char local_a8;
int7 uStack_a7;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uSta... |
7,048 | func0 | #include <assert.h>
| double func0(int s, int l) {
double perimeter = s * l;
return perimeter;
}
| int main() {
assert(func0(4, 20) == 80);
assert(func0(10, 15) == 150);
assert(func0(9, 7) == 63);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
imul -0x18(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_14]
imul eax, [rbp+var_18]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(int a1, int a2)
{
return (double)(a2 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,dword ptr [RBP + -0x18]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(int param_1,int param_2)
{
return (double)(param_1 * param_2);
} |
7,049 | func0 | #include <assert.h>
| double func0(int s, int l) {
double perimeter = s * l;
return perimeter;
}
| int main() {
assert(func0(4, 20) == 80);
assert(func0(10, 15) == 150);
assert(func0(9, 7) == 63);
return 0;
}
| O1 | c | func0:
endbr64
imul %esi,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
retq
| func0:
endbr64
imul edi, esi
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
retn | double func0(int a1, int a2)
{
return (double)(a2 * a1);
} | func0:
ENDBR64
IMUL EDI,ESI
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
RET | double func0(int param_1,int param_2)
{
return (double)(param_1 * param_2);
} |
7,050 | func0 | #include <assert.h>
| double func0(int s, int l) {
double perimeter = s * l;
return perimeter;
}
| int main() {
assert(func0(4, 20) == 80);
assert(func0(10, 15) == 150);
assert(func0(9, 7) == 63);
return 0;
}
| O2 | c | func0:
endbr64
imul %esi,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
retq
| func0:
endbr64
imul edi, esi
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
retn | double func0(int a1, int a2)
{
return (double)(a2 * a1);
} | func0:
ENDBR64
IMUL EDI,ESI
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
RET | double func0(int param_1,int param_2)
{
return (double)(param_1 * param_2);
} |
7,051 | func0 | #include <assert.h>
| double func0(int s, int l) {
double perimeter = s * l;
return perimeter;
}
| int main() {
assert(func0(4, 20) == 80);
assert(func0(10, 15) == 150);
assert(func0(9, 7) == 63);
return 0;
}
| O3 | c | func0:
endbr64
imul %esi,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
retq
| func0:
endbr64
imul edi, esi
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
retn | double func0(int a1, int a2)
{
return (double)(a2 * a1);
} | func0:
ENDBR64
IMUL EDI,ESI
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
RET | double func0(int param_1,int param_2)
{
return (double)(param_1 * param_2);
} |
7,052 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int length) {
for (int i = 0; i < length; i++) {
if (nums[i] % 2 != i % 2) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {3, 2, 1};
int arr2[] = {1, 2, 3};
int arr3[] = {2, 1, 4};
assert(func0(arr1, 3) == false);
assert(func0(arr2, 3) == false);
assert(func0(arr3, 3) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c1 <func0+0x58>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %ed... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_4], 0
jmp short loc_11CB
loc_1181:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
... | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) % 2 != i % 2 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cb
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
... | int8 func0(long param_1,int param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 1;
}
if (*(int *)(param_1 + (long)local_c * 4) % 2 != local_c % 2) break;
local_c = local_c + 1;
}
return 0;
} |
7,053 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int length) {
for (int i = 0; i < length; i++) {
if (nums[i] % 2 != i % 2) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {3, 2, 1};
int arr2[] = {1, 2, 3};
int arr3[] = {2, 1, 4};
assert(func0(arr1, 3) == false);
assert(func0(arr2, 3) == false);
assert(func0(arr3, 3) == true);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ae <func0+0x45>
lea -0x1(%rsi),%r8d
mov $0x0,%ecx
jmp 117f <func0+0x16>
mov %rax,%rcx
mov (%rdi,%rcx,4),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
mov %ecx,%esi
shr $0x1f,%esi
lea (%rsi,%rcx,1),%edx
and $... | func0:
endbr64
test esi, esi
jle short loc_11AB
mov esi, esi
mov ecx, 0
loc_1178:
mov eax, [rdi+rcx*4]
mov edx, eax
shr edx, 1Fh
add eax, edx
and eax, 1
sub eax, edx
mov r8d, ecx
shr r8d, 1Fh
lea edx, [r8+rcx]
and edx, 1
sub edx, r8d
cmp eax, edx
jnz sh... | long long func0(long long a1, int a2)
{
long long v2; // rcx
if ( a2 <= 0 )
return 1LL;
v2 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v2) % 2 == (int)v2 % 2 )
{
if ( ++v2 == a2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011ab
MOV ESI,ESI
MOV ECX,0x0
LAB_00101178:
MOV EAX,dword ptr [RDI + RCX*0x4]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
AND EAX,0x1
SUB EAX,EDX
MOV R8D,ECX
SHR R8D,0x1f
LEA EDX,[R8 + RCX*0x1]
AND EDX,0x1
SUB EDX,R8D
CMP EAX,EDX
JNZ 0x001011b1
ADD RCX,0x1
CMP RCX,RSI
JNZ 0x00101178
MOV EA... | int8 func0(long param_1,uint param_2)
{
uint uVar1;
ulong uVar2;
if ((int)param_2 < 1) {
return 1;
}
uVar2 = 0;
do {
uVar1 = (uint)(uVar2 >> 0x1f) & 1;
if (*(int *)(param_1 + uVar2 * 4) % 2 != (uVar1 + (int)uVar2 & 1) - uVar1) {
return 0;
}
uVar2 = uVar2 + 1;
} while (uVar2 !... |
7,054 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int length) {
for (int i = 0; i < length; i++) {
if (nums[i] % 2 != i % 2) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {3, 2, 1};
int arr2[] = {1, 2, 3};
int arr3[] = {2, 1, 4};
assert(func0(arr1, 3) == false);
assert(func0(arr2, 3) == false);
assert(func0(arr3, 3) == true);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
sub $0x1,%esi
xor %edx,%edx
jmp 115c <func0+0x1c>
lea 0x1(%rdx),%rax
cmp %rsi,%rdx
je 1180 <func0+0x40>
mov %rax,%rdx
mov (%rdi,%rdx,4),%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %ecx,%eax
and $0x1,%eax
sub %ecx,%eax
mov %edx... | func0:
endbr64
test esi, esi
jle short loc_1178
movsxd rsi, esi
xor edx, edx
jmp short loc_1159
loc_1150:
add rdx, 1
cmp rdx, rsi
jz short loc_1178
loc_1159:
mov eax, [rdi+rdx*4]
mov ecx, eax
shr ecx, 1Fh
add eax, ecx
and eax, 1
sub eax, ecx
mov ecx, edx
and ... | long long func0(long long a1, int a2)
{
long long v2; // rdx
if ( a2 <= 0 )
return 1LL;
v2 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v2) % 2 == (v2 & 1) )
{
if ( ++v2 == a2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101178
MOVSXD RSI,ESI
XOR EDX,EDX
JMP 0x00101159
LAB_00101150:
ADD RDX,0x1
CMP RDX,RSI
JZ 0x00101178
LAB_00101159:
MOV EAX,dword ptr [RDI + RDX*0x4]
MOV ECX,EAX
SHR ECX,0x1f
ADD EAX,ECX
AND EAX,0x1
SUB EAX,ECX
MOV ECX,EDX
AND ECX,0x1
CMP EAX,ECX
JZ 0x00101150
XOR EAX,EAX
RET
LAB_0010... | int8 func0(long param_1,int param_2)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) % 2 != ((uint)lVar1 & 1)) {
return 0;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_2);
}
return 1;
} |
7,055 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int nums[], int length) {
for (int i = 0; i < length; i++) {
if (nums[i] % 2 != i % 2) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {3, 2, 1};
int arr2[] = {1, 2, 3};
int arr3[] = {2, 1, 4};
assert(func0(arr1, 3) == false);
assert(func0(arr2, 3) == false);
assert(func0(arr3, 3) == true);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
sub $0x1,%esi
xor %edx,%edx
jmp 115c <func0+0x1c>
lea 0x1(%rdx),%rax
cmp %rsi,%rdx
je 1180 <func0+0x40>
mov %rax,%rdx
mov (%rdi,%rdx,4),%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %ecx,%eax
and $0x1,%eax
sub %ecx,%eax
mov %edx... | func0:
endbr64
test esi, esi
jle short loc_1178
movsxd rsi, esi
xor edx, edx
jmp short loc_1159
loc_1150:
add rdx, 1
cmp rsi, rdx
jz short loc_1178
loc_1159:
mov eax, [rdi+rdx*4]
mov ecx, eax
shr ecx, 1Fh
add eax, ecx
and eax, 1
sub eax, ecx
mov ecx, edx
and ... | long long func0(long long a1, int a2)
{
long long v2; // rdx
if ( a2 <= 0 )
return 1LL;
v2 = 0LL;
while ( *(_DWORD *)(a1 + 4 * v2) % 2 == (v2 & 1) )
{
if ( a2 == ++v2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101178
MOVSXD RSI,ESI
XOR EDX,EDX
JMP 0x00101159
LAB_00101150:
ADD RDX,0x1
CMP RSI,RDX
JZ 0x00101178
LAB_00101159:
MOV EAX,dword ptr [RDI + RDX*0x4]
MOV ECX,EAX
SHR ECX,0x1f
ADD EAX,ECX
AND EAX,0x1
SUB EAX,ECX
MOV ECX,EDX
AND ECX,0x1
CMP EAX,ECX
JZ 0x00101150
XOR EAX,EAX
RET
LAB_0010... | int8 func0(long param_1,int param_2)
{
long lVar1;
if (0 < param_2) {
lVar1 = 0;
do {
if (*(int *)(param_1 + lVar1 * 4) % 2 != ((uint)lVar1 & 1)) {
return 0;
}
lVar1 = lVar1 + 1;
} while (param_2 != lVar1);
}
return 1;
} |
7,056 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int *elements;
int size;
} Tuple;
| Tuple func0(Tuple test_tup) {
Tuple res;
int *elements = (int*)malloc(test_tup.size * sizeof(int));
int count = 0;
for (int i = 0; i < test_tup.size; i++) {
// Assuming we are not handling nested tuples within C as Python handles
// We'd be adding checks for flat integers only
... | int main() {
Tuple test_tup1 = {(int[]){1, 5, 7, 10}, 4};
Tuple test_tup2 = {(int[]){2, 6, 8, 11}, 4};
Tuple test_tup3 = {(int[]){3, 7, 9, 12}, 4};
Tuple result1 = func0(test_tup1);
Tuple result2 = func0(test_tup2);
Tuple result3 = func0(test_tup3);
assert(result1.size == 4 && res... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,%rax
mov %rsi,%rcx
mov %rcx,%rdx
mov %rax,-0x30(%rbp)
mov %rdx,-0x28(%rbp)
mov -0x28(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, rdi
mov rcx, rsi
mov rdx, rcx
mov [rbp+var_30], rax
mov [rbp+var_28], rdx
mov eax, dword ptr [rbp+var_28]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_20], 0
mov [rb... | _DWORD * func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-20h]
int i; // [rsp+14h] [rbp-1Ch]
_DWORD *v5; // [rsp+18h] [rbp-18h]
v5 = malloc(4LL * a2);
v3 = 0;
for ( i = 0; i < a2; ++i )
v5[v3++] = *(_DWORD *)(4LL * i + a1);
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,RDI
MOV RCX,RSI
MOV RDX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x28],RDX
MOV EAX,dword ptr [RBP + -0x28]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x... | int [16] func0(long param_1,int param_2)
{
int auVar1 [16];
void *pvVar2;
int4 local_28;
int4 local_24;
int4 uStack_c;
pvVar2 = malloc((long)param_2 << 2);
local_28 = 0;
for (local_24 = 0; local_24 < param_2; local_24 = local_24 + 1) {
*(int4 *)((long)pvVar2 + (long)local_28 * 4) =
*(i... |
7,057 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int *elements;
int size;
} Tuple;
| Tuple func0(Tuple test_tup) {
Tuple res;
int *elements = (int*)malloc(test_tup.size * sizeof(int));
int count = 0;
for (int i = 0; i < test_tup.size; i++) {
// Assuming we are not handling nested tuples within C as Python handles
// We'd be adding checks for flat integers only
... | int main() {
Tuple test_tup1 = {(int[]){1, 5, 7, 10}, 4};
Tuple test_tup2 = {(int[]){2, 6, 8, 11}, 4};
Tuple test_tup3 = {(int[]){3, 7, 9, 12}, 4};
Tuple result1 = func0(test_tup1);
Tuple result2 = func0(test_tup2);
Tuple result3 = func0(test_tup3);
assert(result1.size == 4 && res... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %rsi,%r12
mov %esi,%ebx
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 11f0 <func0+0x47>
mov %rbp,%rdi
lea -0x1(%r12),%esi
mov $0x0,%edx
mov (%rdi,%rdx,4),%ecx
mov %ecx,(%rax,%rdx,4)
mov ... | func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov rbx, rsi
mov r12d, esi
movsxd rdi, esi
shl rdi, 2
call _malloc
test ebx, ebx
jle short loc_11E9
mov esi, ebx
mov edx, 0
loc_11D1:
mov ecx, [rbp+rdx*4+0]
mov [rax+rdx*4], ecx
add rdx, 1
cmp rdx, rsi
jnz... | 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 R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV RBX,RSI
MOV R12D,ESI
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x001011e9
MOV ESI,EBX
MOV EDX,0x0
LAB_001011d1:
MOV ECX,dword ptr [RBP + RDX*0x4]
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP RDX,RSI
JNZ 0x001011d1
LAB_001011e1:
MOV EDX,R12... | 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;
} |
7,058 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int *elements;
int size;
} Tuple;
| Tuple func0(Tuple test_tup) {
Tuple res;
int *elements = (int*)malloc(test_tup.size * sizeof(int));
int count = 0;
for (int i = 0; i < test_tup.size; i++) {
// Assuming we are not handling nested tuples within C as Python handles
// We'd be adding checks for flat integers only
... | int main() {
Tuple test_tup1 = {(int[]){1, 5, 7, 10}, 4};
Tuple test_tup2 = {(int[]){2, 6, 8, 11}, 4};
Tuple test_tup3 = {(int[]){3, 7, 9, 12}, 4};
Tuple result1 = func0(test_tup1);
Tuple result2 = func0(test_tup2);
Tuple result3 = func0(test_tup3);
assert(result1.size == 4 && res... | O2 | c | func0:
endbr64
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
shl $0x2,%rdi
mov %esi,%ebx
callq 10b0 <malloc@plt>
test %r12d,%r12d
jle 13c0 <func0+0x50>
lea -0x1(%r12),%esi
xor %edx,%edx
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp,%rdx,4),%ecx
mov %ecx,(%rax,%rdx... | func0:
endbr64
push r13
mov r13, rdi
push r12
movsxd r12, esi
push rbp
shl r12, 2
mov ebp, esi
push rbx
mov rdi, r12
mov rbx, rsi
sub rsp, 8
call _malloc
mov r8, rax
test ebx, ebx
jle short loc_13E0
mov rdx, r12
mov rsi, r13
mov rdi, rax
call _memcpy
add... | long long func0(long long a1, int a2)
{
long long result; // rax
long long v3; // rcx
result = malloc(4LL * a2);
if ( a2 > 0 )
return memcpy(result, a1, 4LL * a2, v3, result);
return result;
} | func0:
ENDBR64
PUSH R13
MOV R13,RDI
PUSH R12
MOVSXD R12,ESI
PUSH RBP
SHL R12,0x2
MOV EBP,ESI
PUSH RBX
MOV RDI,R12
MOV RBX,RSI
SUB RSP,0x8
CALL 0x001010d0
MOV R8,RAX
TEST EBX,EBX
JLE 0x001013e0
MOV RDX,R12
MOV RSI,R13
MOV RDI,RAX
CALL 0x001010c0
ADD RSP,0x8
MOV EDX,EBP
MOV R8,RAX
POP RBX
POP RBP
MOV RAX,R8
POP R12
POP R... | int1 [16] func0(void *param_1,int param_2)
{
int1 auVar1 [16];
int1 auVar2 [16];
auVar2._0_8_ = malloc((long)param_2 << 2);
if (0 < param_2) {
auVar1._0_8_ = memcpy(auVar2._0_8_,param_1,(long)param_2 << 2);
auVar1._8_4_ = param_2;
auVar1._12_4_ = 0;
return auVar1;
}
auVar2._8_8_ = 0;
... |
7,059 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int *elements;
int size;
} Tuple;
| Tuple func0(Tuple test_tup) {
Tuple res;
int *elements = (int*)malloc(test_tup.size * sizeof(int));
int count = 0;
for (int i = 0; i < test_tup.size; i++) {
// Assuming we are not handling nested tuples within C as Python handles
// We'd be adding checks for flat integers only
... | int main() {
Tuple test_tup1 = {(int[]){1, 5, 7, 10}, 4};
Tuple test_tup2 = {(int[]){2, 6, 8, 11}, 4};
Tuple test_tup3 = {(int[]){3, 7, 9, 12}, 4};
Tuple result1 = func0(test_tup1);
Tuple result2 = func0(test_tup2);
Tuple result3 = func0(test_tup3);
assert(result1.size == 4 && res... | O3 | c | func0:
endbr64
push %r12
mov %rdi,%r12
movslq %esi,%rdi
push %rbp
shl $0x2,%rdi
mov %esi,%ebp
push %rbx
mov %rsi,%rbx
callq 10d0 <malloc@plt>
mov %rax,%r8
test %ebx,%ebx
jle 13b0 <func0+0x50>
lea -0x1(%rbx),%eax
mov %r12,%rsi
mov %r8,%rdi
lea 0x4(,%rax,4),%rdx
callq 10c0 <memcpy@... | func0:
endbr64
push r12
mov r12d, esi
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
shl rdi, 2; size
mov rbx, rsi
call _malloc
mov rcx, rax
test ebx, ebx
jle short loc_13A8
mov edx, ebx
mov rsi, rbp; src
mov rdi, rax; dest
shl rdx, 2; n
call _memcpy
mov ed... | void * func0(void *src, int a2)
{
void *result; // rax
result = malloc(4LL * a2);
if ( a2 > 0 )
return memcpy(result, src, 4LL * (unsigned int)a2);
return result;
} | func0:
ENDBR64
PUSH R12
MOV R12D,ESI
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
SHL RDI,0x2
MOV RBX,RSI
CALL 0x001010d0
MOV RCX,RAX
TEST EBX,EBX
JLE 0x001013a8
MOV EDX,EBX
MOV RSI,RBP
MOV RDI,RAX
SHL RDX,0x2
CALL 0x001010c0
MOV EDX,R12D
POP RBX
POP RBP
MOV RCX,RAX
POP R12
MOV RAX,RCX
RET
LAB_001013a8:
XOR R12D,R12D
P... | int [16] func0(void *param_1,uint param_2)
{
int auVar1 [16];
int auVar2 [16];
auVar2._0_8_ = malloc((long)(int)param_2 << 2);
if (0 < (int)param_2) {
auVar1._0_8_ = memcpy(auVar2._0_8_,param_1,(ulong)param_2 << 2);
auVar1._8_4_ = param_2;
auVar1._12_4_ = 0;
return auVar1;
}
auVar2._8_8... |
7,060 | func0 |
#include <assert.h>
| int func0(int input_list[][2], int size) {
return size;
}
| int main() {
int list1[][2] = {{1, 3}, {5, 7}, {9, 11}, {13, 15}};
int list2[][2] = {{1, 2}, {2, 3}, {4, 5}};
int list3[][2] = {{1, 0}, {2, 0}};
assert(func0(list1, 4) == 4);
assert(func0(list2, 3) == 3);
assert(func0(list3, 2) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov -0xc(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(long long a1, unsigned int a2)
{
return a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | int4 func0(int8 param_1,int4 param_2)
{
return param_2;
} |
7,061 | func0 |
#include <assert.h>
| int func0(int input_list[][2], int size) {
return size;
}
| int main() {
int list1[][2] = {{1, 3}, {5, 7}, {9, 11}, {13, 15}};
int list2[][2] = {{1, 2}, {2, 3}, {4, 5}};
int list3[][2] = {{1, 0}, {2, 0}};
assert(func0(list1, 4) == 4);
assert(func0(list2, 3) == 3);
assert(func0(list3, 2) == 2);
return 0;
}
| O1 | c | func0:
endbr64
mov %esi,%eax
retq
| func0:
endbr64
mov eax, esi
retn | long long func0(long long a1, unsigned int a2)
{
return a2;
} | func0:
ENDBR64
MOV EAX,ESI
RET | int4 func0(int8 param_1,int4 param_2)
{
return param_2;
} |
7,062 | func0 |
#include <assert.h>
| int func0(int input_list[][2], int size) {
return size;
}
| int main() {
int list1[][2] = {{1, 3}, {5, 7}, {9, 11}, {13, 15}};
int list2[][2] = {{1, 2}, {2, 3}, {4, 5}};
int list3[][2] = {{1, 0}, {2, 0}};
assert(func0(list1, 4) == 4);
assert(func0(list2, 3) == 3);
assert(func0(list3, 2) == 2);
return 0;
}
| O2 | c | func0:
endbr64
mov %esi,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, esi
retn | long long func0(long long a1, unsigned int a2)
{
return a2;
} | func0:
ENDBR64
MOV EAX,ESI
RET | int4 func0(int8 param_1,int4 param_2)
{
return param_2;
} |
7,063 | func0 |
#include <assert.h>
| int func0(int input_list[][2], int size) {
return size;
}
| int main() {
int list1[][2] = {{1, 3}, {5, 7}, {9, 11}, {13, 15}};
int list2[][2] = {{1, 2}, {2, 3}, {4, 5}};
int list3[][2] = {{1, 0}, {2, 0}};
assert(func0(list1, 4) == 4);
assert(func0(list2, 3) == 3);
assert(func0(list3, 2) == 2);
return 0;
}
| O3 | c | func0:
endbr64
mov %esi,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, esi
retn | long long func0(long long a1, unsigned int a2)
{
return a2;
} | func0:
ENDBR64
MOV EAX,ESI
RET | int4 func0(int8 param_1,int4 param_2)
{
return param_2;
} |
7,064 | func0 |
#include <assert.h>
| int func0(int arr[], int x, int n) {
int low = 0;
int high = n - 1;
int res = -1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] > x) {
high = mid - 1;
} else if (arr[mid] < x) {
low = mid + 1;
} else {
res = ... | int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 1, 3) == 0);
int arr2[] = {1, 1, 1, 2, 3, 4};
assert(func0(arr2, 1, 6) == 2);
int arr3[] = {2, 3, 2, 3, 6, 8, 9};
assert(func0(arr3, 3, 7) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x10(%rbp)
mov -0x20(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
movl $0xffffffff,-0x8(%rbp)
jmp 1203 <func0+0x9a>
mov -0x10(%rbp),%edx
mov -0xc(%rbp),%eax
add %edx,%e... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_10], 0
mov eax, [rbp+var_20]
sub eax, 1
mov [rbp+var_C], eax
mov [rbp+var_8], 0FFFFFFFFh
jmp short loc_1203
loc_1194:
mov edx, [rbp+var_10]
mov eax, [rbp... | long long func0(long long a1, int a2, int a3)
{
int v4; // [rsp+10h] [rbp-10h]
int v5; // [rsp+14h] [rbp-Ch]
unsigned int v6; // [rsp+18h] [rbp-8h]
int v7; // [rsp+1Ch] [rbp-4h]
v4 = 0;
v5 = a3 - 1;
v6 = -1;
while ( v4 <= v5 )
{
v7 = (v4 + v5) / 2;
if ( a2 >= *(_DWORD *)(4LL * v7 + a1) )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x10],0x0
MOV EAX,dword ptr [RBP + -0x20]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0xffffffff
JMP 0x00101203
LAB_00101194:
MOV EDX,dword ... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int4 local_18;
int4 local_14;
int4 local_10;
local_18 = 0;
local_14 = param_3 + -1;
local_10 = -1;
while (local_18 <= local_14) {
iVar1 = (local_14 + local_18) / 2;
if (param_2 < *(int *)(param_1 + (long)iVar1 * 4)) {
local_1... |
7,065 | func0 |
#include <assert.h>
| int func0(int arr[], int x, int n) {
int low = 0;
int high = n - 1;
int res = -1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] > x) {
high = mid - 1;
} else if (arr[mid] < x) {
low = mid + 1;
} else {
res = ... | int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 1, 3) == 0);
int arr2[] = {1, 1, 1, 2, 3, 4};
assert(func0(arr2, 1, 6) == 2);
int arr3[] = {2, 3, 2, 3, 6, 8, 9};
assert(func0(arr3, 3, 7) == 3);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1,%edx
js 11ae <func0+0x45>
mov $0xffffffff,%r9d
mov $0x0,%r8d
jmp 1192 <func0+0x29>
lea 0x1(%rax),%r8d
jl 118d <func0+0x24>
lea 0x1(%rax),%r8d
mov %eax,%r9d
cmp %edx,%r8d
jg 11b4 <func0+0x4b>
lea (%r8,%rdx,1),%ecx
mov %ecx,%eax
shr $0x1f,%eax
add %e... | func0:
endbr64
sub edx, 1
js short loc_11AE
mov r9d, 0FFFFFFFFh
mov r8d, 0
jmp short loc_1192
loc_1180:
lea r8d, [rax+1]
jl short loc_118D
lea r8d, [rax+1]
mov r9d, eax
loc_118D:
cmp r8d, edx
jg short loc_11B4
loc_1192:
lea ecx, [r8+rdx]
mov eax, ecx
shr eax, 1... | long long func0(long long a1, int a2, int a3)
{
int v3; // edx
unsigned int v4; // r9d
int v5; // r8d
int v6; // eax
int v7; // ecx
v3 = a3 - 1;
if ( v3 < 0 )
{
return (unsigned int)-1;
}
else
{
v4 = -1;
v5 = 0;
do
{
v6 = (v5 + v3) / 2;
v7 = *(_DWORD *)(a1 + 4LL *... | func0:
ENDBR64
SUB EDX,0x1
JS 0x001011ae
MOV R9D,0xffffffff
MOV R8D,0x0
JMP 0x00101192
LAB_00101180:
LEA R8D,[RAX + 0x1]
JL 0x0010118d
LEA R8D,[RAX + 0x1]
MOV R9D,EAX
LAB_0010118d:
CMP R8D,EDX
JG 0x001011b4
LAB_00101192:
LEA ECX,[R8 + RDX*0x1]
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOVSXD RCX,EAX
MOV ECX,dwor... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
param_3 = param_3 + -1;
if (param_3 < 0) {
iVar4 = -1;
}
else {
iVar4 = -1;
iVar3 = 0;
do {
iVar2 = (iVar3 + param_3) / 2;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (... |
7,066 | func0 |
#include <assert.h>
| int func0(int arr[], int x, int n) {
int low = 0;
int high = n - 1;
int res = -1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] > x) {
high = mid - 1;
} else if (arr[mid] < x) {
low = mid + 1;
} else {
res = ... | int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 1, 3) == 0);
int arr2[] = {1, 1, 1, 2, 3, 4};
assert(func0(arr2, 1, 6) == 2);
int arr3[] = {2, 3, 2, 3, 6, 8, 9};
assert(func0(arr3, 3, 7) == 3);
return 0;
}
| O2 | c | func0:
endbr64
mov $0xffffffff,%r9d
sub $0x1,%edx
js 136b <func0+0x3b>
xor %ecx,%ecx
jmp 134f <func0+0x1f>
nopl 0x0(%rax,%rax,1)
lea -0x1(%rax),%edx
cmp %ecx,%edx
jl 136b <func0+0x3b>
lea (%rdx,%rcx,1),%eax
sar %eax
movslq %eax,%r8
mov (%rdi,%r8,4),%r8d
cmp %esi,%r8d
jg 1348 ... | func0:
endbr64
mov r9d, 0FFFFFFFFh
sub edx, 1
js short loc_12FB
xor ecx, ecx
jmp short loc_12DF
loc_12D8:
lea edx, [rax-1]
cmp edx, ecx
jl short loc_12FB
loc_12DF:
lea eax, [rdx+rcx]
sar eax, 1
movsxd r8, eax
mov r8d, [rdi+r8*4]
cmp r8d, esi
jg short loc_12D8
lea ... | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r9d
int v4; // edx
int v5; // ecx
int v6; // eax
int v7; // r8d
v3 = -1;
v4 = a3 - 1;
if ( v4 >= 0 )
{
v5 = 0;
do
{
while ( 1 )
{
v6 = (v4 + v5) >> 1;
v7 = *(_DWORD *)(a1 + 4LL * v6);
... | func0:
ENDBR64
MOV R9D,0xffffffff
SUB EDX,0x1
JS 0x001012fb
XOR ECX,ECX
JMP 0x001012df
LAB_001012d8:
LEA EDX,[RAX + -0x1]
CMP EDX,ECX
JL 0x001012fb
LAB_001012df:
LEA EAX,[RDX + RCX*0x1]
SAR EAX,0x1
MOVSXD R8,EAX
MOV R8D,dword ptr [RDI + R8*0x4]
CMP R8D,ESI
JG 0x001012d8
LEA ECX,[RAX + 0x1]
CMOVGE R9D,EAX
CMP EDX,ECX
JG... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = -1;
param_3 = param_3 + -1;
if (-1 < param_3) {
iVar3 = 0;
do {
while( true ) {
iVar2 = param_3 + iVar3 >> 1;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (par... |
7,067 | func0 |
#include <assert.h>
| int func0(int arr[], int x, int n) {
int low = 0;
int high = n - 1;
int res = -1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] > x) {
high = mid - 1;
} else if (arr[mid] < x) {
low = mid + 1;
} else {
res = ... | int main() {
int arr1[] = {1, 2, 3};
assert(func0(arr1, 1, 3) == 0);
int arr2[] = {1, 1, 1, 2, 3, 4};
assert(func0(arr2, 1, 6) == 2);
int arr3[] = {2, 3, 2, 3, 6, 8, 9};
assert(func0(arr3, 3, 7) == 3);
return 0;
}
| O3 | c | func0:
endbr64
mov $0xffffffff,%r9d
sub $0x1,%edx
js 134b <func0+0x3b>
xor %ecx,%ecx
jmp 132f <func0+0x1f>
nopl 0x0(%rax,%rax,1)
lea -0x1(%rax),%edx
cmp %edx,%ecx
jg 134b <func0+0x3b>
lea (%rdx,%rcx,1),%eax
sar %eax
movslq %eax,%r8
mov (%rdi,%r8,4),%r8d
cmp %r8d,%esi
jl 1328 ... | func0:
endbr64
mov r9d, 0FFFFFFFFh
sub edx, 1
js short loc_1364
xor r8d, r8d
jmp short loc_1340
loc_1338:
lea edx, [rax-1]
cmp r8d, edx
jg short loc_1364
loc_1340:
lea ecx, [rdx+r8]
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
movsxd rcx, eax
mov ecx, [rdi... | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r9d
int v4; // edx
int v5; // r8d
int v6; // eax
int v7; // ecx
v3 = -1;
v4 = a3 - 1;
if ( v4 >= 0 )
{
v5 = 0;
do
{
while ( 1 )
{
v6 = (v4 + v5) / 2;
v7 = *(_DWORD *)(a1 + 4LL * v6);
i... | func0:
ENDBR64
MOV R9D,0xffffffff
SUB EDX,0x1
JS 0x00101364
XOR R8D,R8D
JMP 0x00101340
LAB_00101338:
LEA EDX,[RAX + -0x1]
CMP R8D,EDX
JG 0x00101364
LAB_00101340:
LEA ECX,[RDX + R8*0x1]
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOVSXD RCX,EAX
MOV ECX,dword ptr [RDI + RCX*0x4]
CMP ESI,ECX
JL 0x00101338
LEA R8D,[RA... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = -1;
param_3 = param_3 + -1;
if (-1 < param_3) {
iVar3 = 0;
do {
while( true ) {
iVar2 = (param_3 + iVar3) / 2;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (pa... |
7,068 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
int result;
char* pattern = "a.*?b$";
// Compile regex
result = regcomp(®ex, pattern, REG_EXTENDED);
if (result) {
fprintf(stderr, "Could not compile regex\n");
return "Error";
}
// Execute regex
... | int main() {
assert(strcmp(func0("aabbbb"), "Found a match!") == 0);
assert(strcmp(func0("aabAbbbc"), "Not matched!") == 0);
assert(strcmp(func0("accddbbjjj"), "Not matched!") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xdd9(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10e0 <regcomp@plt>
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aAB; "a.*?b$"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax;... | const char * func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-5Ch]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
if ( regcomp(&preg, "a.*?b$", 1) )
{
fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start);
return "Error";... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010e0
MOV dword p... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_58,"a.*?b$",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if ... |
7,069 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
int result;
char* pattern = "a.*?b$";
// Compile regex
result = regcomp(®ex, pattern, REG_EXTENDED);
if (result) {
fprintf(stderr, "Could not compile regex\n");
return "Error";
}
// Execute regex
... | int main() {
assert(strcmp(func0("aabbbb"), "Found a match!") == 0);
assert(strcmp(func0("aabAbbbc"), "Not matched!") == 0);
assert(strcmp(func0("accddbbjjj"), "Not matched!") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1,%edx
lea 0xe11(%rip),%rsi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 1271 <func0+0x88>
mov %rsp,%rbp
mov $0x0,%r8d
mov $0x0,%ecx
mov $... | func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov rdi, rsp
mov edx, 1
lea rsi, aAB; "a.*?b$"
call _regcomp
test eax, eax
jnz short loc_1291
mov rbp, rsp
mov r8d, 0
mov ecx, 0
mov edx, 0
mo... | const char * func0(long long a1)
{
int v1; // ebx
const char *result; // rax
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v3[9] = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v3, "a.*?b$", 1LL) )
{
fwrite("Could not compile regex\n", 1LL, 24LL, stderr);
return "Error";
}
else
{
v1 = reg... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102026]
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x00101291
MOV RBP,RSP
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101100
MOV EBX,EAX
MOV ... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"a.*?b$",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
... |
7,070 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
int result;
char* pattern = "a.*?b$";
// Compile regex
result = regcomp(®ex, pattern, REG_EXTENDED);
if (result) {
fprintf(stderr, "Could not compile regex\n");
return "Error";
}
// Execute regex
... | int main() {
assert(strcmp(func0("aabbbb"), "Found a match!") == 0);
assert(strcmp(func0("aabAbbbc"), "Not matched!") == 0);
assert(strcmp(func0("accddbbjjj"), "Not matched!") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd44(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 1358 <func0+0x88>
xor %edx,%edx
xor %r8d,%r8d
xor %... | func0:
endbr64
push r12
mov edx, 1
lea rsi, aAB; "a.*?b$"
push rbp
mov rbp, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12
call _regcomp
test eax, eax
jnz short loc_1368
xor edx, edx
xor r8d, r8d
xor ecx, ... | const char * func0(long long a1)
{
int v1; // ebp
const char *result; // rax
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
v3[9] = __readfsqword(0x28u);
if ( (unsigned int)regcomp(v3, "a.*?b$", 1LL) )
{
fwrite("Could not compile regex\n", 1LL, 24LL, stderr);
return "Error";
}
else
{
v1 = reg... | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
LEA RSI,[0x102026]
PUSH RBP
MOV RBP,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x00101368
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBP
MOV RDI,R12
CALL 0x00101100
MOV RDI,R12
MOV ... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"a.*?b$",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
... |
7,071 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char* func0(const char* text) {
regex_t regex;
int result;
char* pattern = "a.*?b$";
// Compile regex
result = regcomp(®ex, pattern, REG_EXTENDED);
if (result) {
fprintf(stderr, "Could not compile regex\n");
return "Error";
}
// Execute regex
... | int main() {
assert(strcmp(func0("aabbbb"), "Found a match!") == 0);
assert(strcmp(func0("aabAbbbc"), "Not matched!") == 0);
assert(strcmp(func0("accddbbjjj"), "Not matched!") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd44(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10d0 <regcomp@plt>
test %eax,%eax
jne 1358 <func0+0x88>
xor %edx,%edx
xor %r8d,%r8d
xor %... | func0:
endbr64
push rbp
mov edx, 1; cflags
lea rsi, pattern; "a.*?b$"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
test eax, eax
jnz short loc_1360
xor edx, edx; nmatch
xor ... | const char * func0(char *string)
{
int v1; // ebx
const char *result; // rax
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
if ( regcomp(&_0, "a.*?b$", 1) )
{
fwrite("Could not compile regex\n", 1uLL, 0x18uLL, _bss_start);
r... | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x102026]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x00101360
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101100
MOV RDI,RBP
MOV ... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"a.*?b$",1);
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
... |
7,072 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
char* name;
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item *)a;
Item *itemB = (Item *)b;
if (itemA->price > itemB->price) return 1;
if (itemA->price < itemB->price)... | Item* func0(Item items[], int totalItems, int n) {
qsort(items, totalItems, sizeof(Item), compare);
Item* result = (Item*)malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
result[i] = items[i];
}
return result;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item* result1 = func0(items1, 2, 1);
assert(result1[0].price == 101.1);
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item* result2 = func0(item... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rsi
mov -0x18(%rbp),%rax
lea -0x8c(%rip),%rcx
mov $0x10,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
mov -0x20(%rbp),%eax
cltq
shl $0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+base], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_1C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 10h; size
mov rdi, rax; base
call _qsort
mo... | char * func0(char *a1, int a2, int a3)
{
char *v3; // rax
char *v4; // rcx
long long v5; // rdx
int i; // [rsp+14h] [rbp-Ch]
char *v9; // [rsp+18h] [rbp-8h]
qsort(a1, a2, 0x10uLL, compare);
v9 = (char *)malloc(16LL * a3);
for ( i = 0; i < a3; ++i )
{
v3 = &a1[16 * i];
v4 = &v9[16 * i];
v5... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x10
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,dword ptr [RBP +... | void * func0(void *param_1,int param_2,int param_3)
{
int8 uVar1;
void *pvVar2;
int8 *puVar3;
int8 *puVar4;
int local_14;
qsort(param_1,(long)param_2,0x10,compare);
pvVar2 = malloc((long)param_3 << 4);
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
puVar3 = (int8 *)((long)para... |
7,073 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
char* name;
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item *)a;
Item *itemB = (Item *)b;
if (itemA->price > itemB->price) return 1;
if (itemA->price < itemB->price)... | Item* func0(Item items[], int totalItems, int n) {
qsort(items, totalItems, sizeof(Item), compare);
Item* result = (Item*)malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
result[i] = items[i];
}
return result;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item* result1 = func0(items1, 2, 1);
assert(result1[0].price == 101.1);
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item* result2 = func0(item... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %edx,%ebp
movslq %esi,%rsi
lea -0x3f(%rip),%rcx
mov $0x10,%edx
callq 10a0 <qsort@plt>
movslq %ebp,%rdi
shl $0x4,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 1244 <func0+0x55>
lea -0x1(%rbp),%ecx
add $0x1,%rcx
shl ... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, edx
movsxd rsi, esi
lea rcx, compare
mov edx, 10h
call _qsort
movsxd rdi, ebx
shl rdi, 4
call _malloc
test ebx, ebx
jle short loc_1240
mov ecx, ebx
shl rcx, 4
mov edx, 0
loc_122D:
movdqu xmm0, xmm... | long long func0(long long a1, int a2, int a3)
{
long long result; // rax
long long v5; // rdx
qsort(a1, a2, 16LL, compare);
result = malloc(16LL * a3);
if ( a3 > 0 )
{
v5 = 0LL;
do
{
*(__m128i *)(result + v5) = _mm_loadu_si128((const __m128i *)(a1 + v5));
v5 += 16LL;
}
whil... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,EDX
MOVSXD RSI,ESI
LEA RCX,[0x1011c9]
MOV EDX,0x10
CALL 0x001010a0
MOVSXD RDI,EBX
SHL RDI,0x4
CALL 0x001010d0
TEST EBX,EBX
JLE 0x00101240
MOV ECX,EBX
SHL RCX,0x4
MOV EDX,0x0
LAB_0010122d:
MOVDQU XMM0,xmmword ptr [RBP + RDX*0x1]
MOVUPS xmmword ptr [RAX + R... | void func0(void *param_1,int param_2,uint param_3)
{
int8 uVar1;
void *pvVar2;
long lVar3;
qsort(param_1,(long)param_2,0x10,compare);
pvVar2 = malloc((long)(int)param_3 << 4);
if (0 < (int)param_3) {
lVar3 = 0;
do {
uVar1 = ((int8 *)((long)param_1 + lVar3))[1];
*(int8 *)((long)pvVar2... |
7,074 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
char* name;
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item *)a;
Item *itemB = (Item *)b;
if (itemA->price > itemB->price) return 1;
if (itemA->price < itemB->price)... | Item* func0(Item items[], int totalItems, int n) {
qsort(items, totalItems, sizeof(Item), compare);
Item* result = (Item*)malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
result[i] = items[i];
}
return result;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item* result1 = func0(items1, 2, 1);
assert(result1[0].price == 101.1);
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item* result2 = func0(item... | O2 | c | func0:
endbr64
push %rbp
movslq %esi,%rsi
mov %edx,%ebp
lea -0x41(%rip),%rcx
push %rbx
mov $0x10,%edx
mov %rdi,%rbx
sub $0x8,%rsp
callq 10a0 <qsort@plt>
movslq %ebp,%rdi
shl $0x4,%rdi
callq 10d0 <malloc@plt>
test %ebp,%ebp
jle 1462 <func0+0x52>
lea -0x1(%rbp),%ecx
xor %edx,%edx
add ... | func0:
endbr64
push r12
movsxd r12, edx
movsxd rsi, esi
lea rcx, compare
push rbp
mov edx, 10h
mov rbp, rdi
push rbx
mov rbx, r12
shl r12, 4
call _qsort
mov rdi, r12
call _malloc
mov r8, rax
test ebx, ebx
jle short loc_1479
mov rdx, r12
mov rsi, rbp
mov rd... | long long func0(long long a1, int a2, int a3)
{
long long v4; // r12
long long v5; // rax
long long v6; // rcx
long long v7; // r8
v4 = 16LL * a3;
qsort(a1, a2, 16LL, compare);
v5 = malloc(v4);
v7 = v5;
if ( a3 > 0 )
return memcpy(v5, a1, v4, v6, v5);
return v7;
} | func0:
ENDBR64
PUSH R12
MOVSXD R12,EDX
MOVSXD RSI,ESI
LEA RCX,[0x101400]
PUSH RBP
MOV EDX,0x10
MOV RBP,RDI
PUSH RBX
MOV RBX,R12
SHL R12,0x4
CALL 0x001010b0
MOV RDI,R12
CALL 0x001010f0
MOV R8,RAX
TEST EBX,EBX
JLE 0x00101479
MOV RDX,R12
MOV RSI,RBP
MOV RDI,RAX
CALL 0x001010e0
MOV R8,RAX
LAB_00101479:
POP RBX
MOV RAX,R8
P... | void * func0(void *param_1,int param_2,int param_3)
{
void *__dest;
qsort(param_1,(long)param_2,0x10,compare);
__dest = malloc((long)param_3 << 4);
if (0 < param_3) {
__dest = memcpy(__dest,param_1,(long)param_3 << 4);
}
return __dest;
} |
7,075 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
char* name;
double price;
} Item;
int compare(const void *a, const void *b) {
Item *itemA = (Item *)a;
Item *itemB = (Item *)b;
if (itemA->price > itemB->price) return 1;
if (itemA->price < itemB->price)... | Item* func0(Item items[], int totalItems, int n) {
qsort(items, totalItems, sizeof(Item), compare);
Item* result = (Item*)malloc(n * sizeof(Item));
for (int i = 0; i < n; i++) {
result[i] = items[i];
}
return result;
}
| int main() {
Item items1[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item* result1 = func0(items1, 2, 1);
assert(result1[0].price == 101.1);
Item items2[] = {{.name = "Item-1", .price = 101.1}, {.name = "Item-2", .price = 555.22}};
Item* result2 = func0(item... | O3 | c | func0:
endbr64
push %rbp
movslq %esi,%rsi
lea -0x3f(%rip),%rcx
mov %rdi,%rbp
push %rbx
mov %edx,%ebx
mov $0x10,%edx
sub $0x8,%rsp
callq 10b0 <qsort@plt>
movslq %ebx,%rdi
shl $0x4,%rdi
callq 10f0 <malloc@plt>
mov %rax,%r8
test %ebx,%ebx
jle 146f <func0+0x4f>
lea -0x1(%rbx),%edx
mov ... | func0:
endbr64
push rbp
lea rcx, compare; compar
movsxd rsi, esi; nmemb
mov rbp, rdi
push rbx
mov ebx, edx
mov edx, 10h; size
sub rsp, 8
call _qsort
movsxd rdi, ebx
shl rdi, 4; size
call _malloc
mov rcx, rax
test ebx, ebx
jle short loc_146A
mov edx, ebx
mov rsi, ... | void * func0(void *src, int a2, int a3)
{
void *v4; // rax
void *v5; // rcx
qsort(src, a2, 0x10uLL, compare);
v4 = malloc(16LL * a3);
v5 = v4;
if ( a3 > 0 )
return memcpy(v4, src, 16LL * (unsigned int)a3);
return v5;
} | func0:
ENDBR64
PUSH RBP
LEA RCX,[0x1013f0]
MOVSXD RSI,ESI
MOV RBP,RDI
PUSH RBX
MOV EBX,EDX
MOV EDX,0x10
SUB RSP,0x8
CALL 0x001010b0
MOVSXD RDI,EBX
SHL RDI,0x4
CALL 0x001010f0
MOV RCX,RAX
TEST EBX,EBX
JLE 0x0010146a
MOV EDX,EBX
MOV RSI,RBP
MOV RDI,RAX
SHL RDX,0x4
CALL 0x001010e0
MOV RCX,RAX
LAB_0010146a:
ADD RSP,0x8
MOV... | void * func0(void *param_1,int param_2,uint param_3)
{
void *__dest;
qsort(param_1,(long)param_2,0x10,compare);
__dest = malloc((long)(int)param_3 << 4);
if (0 < (int)param_3) {
__dest = memcpy(__dest,param_1,(ulong)param_3 << 4);
}
return __dest;
} |
7,076 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int dict[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += dict[i];
}
return sum;
}
| int main() {
int dict1[] = {100, 200, 300};
int dict2[] = {25, 18, 45};
int dict3[] = {36, 39, 49};
assert(func0(dict1, 3) == 600);
assert(func0(dict2, 3) == 88);
assert(func0(dict3, 3) == 124);
printf("All tests passed successfully.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c5 <func0+0x3c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11C5
loc_11A8:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
add... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 += *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c5
LAB_001011a8:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dwo... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
return local_10;
} |
7,077 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int dict[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += dict[i];
}
return sum;
}
| int main() {
int dict1[] = {100, 200, 300};
int dict2[] = {25, 18, 45};
int dict3[] = {36, 39, 49};
assert(func0(dict1, 3) == 600);
assert(func0(dict2, 3) == 88);
assert(func0(dict3, 3) == 124);
printf("All tests passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11af <func0+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 11a1 <func0+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 11ac <func0+0x23>
| func0:
endbr64
test esi, esi
jle short loc_11AF
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 0
loc_11A1:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_11A1
loc_11AC:
mov eax, edx
retn
loc_11AF:
mov edx, 0
jmp short loc_11AC | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 += *v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011af
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_001011a1:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011a1
LAB_001011ac:
MOV EAX,EDX
RET
LAB_001011af:
MOV EDX,0x0
JMP 0x001011ac | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
7,078 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int dict[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += dict[i];
}
return sum;
}
| int main() {
int dict1[] = {100, 200, 300};
int dict2[] = {25, 18, 45};
int dict3[] = {36, 39, 49};
assert(func0(dict1, 3) == 600);
assert(func0(dict2, 3) == 88);
assert(func0(dict3, 3) == 124);
printf("All tests passed successfully.\n");
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1198 <func0+0x28>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
add (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1188 <func0+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
test esi, esi
jle short loc_1198
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1188:
add eax, [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_1188
retn
loc_1198:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 0LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
result = (unsigned int)(*a1++ + result);
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101198
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101188:
ADD EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x00101188
RET
LAB_00101198:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
return 0;
} |
7,079 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int dict[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += dict[i];
}
return sum;
}
| int main() {
int dict1[] = {100, 200, 300};
int dict2[] = {25, 18, 45};
int dict3[] = {36, 39, 49};
assert(func0(dict1, 3) == 600);
assert(func0(dict2, 3) == 88);
assert(func0(dict3, 3) == 124);
printf("All tests passed successfully.\n");
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1210 <func0+0xa0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 1219 <func0+0xa9>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rdx,%... | func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_1208
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1211
mov edx, esi
mov rax, rdi
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rdi
xchg ax, ax
loc_11A0:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp ... | long long func0(const __m128i *a1, int a2)
{
const __m128i *v2; // rax
__m128i v3; // xmm0
__m128i v4; // xmm2
int v5; // edx
__m128i v6; // xmm0
long long result; // rax
long long v8; // r8
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
LODWORD(result) = 0;
... | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x00101208
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101211
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP
LAB_001011a0:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RAX,RDX
JNZ 0x001011a0
MOVDQA XMM1,XMM0
MOV EDX,ESI
PSRLDQ XM... | int func0(int *param_1,uint param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
if ((int)param_2 < 1) {
iVar7 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar6 = 0;
iVar7 = 0;
}
else {
... |
7,080 | func0 |
#include <assert.h>
int sum_Odd(int n) {
int terms = (n + 1) / 2;
int sum1 = terms * terms;
return sum1;
}
| int func0(int l, int r) {
return sum_Odd(r) - sum_Odd(l - 1);
}
| int main() {
assert(func0(2, 5) == 8);
assert(func0(5, 7) == 12);
assert(func0(7, 13) == 40);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x8,%rsp
mov %edi,-0xc(%rbp)
mov %esi,-0x10(%rbp)
mov -0x10(%rbp),%eax
mov %eax,%edi
callq 1149 <sum_Odd>
mov %eax,%ebx
mov -0xc(%rbp),%eax
sub $0x1,%eax
mov %eax,%edi
callq 1149 <sum_Odd>
sub %eax,%ebx
mov %ebx,%eax
add ... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 8
mov [rbp+var_C], edi
mov [rbp+var_10], esi
mov eax, [rbp+var_10]
mov edi, eax
call sum_Odd
mov ebx, eax
mov eax, [rbp+var_C]
sub eax, 1
mov edi, eax
call sum_Odd
mov edx, ebx
sub edx, eax
mov eax, ed... | long long func0(int a1, unsigned int a2)
{
int v2; // ebx
v2 = sum_Odd(a2);
return v2 - (unsigned int)sum_Odd((unsigned int)(a1 - 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x8
MOV dword ptr [RBP + -0xc],EDI
MOV dword ptr [RBP + -0x10],ESI
MOV EAX,dword ptr [RBP + -0x10]
MOV EDI,EAX
CALL 0x00101149
MOV EBX,EAX
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
MOV EDI,EAX
CALL 0x00101149
MOV EDX,EBX
SUB EDX,EAX
MOV EAX,EDX
MOV RBX,qword ptr [RB... | int func0(int param_1,int4 param_2)
{
int iVar1;
int iVar2;
iVar1 = sum_Odd(param_2);
iVar2 = sum_Odd(param_1 + -1);
return iVar1 - iVar2;
} |
7,081 | func0 |
#include <assert.h>
int sum_Odd(int n) {
int terms = (n + 1) / 2;
int sum1 = terms * terms;
return sum1;
}
| int func0(int l, int r) {
return sum_Odd(r) - sum_Odd(l - 1);
}
| int main() {
assert(func0(2, 5) == 8);
assert(func0(5, 7) == 12);
assert(func0(7, 13) == 40);
return 0;
}
| O1 | c | func0:
endbr64
add $0x1,%esi
mov %esi,%eax
shr $0x1f,%eax
add %esi,%eax
sar %eax
mov %edi,%edx
shr $0x1f,%edx
lea (%rdx,%rdi,1),%edx
sar %edx
imul %eax,%eax
imul %edx,%edx
sub %edx,%eax
retq
| func0:
endbr64
add esi, 1
mov eax, esi
shr eax, 1Fh
add eax, esi
sar eax, 1
mov edx, edi
shr edx, 1Fh
lea edx, [rdx+rdi]
sar edx, 1
imul eax, eax
imul edx, edx
sub eax, edx
retn | long long func0(int a1, int a2)
{
return (unsigned int)((a2 + 1) / 2 * ((a2 + 1) / 2) - a1 / 2 * (a1 / 2));
} | func0:
ENDBR64
ADD ESI,0x1
MOV EAX,ESI
SHR EAX,0x1f
ADD EAX,ESI
SAR EAX,0x1
MOV EDX,EDI
SHR EDX,0x1f
LEA EDX,[RDX + RDI*0x1]
SAR EDX,0x1
IMUL EAX,EAX
IMUL EDX,EDX
SUB EAX,EDX
RET | int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = (param_2 + 1) / 2;
return iVar1 * iVar1 - (param_1 / 2) * (param_1 / 2);
} |
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.