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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
4,582 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(const char* s) {
int count = 0;
int i;
int len = 0;
while(s[len] != '\0') {
len++;
}
for (i = 0; i < len - 2; i++) {
if (s[i] == 's' && s[i + 1] == 't' && s[i + 2] == 'd') {
count++;
}
}
return count;
}
| int main() {
assert(func0("letstdlenstdporstd") == 3);
assert(func0("truststdsolensporsd") == 1);
assert(func0("makestdsostdworthit") == 2);
return 0;
}
| O2 | c | func0:
endbr64
movzbl (%rdi),%edx
test %dl,%dl
je 1250 <func0+0x60>
xor %eax,%eax
nopl (%rax)
mov %eax,%esi
add $0x1,%rax
cmpb $0x0,(%rdi,%rax,1)
jne 1200 <func0+0x10>
cmp $0x1,%esi
jle 1250 <func0+0x60>
lea -0x2(%rsi),%eax
xor %r8d,%r8d
add %rdi,%rax
jmp 122d <func0+0x3d>
nopl ... | func0:
endbr64
movzx edx, byte ptr [rdi]
test dl, dl
jz short loc_1250
xor eax, eax
nop dword ptr [rax]
loc_1200:
mov ecx, eax
add rax, 1
cmp byte ptr [rdi+rax], 0
jnz short loc_1200
cmp ecx, 1
jle short loc_1250
lea eax, [rcx-2]
xor r8d, r8d
add rax, rdi
jmp sh... | long long func0(char *a1)
{
char v1; // dl
long long v2; // rax
int v3; // ecx
unsigned int v4; // r8d
char *v5; // rax
v1 = *a1;
if ( *a1 )
{
v2 = 0LL;
do
v3 = v2++;
while ( a1[v2] );
if ( v3 > 1 )
{
v4 = 0;
v5 = &a1[v3 - 2];
while ( 1 )
{
if ... | func0:
ENDBR64
MOVZX EDX,byte ptr [RDI]
TEST DL,DL
JZ 0x00101250
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101200:
MOV ECX,EAX
ADD RAX,0x1
CMP byte ptr [RDI + RAX*0x1],0x0
JNZ 0x00101200
CMP ECX,0x1
JLE 0x00101250
LEA EAX,[RCX + -0x2]
XOR R8D,R8D
ADD RAX,RDI
JMP 0x0010122d
LAB_00101220:
CMP RDI,RAX
JZ 0x00101249
LAB_001012... | int func0(char *param_1)
{
char cVar1;
long lVar2;
long lVar3;
char *pcVar4;
int iVar5;
int iVar6;
cVar1 = *param_1;
if (cVar1 != '\0') {
lVar3 = 0;
do {
lVar2 = lVar3;
lVar3 = lVar2 + 1;
} while (param_1[lVar3] != '\0');
iVar5 = (int)lVar2;
if (1 < iVar5) {
iVa... |
4,583 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(const char* s) {
int count = 0;
int i;
int len = 0;
while(s[len] != '\0') {
len++;
}
for (i = 0; i < len - 2; i++) {
if (s[i] == 's' && s[i + 1] == 't' && s[i + 2] == 'd') {
count++;
}
}
return count;
}
| int main() {
assert(func0("letstdlenstdporstd") == 3);
assert(func0("truststdsolensporsd") == 1);
assert(func0("makestdsostdworthit") == 2);
return 0;
}
| O3 | c | func0:
endbr64
cmpb $0x0,(%rdi)
je 1250 <func0+0x60>
xor %eax,%eax
nopl 0x0(%rax,%rax,1)
mov %eax,%ecx
add $0x1,%rax
cmpb $0x0,(%rdi,%rax,1)
jne 1200 <func0+0x10>
cmp $0x1,%ecx
jle 1250 <func0+0x60>
lea -0x2(%rcx),%eax
xor %r8d,%r8d
lea 0x1(%rdi,%rax,1),%rax
jmp 1229 <func0+0x39>... | func0:
endbr64
cmp byte ptr [rdi], 0
jz short loc_1250
lea rdx, [rdi+1]
xor eax, eax
nop
loc_1200:
add rdx, 1
mov ecx, eax
add eax, 1
cmp byte ptr [rdx-1], 0
jnz short loc_1200
lea edx, [rcx-1]
cmp eax, 2
jle short loc_1250
xor eax, eax
xor ecx, ecx
jmp short... | long long func0(_BYTE *a1)
{
_BYTE *v1; // rdx
int v2; // eax
int v3; // ecx
int v4; // edx
long long v5; // rax
unsigned int v6; // ecx
if ( !*a1 )
return 0LL;
v1 = a1 + 1;
v2 = 0;
do
{
++v1;
v3 = v2++;
}
while ( *(v1 - 1) );
v4 = v3 - 1;
if ( v2 <= 2 )
return 0LL;
v5 ... | func0:
ENDBR64
CMP byte ptr [RDI],0x0
JZ 0x00101250
LEA RDX,[RDI + 0x1]
XOR EAX,EAX
NOP
LAB_00101200:
ADD RDX,0x1
MOV ECX,EAX
ADD EAX,0x1
CMP byte ptr [RDX + -0x1],0x0
JNZ 0x00101200
LEA EDX,[RCX + -0x1]
CMP EAX,0x2
JLE 0x00101250
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00101228
LAB_00101220:
ADD RAX,0x1
CMP EDX,EAX
JLE 0x001012... | int func0(char *param_1)
{
char cVar1;
int iVar2;
long lVar3;
int iVar4;
char *pcVar5;
if (*param_1 != '\0') {
pcVar5 = param_1 + 1;
iVar2 = 0;
do {
iVar4 = iVar2;
iVar2 = iVar4 + 1;
cVar1 = *pcVar5;
pcVar5 = pcVar5 + 1;
} while (cVar1 != '\0');
iVar4 = iVar4 ... |
4,584 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(char* text) {
int i=0, j=0;
char temp[strlen(text) + 1];
while(text[i]) {
if(isalnum(text[i])) {
temp[j++] = text[i];
}
i++;
}
temp[j] = '\0';
strcpy(text, temp);
return text;
}
| int main() {
char text1[] = "python @#&^%$*program123";
char text2[] = "python %^$@!^&*() programming24%$^^() language";
char text3[] = "python ^%&^()(+_)(_^&67) program";
assert(strcmp(func0(text1), "pythonprogram123") == 0);
assert(strcmp(func0(text2), "pythonpro... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %rdi,-0x58(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rbx
movl $0x0,-0x4c(%rbp)
movl $0x0,-0x50(%rbp)
mov -0x58(%rbp),%rax
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov [rbp+var_30], 0
mov [rbp+var_2C], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
add rax, 1
mov r... | char * func0(char *a1)
{
size_t v1; // rax
unsigned long long v2; // rax
void *v3; // rsp
int v4; // eax
_BYTE v6[8]; // [rsp+8h] [rbp-40h] BYREF
char *s; // [rsp+10h] [rbp-38h]
int v8; // [rsp+18h] [rbp-30h]
int v9; // [rsp+1Ch] [rbp-2Ch]
size_t v10; // [rsp+20h] [rbp-28h]
char *src; // [rsp+28h] [... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV dword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x2c],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010b0
ADD RAX,0x... | char * func0(char *param_1)
{
long lVar1;
char *__dest;
char *__src;
ulong uVar2;
ushort **ppuVar3;
int *puVar4;
long in_FS_OFFSET;
int auStack_48 [8];
char *local_40;
int local_38;
int local_34;
size_t local_30;
char *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);... |
4,585 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(char* text) {
int i=0, j=0;
char temp[strlen(text) + 1];
while(text[i]) {
if(isalnum(text[i])) {
temp[j++] = text[i];
}
i++;
}
temp[j] = '\0';
strcpy(text, temp);
return text;
}
| int main() {
char text1[] = "python @#&^%$*program123";
char text2[] = "python %^$@!^&*() programming24%$^^() language";
char text3[] = "python ^%&^()(+_)(_^&67) program";
assert(strcmp(func0(text1), "pythonprogram123") == 0);
assert(strcmp(func0(text2), "pythonpro... | O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x18,%rsp
mov %rdi,%r12
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
not %rcx
add $0xf,%rcx
mov %rcx,%rdx
and $0xfffffffffffffff0,%rdx
and ... | func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call _strlen
add rax, 10h
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx,... | char * func0(char *a1)
{
long long v1; // rax
__int16 v2; // cx
signed long long v3; // rax
void *v4; // rsp
char v5; // bl
long long v6; // rsi
char *v7; // rax
int v8; // ecx
_BYTE v11[8]; // [rsp+8h] [rbp-30h] BYREF
unsigned long long v12; // [rsp+10h] [rbp-28h]
v12 = __readfsqword(0x28u);
v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001010b0
ADD RAX,0x10
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_00101228:
CMP RSP,RDX
JZ 0x0010123f
SUB RSP,0x1000
OR qword p... | char * func0(char *param_1)
{
ushort *puVar1;
long lVar2;
size_t sVar3;
ulong uVar4;
ushort **ppuVar5;
char *pcVar6;
int iVar7;
char cVar8;
int1 *puVar9;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
for (puVa... |
4,586 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(char* text) {
int i=0, j=0;
char temp[strlen(text) + 1];
while(text[i]) {
if(isalnum(text[i])) {
temp[j++] = text[i];
}
i++;
}
temp[j] = '\0';
strcpy(text, temp);
return text;
}
| int main() {
char text1[] = "python @#&^%$*program123";
char text2[] = "python %^$@!^&*() programming24%$^^() language";
char text3[] = "python ^%&^()(+_)(_^&67) program";
assert(strcmp(func0(text1), "pythonprogram123") == 0);
assert(strcmp(func0(text2), "pythonpro... | O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
mov %rdi,%r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
callq 10a0 <strlen@plt>
mov %rsp,%rdi
add $0x10,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffff... | func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
mov r12, rdi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call _strlen
mov rcx, rsp
add rax, 10h
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFF... | char * func0(char *a1)
{
long long v1; // rax
_BYTE *v2; // rcx
signed long long v3; // rdx
void *v4; // rsp
char v5; // bl
long long *v6; // rax
int v7; // ecx
long long v8; // rsi
char *v9; // rax
long long v10; // rdx
_BYTE v13[4088]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v14[6]; // [rsp+1008h... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001010b0
MOV RCX,RSP
ADD RAX,0x10
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001013d9
LAB_001013c4:
SUB RSP,0x1000
OR qword p... | char * func0(char *param_1)
{
ushort *puVar1;
long lVar2;
int1 *puVar3;
size_t sVar4;
ushort **ppuVar5;
char *pcVar6;
int iVar7;
ulong uVar8;
long lVar9;
char cVar10;
int1 *puVar11;
long in_FS_OFFSET;
int1 auStack_38 [8];
long local_30;
int1 *puVar12;
puVar11 = auStack_38;
local_30... |
4,587 | func0 |
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(char* text) {
int i=0, j=0;
char temp[strlen(text) + 1];
while(text[i]) {
if(isalnum(text[i])) {
temp[j++] = text[i];
}
i++;
}
temp[j] = '\0';
strcpy(text, temp);
return text;
}
| int main() {
char text1[] = "python @#&^%$*program123";
char text2[] = "python %^$@!^&*() programming24%$^^() language";
char text3[] = "python ^%&^()(+_)(_^&67) program";
assert(strcmp(func0(text1), "pythonprogram123") == 0);
assert(strcmp(func0(text2), "pythonpro... | O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
mov %rdi,%r12
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
callq 10a0 <strlen@plt>
mov %rsp,%rdi
add $0x10,%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rdi
and $0xfffffff... | func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
mov r12, rdi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call _strlen
mov rcx, rsp
add rax, 10h
mov rdx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rcx, rax
and rdx, 0FFFFFFFFFFFFF... | char * func0(char *dest)
{
size_t v1; // rax
char *v2; // rcx
signed long long v3; // rdx
void *v4; // rsp
char v5; // bl
const unsigned __int16 **v6; // rax
long long v7; // rdx
const unsigned __int16 *v8; // rsi
char *v9; // rax
char v12[4088]; // [rsp+8h] [rbp-1030h] BYREF
_QWORD v13[6]; // [rs... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001010b0
MOV RCX,RSP
ADD RAX,0x10
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RSP,RCX
JZ 0x001013b9
LAB_001013a4:
SUB RSP,0x1000
OR qword p... | char * func0(char *param_1)
{
ushort *puVar1;
long lVar2;
int *puVar3;
size_t sVar4;
ushort **ppuVar5;
char *pcVar6;
ulong uVar7;
long lVar8;
char cVar9;
int *puVar10;
long in_FS_OFFSET;
int auStack_38 [8];
long local_30;
int *puVar11;
puVar10 = auStack_38;
local_30 = *(long *)(in_FS... |
4,588 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct Node {
int value;
struct Node *next;
} Node;
typedef struct {
char *key;
Node *values;
} KeyValue;
typedef struct {
KeyValue *pairs;
int size;
int capacity;
} HashMap;
voi... | HashMap func0(char l[][2][10], int len) {
HashMap result;
initHashMap(&result);
for (int i = 0; i < len; i++) {
insertHashMap(&result, l[i][0], atoi(l[i][1]));
}
return result;
}
| int main() {
char test1[][2][10] = {{"yellow", "1"}, {"blue", "2"}, {"yellow", "3"}, {"blue", "4"}, {"red", "1"}};
HashMap result1 = func0(test1, 5);
char test2[][2][10] = {{"python", "1"}, {"python", "2"}, {"python", "3"}, {"python", "4"}, {"python", "5"}};
HashMap result2 = func0(test2, 5)... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x20(%rbp),%rax
mov %rax,%rdi
callq 12ad <initHashMap>
movl $0x0,-0x24(%rbp)
jmp 14e2 <func0+0x96>
mov -0x24(%rbp),%eax
movslq %e... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+var_20]
mov rdi, rax
call initHashMap
mov [rbp+var_24], 0
jmp short loc_14E1
loc_1482:
mov eax, [rbp+var_24]... | long long func0(long long a1, int a2)
{
unsigned int v2; // eax
int i; // [rsp+1Ch] [rbp-24h]
_QWORD v5[4]; // [rsp+20h] [rbp-20h] BYREF
v5[3] = __readfsqword(0x28u);
initHashMap(v5);
for ( i = 0; i < a2; ++i )
{
v2 = atoi((const char *)(20LL * i + a1 + 10));
insertHashMap(v5, 20LL * i + a1, v2)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x20]
MOV RDI,RAX
CALL 0x001012ad
MOV dword ptr [RBP + -0x24],0x0
JMP 0x001014e1
LAB_00101482:
MOV EAX,dword ptr [RBP + ... | int8 func0(long param_1,int param_2)
{
int iVar1;
long in_FS_OFFSET;
int local_2c;
int8 local_28 [3];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
initHashMap(local_28);
for (local_2c = 0; local_2c < param_2; local_2c = local_2c + 1) {
iVar1 = atoi((char *)(param_1 + (long)local_2c ... |
4,589 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct Node {
int value;
struct Node *next;
} Node;
typedef struct {
char *key;
Node *values;
} KeyValue;
typedef struct {
KeyValue *pairs;
int size;
int capacity;
} HashMap;
voi... | HashMap func0(char l[][2][10], int len) {
HashMap result;
initHashMap(&result);
for (int i = 0; i < len; i++) {
insertHashMap(&result, l[i][0], atoi(l[i][1]));
}
return result;
}
| int main() {
char test1[][2][10] = {{"yellow", "1"}, {"blue", "2"}, {"yellow", "3"}, {"blue", "4"}, {"red", "1"}};
HashMap result1 = func0(test1, 5);
char test2[][2][10] = {{"python", "1"}, {"python", "2"}, {"python", "3"}, {"python", "4"}, {"python", "5"}};
HashMap result2 = func0(test2, 5)... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %rdi,%r12
mov %esi,%ebp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %rsp,%rdi
callq 1270 <initHashMap>
test %ebp,%ebp
jle 13dc <func0+0x6b>
lea 0xa(%r12),%rbx
lea -0x1(%rbp),%eax
lea (%rax,%rax,4),%rax
... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 20h
mov r12, rdi
mov ebp, esi
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
mov rdi, rsp
call initHashMap
test ebp, ebp
jle short loc_13DB
lea rbx, [r12+0Ah]
lea eax, [rbp-1]
lea rax, [rax+rax*4]
lea ... | long long func0(long long a1, int a2)
{
long long v2; // rbx
unsigned int v3; // eax
_QWORD v5[7]; // [rsp+0h] [rbp-38h] BYREF
v5[3] = __readfsqword(0x28u);
initHashMap(v5);
if ( a2 > 0 )
{
v2 = a1 + 10;
do
{
v3 = strtol(v2, 0LL, 10LL);
insertHashMap(v5, v2 - 10, v3);
v2 +=... | ||
4,590 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct Node {
int value;
struct Node *next;
} Node;
typedef struct {
char *key;
Node *values;
} KeyValue;
typedef struct {
KeyValue *pairs;
int size;
int capacity;
} HashMap;
voi... | HashMap func0(char l[][2][10], int len) {
HashMap result;
initHashMap(&result);
for (int i = 0; i < len; i++) {
insertHashMap(&result, l[i][0], atoi(l[i][1]));
}
return result;
}
| int main() {
char test1[][2][10] = {{"yellow", "1"}, {"blue", "2"}, {"yellow", "3"}, {"blue", "4"}, {"red", "1"}};
HashMap result1 = func0(test1, 5);
char test2[][2][10] = {{"python", "1"}, {"python", "2"}, {"python", "3"}, {"python", "4"}, {"python", "5"}};
HashMap result2 = func0(test2, 5)... | O2 | c | func0:
endbr64
push %r12
mov %rdi,%r12
mov $0xa0,%edi
push %rbp
mov %esi,%ebp
push %rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movabs $0xa00000000,%rax
mov %rax,0x8(%rsp)
callq 1110 <malloc@plt>
mov %rax,(%rsp)
test %ebp,%ebp
jle 17f7 <func0+0x87>
lea ... | func0:
endbr64
push r12
mov r12, rdi
mov edi, 0A0h
push rbp
mov ebp, esi
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+38h+var_20], rax
mov rax, 0A00000000h
mov [rsp+38h+var_30], rax
call _malloc
mov [rsp+38h+var_38], rax
test ebp, ebp
jle short loc_174E
lea e... | long long func0(long long a1, int a2)
{
long long v3; // rbx
unsigned int v4; // eax
long long v5; // rsi
_QWORD v7[7]; // [rsp+0h] [rbp-38h] BYREF
v7[3] = __readfsqword(0x28u);
v7[1] = 0xA00000000LL;
v7[0] = malloc(160LL);
if ( a2 > 0 )
{
v3 = a1 + 10;
do
{
v4 = strtol(v3, 0LL, 10... | func0:
ENDBR64
PUSH R12
MOV R12,RDI
MOV EDI,0xa0
PUSH RBP
MOV EBP,ESI
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,0xa00000000
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00101110
MOV qword ptr [RSP],RAX
TEST EBP,EBP
JLE 0x0010174e
LEA EAX,[RBP + -0x1]
LEA RBX,[R12 + 0xa]
MOV RBP,RS... | void * func0(long param_1,int param_2)
{
char *pcVar1;
ulong uVar2;
char *__nptr;
long in_FS_OFFSET;
void *local_38;
int8 local_30;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = 0xa00000000;
local_38 = malloc(0xa0);
if (0 < param_2) {
__nptr = (char *)(param_1 + 10);... |
4,591 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct Node {
int value;
struct Node *next;
} Node;
typedef struct {
char *key;
Node *values;
} KeyValue;
typedef struct {
KeyValue *pairs;
int size;
int capacity;
} HashMap;
voi... | HashMap func0(char l[][2][10], int len) {
HashMap result;
initHashMap(&result);
for (int i = 0; i < len; i++) {
insertHashMap(&result, l[i][0], atoi(l[i][1]));
}
return result;
}
| int main() {
char test1[][2][10] = {{"yellow", "1"}, {"blue", "2"}, {"yellow", "3"}, {"blue", "4"}, {"red", "1"}};
HashMap result1 = func0(test1, 5);
char test2[][2][10] = {{"python", "1"}, {"python", "2"}, {"python", "3"}, {"python", "4"}, {"python", "5"}};
HashMap result2 = func0(test2, 5)... | O3 | c | func0:
endbr64
push %r12
mov %rdi,%r12
mov $0xa0,%edi
push %rbp
mov %esi,%ebp
push %rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movabs $0xa00000000,%rax
mov %rax,0x8(%rsp)
callq 1110 <malloc@plt>
mov %rax,(%rsp)
test %ebp,%ebp
jle 1877 <func0+0x87>
lea ... | func0:
endbr64
push r12
push rbp
movsxd rbp, esi
push rbx
mov rbx, rdi
mov edi, 0A0h; size
sub rsp, 20h
mov rax, fs:28h
mov [rsp+38h+var_20], rax
mov rax, 0A00000000h
mov [rsp+38h+var_30], rax
call _malloc
mov [rsp+38h+var_38], rax
test ebp, ebp
jle short loc_170E
lea... | long long func0(long long a1, int a2)
{
const char *v2; // rbx
long long v3; // r12
unsigned int v4; // eax
const char *v5; // rsi
_QWORD v7[7]; // [rsp+0h] [rbp-38h] BYREF
v7[3] = __readfsqword(0x28u);
v7[1] = 0xA00000000LL;
v7[0] = malloc(0xA0uLL);
if ( a2 > 0 )
{
v2 = (const char *)(a1 + 10... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV RBX,RDI
MOV EDI,0xa0
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,0xa00000000
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00101110
MOV qword ptr [RSP],RAX
TEST EBP,EBP
JLE 0x0010170e
LEA RAX,[RBP + RBP*0x4]
ADD RBX,0xa
MOV RBP,RSP
... | void * func0(long param_1,int param_2)
{
char *pcVar1;
char *pcVar2;
ulong uVar3;
char *__nptr;
long in_FS_OFFSET;
void *local_38;
int8 local_30;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = 0xa00000000;
local_38 = malloc(0xa0);
if (0 < param_2) {
__nptr = (char *... |
4,592 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(char* str1) {
char stack[100]; // Assuming maximum length of input string is 100
int top = -1;
for (int i = 0; i < strlen(str1); i++) {
char parenthese = str1[i];
if (parenthese == '(' || parenthese == '{' || parenthese == '[') {
stack[++top] = parenthese;
... | int main() {
assert(func0("(){}[]") == true);
assert(func0("()[{)}") == false);
assert(func0("()") == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x98,%rsp
mov %rdi,-0x98(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0xffffffff,-0x88(%rbp)
movl $0x0,-0x84(%rbp)
jmpq 128e <func0+0x105>
mov -0x84(%rbp),%eax
movslq %eax,%rdx
mov -0x98(%rbp),%rax
add %rdx,%r... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_88], 0FFFFFFFFh
mov [rbp+var_84], 0
jmp loc_128E
loc_11C8:
mov eax, [rbp+var_84]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rd... | bool func0(const char *a1)
{
int v2; // eax
char v3; // [rsp+16h] [rbp-8Ah]
char v4; // [rsp+17h] [rbp-89h]
int v5; // [rsp+18h] [rbp-88h]
int i; // [rsp+1Ch] [rbp-84h]
_BYTE v7[104]; // [rsp+20h] [rbp-80h]
unsigned long long v8; // [rsp+88h] [rbp-18h]
v8 = __readfsqword(0x28u);
v5 = -1;
for ( i =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0x98],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x88],0xffffffff
MOV dword ptr [RBP + -0x84],0x0
JMP 0x0010128e
LAB_001011c8:
MOV EAX,dword ptr [RBP + -0x84]
MOVSXD RDX,EAX
MOV RAX,qwo... | bool func0(char *param_1)
{
int iVar1;
char cVar2;
char cVar3;
size_t sVar4;
long in_FS_OFFSET;
bool bVar5;
int local_90;
int local_8c;
char acStack_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_90 = -1;
local_8c = 0;
do {
sVar4 = strlen(param_1);
if (... |
4,593 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(char* str1) {
char stack[100]; // Assuming maximum length of input string is 100
int top = -1;
for (int i = 0; i < strlen(str1); i++) {
char parenthese = str1[i];
if (parenthese == '(' || parenthese == '{' || parenthese == '[') {
stack[++top] = parenthese;
... | int main() {
assert(func0("(){}[]") == true);
assert(func0("()[{)}") == false);
assert(func0("()") == true);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
sub $0x70,%rsp
mov %rdi,%r9
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov $0x0,%esi
mov $0xffffffff,%r8d
mov $0xffffffffffffffff,%r10
jmp 11e8 <func0+0x7f>
cmp $0xffffffff,%r8d
je 122b <func0+0xc2>
lea -0x1(%r8),%ebx
movslq %r8d,%r8
movzbl (%rsp,... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 70h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+88h+var_20], rax
xor eax, eax
mov ebx, 0
mov r12d, 0FFFFFFFFh
jmp short loc_1200
loc_11B5:
cmp r12d, 0FFFFFFFFh
jz short loc_1239
lea r8d, [r12-1]
movsxd r12, r12d
movzx ... | bool func0(long long a1)
{
unsigned long long v1; // rbx
int v2; // r12d
char v3; // si
bool result; // al
char v5; // dl
_BYTE v6[104]; // [rsp+0h] [rbp-88h]
unsigned long long v7; // [rsp+68h] [rbp-20h]
v7 = __readfsqword(0x28u);
v1 = 0LL;
v2 = -1;
while ( 1 )
{
if ( strlen(a1) <= v1 )
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV EBX,0x0
MOV R12D,0xffffffff
JMP 0x00101200
LAB_001011b5:
CMP R12D,-0x1
JZ 0x00101239
LEA R8D,[R12 + -0x1]
MOVSXD R12,R12D
MOVZX ESI,byte ptr [RSP + R12*0x1]
CMP DL,0x29
SETZ CL
C... | bool func0(char *param_1)
{
byte bVar1;
byte bVar2;
bool bVar3;
bool bVar4;
size_t sVar5;
ulong uVar6;
int iVar7;
int iVar8;
long in_FS_OFFSET;
bool bVar9;
byte local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar8 = -1;
for (uVar6 = 0; sVar5 = strlen(param_1)... |
4,594 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(char* str1) {
char stack[100]; // Assuming maximum length of input string is 100
int top = -1;
for (int i = 0; i < strlen(str1); i++) {
char parenthese = str1[i];
if (parenthese == '(' || parenthese == '{' || parenthese == '[') {
stack[++top] = parenthese;
... | int main() {
assert(func0("(){}[]") == true);
assert(func0("()[{)}") == false);
assert(func0("()") == true);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
sub $0x70,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
callq 1070 <strlen@plt>
xor %ecx,%ecx
mov $0xffffffff,%esi
mov %rax,%rdi
jmp 126e <func0+0x3e>
nopl (%rax)
add $0x1,%esi
movslq %esi,%r8
mov %dl,(%rsp,%r8,1)
add $0x1,%rcx
c... | func0:
endbr64
push r12
mov r12, rdi
push rbp
mov ebp, 0FFFFFFFFh
push rbx
xor ebx, ebx
sub rsp, 70h
mov rax, fs:28h
mov [rsp+88h+var_20], rax
xor eax, eax
jmp short loc_126D
loc_1260:
add ebp, 1
movsxd rax, ebp
mov [rsp+rax+88h+var_88], dl
loc_1269:
add rbx, 1
loc_... | bool func0(long long a1)
{
int v1; // ebp
unsigned long long v2; // rbx
char v3; // dl
bool result; // al
char v5; // cl
_BYTE v6[104]; // [rsp+0h] [rbp-88h]
unsigned long long v7; // [rsp+68h] [rbp-20h]
v1 = -1;
v2 = 0LL;
v7 = __readfsqword(0x28u);
while ( 1 )
{
if ( v2 >= strlen(a1) )
... | func0:
ENDBR64
PUSH R12
MOV R12,RDI
PUSH RBP
MOV EBP,0xffffffff
PUSH RBX
XOR EBX,EBX
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
JMP 0x0010126d
LAB_00101260:
ADD EBP,0x1
MOVSXD RAX,EBP
MOV byte ptr [RSP + RAX*0x1],DL
LAB_00101269:
ADD RBX,0x1
LAB_0010126d:
MOV RDI,R12
CALL 0x0010... | bool func0(char *param_1)
{
byte bVar1;
byte bVar2;
bool bVar3;
size_t sVar4;
ulong uVar5;
int iVar6;
int iVar7;
long in_FS_OFFSET;
byte local_88 [104];
long local_20;
uVar5 = 0;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar7 = -1;
do {
sVar4 = strlen(param_1);
if (sVar4 <= uVa... |
4,595 | func0 | #include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(char* str1) {
char stack[100]; // Assuming maximum length of input string is 100
int top = -1;
for (int i = 0; i < strlen(str1); i++) {
char parenthese = str1[i];
if (parenthese == '(' || parenthese == '{' || parenthese == '[') {
stack[++top] = parenthese;
... | int main() {
assert(func0("(){}[]") == true);
assert(func0("()[{)}") == false);
assert(func0("()") == true);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
sub $0x70,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
callq 1070 <strlen@plt>
xor %ecx,%ecx
mov $0xffffffff,%esi
mov %rax,%rdi
jmp 126e <func0+0x3e>
nopl (%rax)
add $0x1,%esi
movslq %esi,%r8
mov %dl,(%rsp,%r8,1)
add $0x1,%rcx
c... | func0:
endbr64
push r12
mov r12d, 0FFFFFFFFh
push rbp
mov rbp, rdi
push rbx
xor ebx, ebx
sub rsp, 70h
mov rax, fs:28h
mov [rsp+88h+var_20], rax
xor eax, eax
jmp short loc_126E
loc_1260:
add r12d, 1
movsxd rax, r12d
mov [rsp+rax+88h+var_88], dl
loc_126A:
add rbx, 1
l... | bool func0(char *s)
{
int v1; // r12d
size_t v2; // rbx
char v3; // dl
bool result; // al
char v5; // cl
_BYTE v6[104]; // [rsp+0h] [rbp-88h]
unsigned long long v7; // [rsp+68h] [rbp-20h]
v1 = -1;
v2 = 0LL;
v7 = __readfsqword(0x28u);
while ( 1 )
{
if ( v2 >= strlen(s) )
return v1 == ... | func0:
ENDBR64
PUSH R12
MOV R12D,0xffffffff
PUSH RBP
MOV RBP,RDI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
JMP 0x0010126e
LAB_00101260:
ADD R12D,0x1
MOVSXD RAX,R12D
MOV byte ptr [RSP + RAX*0x1],DL
LAB_0010126a:
ADD RBX,0x1
LAB_0010126e:
MOV RDI,RBP
CALL 0x0... | bool func0(char *param_1)
{
byte bVar1;
byte bVar2;
bool bVar3;
size_t sVar4;
ulong uVar5;
int iVar6;
int iVar7;
long in_FS_OFFSET;
byte local_88 [104];
long local_20;
uVar5 = 0;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar7 = -1;
do {
sVar4 = strlen(param_1);
if (sVar4 <= uVa... |
4,596 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
int perimeter = a + b + c;
return perimeter;
}
| int main() {
assert(func0(10, 20, 30) == 60);
assert(func0(3, 4, 5) == 12);
assert(func0(25, 35, 45) == 105);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x14(%rbp),%edx
mov -0x18(%rbp),%eax
add %eax,%edx
mov -0x1c(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov edx, [rbp+var_14]
mov eax, [rbp+var_18]
add edx, eax
mov eax, [rbp+var_1C]
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a2 + a1 + a3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,dword ptr [RBP + -0x18]
ADD EDX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RB... | int func0(int param_1,int param_2,int param_3)
{
return param_3 + param_1 + param_2;
} |
4,597 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
int perimeter = a + b + c;
return perimeter;
}
| int main() {
assert(func0(10, 20, 30) == 60);
assert(func0(3, 4, 5) == 12);
assert(func0(25, 35, 45) == 105);
return 0;
}
| O1 | c | func0:
endbr64
add %esi,%edi
lea (%rdi,%rdx,1),%eax
retq
| func0:
endbr64
add edi, esi
lea eax, [rdi+rdx]
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a2 + a1 + a3);
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDX*0x1]
RET | int func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3;
} |
4,598 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
int perimeter = a + b + c;
return perimeter;
}
| int main() {
assert(func0(10, 20, 30) == 60);
assert(func0(3, 4, 5) == 12);
assert(func0(25, 35, 45) == 105);
return 0;
}
| O2 | c | func0:
endbr64
add %esi,%edi
lea (%rdi,%rdx,1),%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
add edi, esi
lea eax, [rdi+rdx]
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a2 + a1 + a3);
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDX*0x1]
RET | int func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3;
} |
4,599 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
int perimeter = a + b + c;
return perimeter;
}
| int main() {
assert(func0(10, 20, 30) == 60);
assert(func0(3, 4, 5) == 12);
assert(func0(25, 35, 45) == 105);
return 0;
}
| O3 | c | func0:
endbr64
add %esi,%edi
lea (%rdi,%rdx,1),%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
add edi, esi
lea eax, [rdi+rdx]
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a2 + a1 + a3);
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDX*0x1]
RET | int func0(int param_1,int param_2,int param_3)
{
return param_1 + param_2 + param_3;
} |
4,600 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(int L, int R) {
static int result[2];
if (2 * L <= R) {
result[0] = L;
result[1] = 2 * L;
return result;
} else {
return NULL;
}
}
| int main() {
int* res;
res = func0(3, 8);
assert(res[0] == 3 && res[1] == 6);
res = func0(2, 6);
assert(res[0] == 2 && res[1] == 4);
res = func0(1, 3);
assert(res[0] == 1 && res[1] == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
add %eax,%eax
cmp %eax,-0x8(%rbp)
jl 117e <func0+0x35>
mov -0x4(%rbp),%eax
mov %eax,0x2eae(%rip)
mov -0x4(%rbp),%eax
add %eax,%eax
mov %eax,0x2ea7(%rip)
lea 0x2e9c(%rip),%rax
jmp ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
add eax, eax
cmp [rbp+var_8], eax
jl short loc_117E
mov eax, [rbp+var_4]
mov cs:result_1, eax
mov eax, [rbp+var_4]
add eax, eax
mov cs:dword_401C, eax
lea rax, resu... | int * func0(int a1, int a2)
{
if ( a2 < 2 * a1 )
return 0LL;
result_1 = a1;
dword_401C = 2 * a1;
return &result_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
CMP dword ptr [RBP + -0x8],EAX
JL 0x0010117e
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [0x00104018],EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
MOV dword ptr [0x0010401c],EA... | int8 * func0(int param_1,int param_2)
{
int8 *puVar1;
if (param_2 < param_1 * 2) {
puVar1 = (int8 *)0x0;
}
else {
result_1._4_4_ = param_1 * 2;
puVar1 = &result_1;
result_1._0_4_ = param_1;
}
return puVar1;
} |
4,601 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(int L, int R) {
static int result[2];
if (2 * L <= R) {
result[0] = L;
result[1] = 2 * L;
return result;
} else {
return NULL;
}
}
| int main() {
int* res;
res = func0(3, 8);
assert(res[0] == 3 && res[1] == 6);
res = func0(2, 6);
assert(res[0] == 2 && res[1] == 4);
res = func0(1, 3);
assert(res[0] == 1 && res[1] == 2);
return 0;
}
| O1 | c | func0:
endbr64
lea (%rdi,%rdi,1),%edx
mov $0x0,%eax
cmp %esi,%edx
jg 114c <func0+0x23>
mov %edi,0x2ed9(%rip)
mov %edx,0x2ed7(%rip)
lea 0x2ecc(%rip),%rax
retq
| func0:
endbr64
lea edx, [rdi+rdi]
mov eax, 0
cmp edx, esi
jg short locret_114C
mov cs:result_1, edi
mov cs:dword_401C, edx
lea rax, result_1
locret_114C:
retn | int * func0(int a1, int a2)
{
int *result; // rax
result = 0LL;
if ( 2 * a1 <= a2 )
{
result_1 = a1;
dword_401C = 2 * a1;
return &result_1;
}
return result;
} | func0:
ENDBR64
LEA EDX,[RDI + RDI*0x1]
MOV EAX,0x0
CMP EDX,ESI
JG 0x0010114c
MOV dword ptr [0x00104018],EDI
MOV dword ptr [0x0010401c],EDX
LEA RAX,[0x104018]
LAB_0010114c:
RET | int8 * func0(int param_1,int param_2)
{
int8 *puVar1;
puVar1 = (int8 *)0x0;
if (param_1 * 2 <= param_2) {
puVar1 = &result_1;
result_1._0_4_ = param_1;
result_1._4_4_ = param_1 * 2;
}
return puVar1;
} |
4,602 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(int L, int R) {
static int result[2];
if (2 * L <= R) {
result[0] = L;
result[1] = 2 * L;
return result;
} else {
return NULL;
}
}
| int main() {
int* res;
res = func0(3, 8);
assert(res[0] == 3 && res[1] == 6);
res = func0(2, 6);
assert(res[0] == 2 && res[1] == 4);
res = func0(1, 3);
assert(res[0] == 1 && res[1] == 2);
return 0;
}
| O2 | c | func0:
endbr64
lea (%rdi,%rdi,1),%edx
xor %eax,%eax
cmp %esi,%edx
jg 1170 <func0+0x20>
mov %edi,0x2eb5(%rip)
lea 0x2eae(%rip),%rax
mov %edx,0x2eac(%rip)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea edx, [rdi+rdi]
xor eax, eax
cmp edx, esi
jg short locret_1170
mov dword ptr cs:result_1, edi
lea rax, result_1
mov dword ptr cs:result_1+4, edx
locret_1170:
retn | long long * func0(int a1, int a2)
{
long long *result; // rax
result = 0LL;
if ( 2 * a1 <= a2 )
{
LODWORD(result_1) = a1;
result = &result_1;
HIDWORD(result_1) = 2 * a1;
}
return result;
} | func0:
ENDBR64
LEA EDX,[RDI + RDI*0x1]
XOR EAX,EAX
CMP EDX,ESI
JG 0x00101170
MOV dword ptr [0x00104018],EDI
LEA RAX,[0x104018]
MOV dword ptr [0x0010401c],EDX
LAB_00101170:
RET | int8 * func0(int param_1,int param_2)
{
int8 *puVar1;
puVar1 = (int8 *)0x0;
if (param_1 * 2 <= param_2) {
puVar1 = &result_1;
result_1._0_4_ = param_1;
result_1._4_4_ = param_1 * 2;
}
return puVar1;
} |
4,603 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(int L, int R) {
static int result[2];
if (2 * L <= R) {
result[0] = L;
result[1] = 2 * L;
return result;
} else {
return NULL;
}
}
| int main() {
int* res;
res = func0(3, 8);
assert(res[0] == 3 && res[1] == 6);
res = func0(2, 6);
assert(res[0] == 2 && res[1] == 4);
res = func0(1, 3);
assert(res[0] == 1 && res[1] == 2);
return 0;
}
| O3 | c | func0:
endbr64
lea (%rdi,%rdi,1),%edx
xor %eax,%eax
cmp %esi,%edx
jg 1170 <func0+0x20>
mov %edi,0x2eb5(%rip)
lea 0x2eae(%rip),%rax
mov %edx,0x2eac(%rip)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea edx, [rdi+rdi]
xor eax, eax
cmp edx, esi
jg short locret_1170
mov dword ptr cs:result_1, edi
lea rax, result_1
mov dword ptr cs:result_1+4, edx
locret_1170:
retn | long long * func0(int a1, int a2)
{
long long *result; // rax
result = 0LL;
if ( 2 * a1 <= a2 )
{
LODWORD(result_1) = a1;
result = &result_1;
HIDWORD(result_1) = 2 * a1;
}
return result;
} | func0:
ENDBR64
LEA EDX,[RDI + RDI*0x1]
XOR EAX,EAX
CMP EDX,ESI
JG 0x00101170
MOV dword ptr [0x00104018],EDI
LEA RAX,[0x104018]
MOV dword ptr [0x0010401c],EDX
LAB_00101170:
RET | int8 * func0(int param_1,int param_2)
{
int8 *puVar1;
puVar1 = (int8 *)0x0;
if (param_1 * 2 <= param_2) {
puVar1 = &result_1;
result_1._0_4_ = param_1;
result_1._4_4_ = param_1 * 2;
}
return puVar1;
} |
4,604 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(char* patterns[], int pattern_n, char* text) {
regex_t regex;
int reti;
for (int i = 0; i < pattern_n; i++) {
reti = regcomp(®ex, patterns[i], 0);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Not Matched!";
}
... | int main() {
char* patterns1[1] = {"language"};
assert(func0(patterns1, 1, "python language") == "Matched!");
char* patterns2[1] = {"program"};
assert(func0(patterns2, 1, "python language") == "Not Matched!");
char* patterns3[1] = {"python"};
assert(func0(patterns3, 1, "programming lan... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
add $0xffffffffffffff80,%rsp
mov %rdi,-0x68(%rbp)
mov %esi,-0x6c(%rbp)
mov %rdx,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x58(%rbp)
jmpq 12c6 <func0+0xdd>
mov -0x58(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -... | func0:
endbr64
push rbp
mov rbp, rsp
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+var_68], rdi
mov [rbp+var_6C], esi
mov [rbp+string], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_58], 0
jmp loc_12C9
loc_121B:
mov eax, [rbp+var_58]
cdqe
lea rdx, ds:0[rax*... | const char * func0(long long a1, int a2, const char *a3)
{
int i; // [rsp+28h] [rbp-58h]
regex_t preg; // [rsp+30h] [rbp-50h] BYREF
unsigned long long v7; // [rsp+78h] [rbp-8h]
v7 = __readfsqword(0x28u);
for ( i = 0; i < a2; ++i )
{
if ( regcomp(&preg, *(const char **)(8LL * i + a1), 0) )
{
f... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
ADD RSP,-0x80
MOV qword ptr [RBP + -0x68],RDI
MOV dword ptr [RBP + -0x6c],ESI
MOV qword ptr [RBP + -0x78],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x58],0x0
JMP 0x001012c9
LAB_0010121b:
MOV EAX,dword ptr [RBP + -0x58]
CDQE
LEA R... | char * func0(long param_1,int param_2,char *param_3)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
int local_60;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = 0;
do {
if (param_2 <= local_60) {
pcVar2 = "Not Matched!";
LAB_001012dc:
if (loca... |
4,605 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(char* patterns[], int pattern_n, char* text) {
regex_t regex;
int reti;
for (int i = 0; i < pattern_n; i++) {
reti = regcomp(®ex, patterns[i], 0);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Not Matched!";
}
... | int main() {
char* patterns1[1] = {"language"};
assert(func0(patterns1, 1, "python language") == "Matched!");
char* patterns2[1] = {"program"};
assert(func0(patterns2, 1, "python language") == "Not Matched!");
char* patterns3[1] = {"python"};
assert(func0(patterns3, 1, "programming lan... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0xdf6(%rip),%rax
test %esi,%esi
jle 1298 <func0+0xaf>
mov %rdx,%r12
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r13
mov %rsp,%rbp
mov $0... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+78h+var_30], rax
xor eax, eax
lea rax, aNotMatched; "Not Matched!"
test esi, esi
jle loc_1298
mov r12, rdx
mov rbx, rdi
lea eax, [rsi-1]
lea r13, [rdi+rax*8+8]
mov rbp, rsp... | char * func0(_QWORD *a1, int a2, long long a3)
{
char *result; // rax
_QWORD *v5; // rbx
_QWORD v6[15]; // [rsp+0h] [rbp-78h] BYREF
v6[9] = __readfsqword(0x28u);
result = "Not Matched!";
if ( a2 > 0 )
{
v5 = a1;
while ( 1 )
{
if ( (unsigned int)regcomp(v6, *v5, 0LL) )
{
fw... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[0x102004]
TEST ESI,ESI
JLE 0x00101298
MOV R12,RDX
MOV RBX,RDI
LEA EAX,[RSI + -0x1]
LEA R13,[RDI + RAX*0x8 + 0x8]
MOV RBP,RSP
LAB_00101227:
MOV EDX,0x0
MOV RSI,qword ptr [RBX]
M... | char * func0(int8 *param_1,int param_2,char *param_3)
{
int8 *puVar1;
int iVar2;
char *pcVar3;
long in_FS_OFFSET;
regex_t rStack_78;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pcVar3 = "Not Matched!";
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
... |
4,606 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(char* patterns[], int pattern_n, char* text) {
regex_t regex;
int reti;
for (int i = 0; i < pattern_n; i++) {
reti = regcomp(®ex, patterns[i], 0);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Not Matched!";
}
... | int main() {
char* patterns1[1] = {"language"};
assert(func0(patterns1, 1, "python language") == "Matched!");
char* patterns2[1] = {"program"};
assert(func0(patterns2, 1, "python language") == "Not Matched!");
char* patterns3[1] = {"python"};
assert(func0(patterns3, 1, "programming lan... | O2 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
test %esi,%esi
jle 13d0 <func0+0xc0>
lea -0x1(%rsi),%eax
mov %rdx,%r12
mov %rdi,%rbx
mov %rsp,%rbp
lea 0x8(%rdi,%rax,8),%r13
jmp 1377 <func0+0x67>
nopl 0... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+78h+var_30], rax
xor eax, eax
test esi, esi
jle loc_13D0
lea eax, [rsi-1]
mov r12, rdx
mov rbx, rdi
mov rbp, rsp
lea r13, [rdi+rax*8+8]
jmp short loc_1377
loc_1350:
mov ... | char * func0(_QWORD *a1, int a2, long long a3)
{
_QWORD *v4; // rbx
_QWORD v6[15]; // [rsp+0h] [rbp-78h] BYREF
v6[9] = __readfsqword(0x28u);
if ( a2 <= 0 )
return "Not Matched!";
v4 = a1;
while ( 1 )
{
if ( (unsigned int)regcomp(v6, *v4, 0LL) )
{
fwrite("Could not compile regex\n", 1LL,... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x001013d0
LEA EAX,[RSI + -0x1]
MOV R12,RDX
MOV RBX,RDI
MOV RBP,RSP
LEA R13,[RDI + RAX*0x8 + 0x8]
JMP 0x00101377
LAB_00101350:
MOV RDI,RBP
XOR R8D,R8D
XOR ECX,ECX
XOR E... | char * func0(int8 *param_1,int param_2,char *param_3)
{
int8 *puVar1;
int iVar2;
char *pcVar3;
long in_FS_OFFSET;
regex_t rStack_78;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
iVar2 = regcomp(&rStack_78... |
4,607 | func0 |
#include <stdio.h>
#include <assert.h>
#include <regex.h>
| char* func0(char* patterns[], int pattern_n, char* text) {
regex_t regex;
int reti;
for (int i = 0; i < pattern_n; i++) {
reti = regcomp(®ex, patterns[i], 0);
if (reti) {
fprintf(stderr, "Could not compile regex\n");
return "Not Matched!";
}
... | int main() {
char* patterns1[1] = {"language"};
assert(func0(patterns1, 1, "python language") == "Matched!");
char* patterns2[1] = {"program"};
assert(func0(patterns2, 1, "python language") == "Not Matched!");
char* patterns3[1] = {"python"};
assert(func0(patterns3, 1, "programming lan... | O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
test %esi,%esi
jle 13d0 <func0+0xc0>
lea -0x1(%rsi),%eax
mov %rdx,%r12
mov %rdi,%rbx
mov %rsp,%rbp
lea 0x8(%rdi,%rax,8),%r13
jmp 1377 <func0+0x67>
nopl 0... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+78h+var_30], rax
xor eax, eax
test esi, esi
jle short loc_139D
movsxd rsi, esi
mov r12, rdx
mov rbx, rdi
mov rbp, rsp
lea r13, [rdi+rsi*8]
jmp short loc_136F
loc_1348:
mov ... | char * func0(const char **a1, int a2, const char *a3)
{
const char **v4; // rbx
regex_t v6; // [rsp+0h] [rbp-78h] BYREF
unsigned long long v7; // [rsp+48h] [rbp-30h]
v7 = __readfsqword(0x28u);
if ( a2 <= 0 )
return "Not Matched!";
v4 = a1;
while ( 1 )
{
if ( regcomp(&v6, *v4, 0) )
{
f... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x0010139d
MOVSXD RSI,ESI
MOV R12,RDX
MOV RBX,RDI
MOV RBP,RSP
LEA R13,[RDI + RSI*0x8]
JMP 0x0010136f
LAB_00101348:
MOV RDI,RBP
XOR R8D,R8D
XOR ECX,ECX
XOR EDX,EDX
MOV R... | char * func0(int8 *param_1,int param_2,char *param_3)
{
int8 *puVar1;
int iVar2;
char *pcVar3;
long in_FS_OFFSET;
regex_t rStack_78;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (0 < param_2) {
puVar1 = param_1 + param_2;
do {
iVar2 = regcomp(&rStack_78,(char *)*param_1... |
4,608 | func0 | #include <assert.h>
#include <stdbool.h>
#include <stdio.h>
| bool func0(int x) {
int terms[100], temp = x, n = 0;
while (temp > 0) {
terms[n++] = temp % 10;
temp /= 10;
}
for (int left = 0, right = n - 1; left < right; left++, right--) {
int temp = terms[left];
terms[left] = terms[right];
terms[right] = temp;
... | int main() {
assert(func0(14) == true);
assert(func0(12) == false);
assert(func0(197) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1d0,%rsp
mov %edi,-0x1c4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x1c4(%rbp),%eax
mov %eax,-0x1c0(%rbp)
movl $0x0,-0x1bc(%rbp)
jmp 120f <func0+0xa6>
mov -0x1bc(%rbp),%esi
lea 0x1(%rsi),%eax
mov %eax,-0x1bc(%rbp)... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1D0h
mov [rbp+var_1C4], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_1C4]
mov [rbp+var_1C0], eax
mov [rbp+var_1BC], 0
jmp short loc_120F
loc_11A5:
mov esi, [rbp+var_1BC]
lea eax, [rsi+1]
mov [... | bool func0(int a1)
{
int v1; // esi
int v2; // eax
int v4; // [rsp+10h] [rbp-1C0h]
int v5; // [rsp+14h] [rbp-1BCh]
int v6; // [rsp+18h] [rbp-1B8h]
int i; // [rsp+1Ch] [rbp-1B4h]
int v8; // [rsp+20h] [rbp-1B0h]
int v9; // [rsp+24h] [rbp-1ACh]
int j; // [rsp+28h] [rbp-1A8h]
int v11; // [rsp+2Ch] [rbp... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1d0
MOV dword ptr [RBP + -0x1c4],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x1c4]
MOV dword ptr [RBP + -0x1c0],EAX
MOV dword ptr [RBP + -0x1bc],0x0
JMP 0x0010120f
LAB_001011a5:
MOV ESI,dword ptr [RBP + -0x1bc]
LEA E... | int4 func0(int param_1)
{
int iVar1;
long in_FS_OFFSET;
int local_1c8;
int local_1c4;
int local_1c0;
int local_1bc;
int local_1b8;
int local_1b4;
int local_1b0;
int aiStack_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1c4 = 0;
for (local_1c8 = param_1; 0 < l... |
4,609 | func0 | #include <assert.h>
#include <stdbool.h>
#include <stdio.h>
| bool func0(int x) {
int terms[100], temp = x, n = 0;
while (temp > 0) {
terms[n++] = temp % 10;
temp /= 10;
}
for (int left = 0, right = n - 1; left < right; left++, right--) {
int temp = terms[left];
terms[left] = terms[right];
terms[right] = temp;
... | int main() {
assert(func0(14) == true);
assert(func0(12) == false);
assert(func0(197) == true);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
test %edi,%edi
jle 122c <func0+0xc3>
mov %rsp,%rcx
mov %rcx,%r10
mov %edi,%edx
mov $0x0,%esi
mov %esi,%r9d
add $0x1,%esi
movslq %edx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edx,%r8d... | func0:
endbr64
sub rsp, 1A8h
mov r8d, edi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
test edi, edi
jle loc_1224
mov rcx, rsp
mov r10, rcx
mov edx, edi
mov esi, 0
loc_119F:
mov r9d, esi
add esi, 1
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov... | bool func0(int a1)
{
int *v2; // rcx
int *v3; // r10
int v4; // edx
int v5; // esi
int v6; // r9d
int v7; // edi
int *v8; // rdx
int v9; // eax
int v10; // edi
long long v11; // rax
int *v12; // rdi
int *i; // rcx
int v14; // edx
int *v15; // rax
_BYTE v17[4]; // [rsp+0h] [rbp-1ACh] BYREF... | func0:
ENDBR64
SUB RSP,0x1a8
MOV R8D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
TEST EDI,EDI
JLE 0x00101224
MOV RCX,RSP
MOV R10,RCX
MOV EDX,EDI
MOV ESI,0x0
LAB_0010119f:
MOV R9D,ESI
ADD ESI,0x1
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDI,EDX
SAR EDI,0x1f
SUB EAX,EDI
LEA ... | int8 func0(int param_1)
{
bool bVar1;
uint uVar2;
int *piVar3;
int *piVar5;
int *piVar6;
int iVar7;
int iVar8;
uint uVar9;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
ulong uVar4;
ulong uVar10;
piVar6 = local_1a8;
piVar5 = local_1a8;
local_10 = *(long *)(in_FS_OFFSET + 0x2... |
4,610 | func0 | #include <assert.h>
#include <stdbool.h>
#include <stdio.h>
| bool func0(int x) {
int terms[100], temp = x, n = 0;
while (temp > 0) {
terms[n++] = temp % 10;
temp /= 10;
}
for (int left = 0, right = n - 1; left < right; left++, right--) {
int temp = terms[left];
terms[left] = terms[right];
terms[right] = temp;
... | int main() {
assert(func0(14) == true);
assert(func0(12) == false);
assert(func0(197) == true);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
test %edi,%edi
jle 12fc <func0+0xec>
mov %rsp,%rsi
mov %edi,%edx
xor %r10d,%r10d
mov $0xcccccccd,%ebp
mov %rsi,%rcx
mov %rsi,%r11
nopl 0x0(%rax,%rax,1)
mov %edx,%eax
mov ... | func0:
endbr64
push rbp
mov r8d, edi
push rbx
sub rsp, 1A8h
mov rax, fs:28h
mov [rsp+1B8h+var_20], rax
xor eax, eax
test edi, edi
jle loc_12F5
mov rsi, rsp
mov edx, edi
xor r11d, r11d
mov ebp, 0CCCCCCCDh
mov r9, rsi
mov rbx, rsi
xchg ax, ax
loc_1250:
mov e... | bool func0(int a1)
{
unsigned int v2; // edx
unsigned int v3; // r11d
unsigned int *v4; // r9
_BYTE *v5; // rbx
unsigned int v6; // r10d
unsigned int v7; // eax
int v8; // edi
unsigned int *v9; // rcx
int v10; // edx
unsigned int v11; // edi
long long v12; // rax
int *v13; // rsi
int *i; // r... | func0:
ENDBR64
PUSH RBP
MOV R8D,EDI
PUSH RBX
SUB RSP,0x1a8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
TEST EDI,EDI
JLE 0x001012f5
MOV RSI,RSP
MOV EDX,EDI
XOR R11D,R11D
MOV EBP,0xcccccccd
MOV R9,RSI
MOV RBX,RSI
NOP
LAB_00101250:
MOV EAX,EDX
MOV R10D,R11D
ADD RBX,0x4
ADD R11D,0x1
IMUL RAX,RBP... | int8 func0(uint param_1)
{
uint uVar1;
uint uVar2;
uint *puVar4;
uint *puVar5;
uint uVar6;
ulong uVar7;
uint *puVar8;
uint uVar9;
uint uVar10;
long in_FS_OFFSET;
uint local_1b8 [102];
long local_20;
int iVar3;
puVar5 = local_1b8;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
puVar4 = (u... |
4,611 | func0 | #include <assert.h>
#include <stdbool.h>
#include <stdio.h>
| bool func0(int x) {
int terms[100], temp = x, n = 0;
while (temp > 0) {
terms[n++] = temp % 10;
temp /= 10;
}
for (int left = 0, right = n - 1; left < right; left++, right--) {
int temp = terms[left];
terms[left] = terms[right];
terms[right] = temp;
... | int main() {
assert(func0(14) == true);
assert(func0(12) == false);
assert(func0(197) == true);
return 0;
}
| O3 | c | func0:
endbr64
push %r14
push %r12
push %rbp
push %rbx
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
test %edi,%edi
jle 15f9 <func0+0x3e9>
mov %rsp,%rbx
mov %edi,%edx
xor %esi,%esi
mov $0xcccccccd,%r10d
mov %rbx,%r11
mov %rbx,%r8
mov %edx,%eax
mov ... | func0:
endbr64
push rbp
mov r8d, edi
push rbx
sub rsp, 1A8h
mov rax, fs:28h
mov [rsp+1B8h+var_20], rax
xor eax, eax
test edi, edi
jle loc_13AE
mov r11, rsp
mov esi, edi
xor edx, edx
mov ebp, 0CCCCCCCDh
mov rcx, r11
mov r10, r11
nop dword ptr [rax]
loc_1250:
m... | bool func0(int a1)
{
unsigned int v2; // esi
int v3; // edx
int *v4; // rcx
_DWORD *v5; // r10
int v6; // edi
unsigned int v7; // ebx
int v8; // r9d
int *v9; // rsi
int v10; // eax
int v11; // r9d
int v12; // r10d
const __m128i *v13; // rsi
const __m128i *v14; // rax
__m128i v15; // xmm1
... | func0:
ENDBR64
PUSH RBP
MOV R8D,EDI
PUSH RBX
SUB RSP,0x1a8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
TEST EDI,EDI
JLE 0x001013ae
MOV R11,RSP
MOV ESI,EDI
XOR EDX,EDX
MOV EBP,0xcccccccd
MOV RCX,R11
MOV R10,R11
NOP dword ptr [RAX]
LAB_00101250:
MOV EAX,ESI
MOV EBX,ESI
MOV EDI,EDX
ADD R10,0x4
... | int8 func0(uint param_1)
{
ulong uVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int iVar6;
int *piVar7;
ulong uVar8;
int *piVar9;
int iVar10;
int iVar11;
uint uVar12;
long in_FS_OFFSET;
uint uVar13;
int iVar14;
int iVar15;
int iVar16;
int aiStack_1c8 [106];
long local_20... |
4,612 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double slat, double slon, double elat, double elon) {
double dist = 6371.01 * acos(sin(slat) * sin(elat) + cos(slat) * cos(elat) * cos(slon - elon));
return dist;
}
| int main() {
assert(func0(23.5, 67.5, 25.5, 69.5) == 12179.372041317429);
assert(func0(10.5, 20.5, 30.5, 40.5) == 6069.397933300514);
assert(func0(10, 20, 30, 40) == 6783.751974994595);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd %xmm2,-0x28(%rbp)
movsd %xmm3,-0x30(%rbp)
mov -0x18(%rbp),%rax
movq %rax,%xmm0
callq 10b0 <sin@plt>
movsd %xmm0,-0x38(%rbp)
mov -0x28(%rbp),%rax
movq %rax,%xmm0
callq 10b0 <sin@plt>
movap... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
movsd [rbp+x], xmm0
movsd [rbp+var_20], xmm1
movsd [rbp+var_28], xmm2
movsd [rbp+var_30], xmm3
mov rax, [rbp+x]
movq xmm0, rax; x
call _sin
movsd [rbp+var_38], xmm0
mov rax, [rbp+var_28]
movq xmm0, rax; x
call _sin
movapd xmm4, ... | double func0(double a1, double a2, double a3, double a4)
{
double v4; // xmm0_8
double v6; // [rsp+0h] [rbp-40h]
double v7; // [rsp+0h] [rbp-40h]
double v8; // [rsp+8h] [rbp-38h]
double v9; // [rsp+8h] [rbp-38h]
v8 = sin(a1);
v9 = sin(a3) * v8;
v6 = cos(a1);
v7 = cos(a3) * v6;
v4 = cos(a2 - a4);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD qword ptr [RBP + -0x28],XMM2
MOVSD qword ptr [RBP + -0x30],XMM3
MOV RAX,qword ptr [RBP + -0x18]
MOVQ XMM0,RAX
CALL 0x001010b0
MOVSD qword ptr [RBP + -0x38],XMM0
MOV RAX,qword ptr [RBP + -0x28]
MO... | double func0(double param_1,double param_2,double param_3,double param_4)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
double dVar5;
dVar1 = sin(param_1);
dVar2 = sin(param_3);
dVar3 = cos(param_1);
dVar4 = cos(param_3);
dVar5 = cos(param_2 - param_4);
dVar1 = acos(dVar5 * dVar4 *... |
4,613 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double slat, double slon, double elat, double elon) {
double dist = 6371.01 * acos(sin(slat) * sin(elat) + cos(slat) * cos(elat) * cos(slon - elon));
return dist;
}
| int main() {
assert(func0(23.5, 67.5, 25.5, 69.5) == 12179.372041317429);
assert(func0(10.5, 20.5, 30.5, 40.5) == 6069.397933300514);
assert(func0(10, 20, 30, 40) == 6783.751974994595);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
movsd %xmm0,0x8(%rsp)
movsd %xmm1,0x10(%rsp)
movapd %xmm2,%xmm0
movsd %xmm3,0x18(%rsp)
lea 0x28(%rsp),%r12
lea 0x20(%rsp),%r13
mov %r13,%rsi
mov %r12,%rdi
callq 1090 <sincos@plt>
mov 0x20(%rsp),%rbx
mov 0x28(%rsp),%rb... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
movq r13, xmm0
movq rbp, xmm1
movapd xmm0, xmm2
movsd [rsp+58h+var_50], xmm3
lea r14, [rsp+58h+var_40]
lea r15, [rsp+58h+var_48]
mov rsi, r15
mov rdi, r14
call _sincos
mov rbx, [rsp+58... | double func0(double a1, double a2, double a3, double a4)
{
double v4; // rbx
double v5; // r12
double v6; // xmm1_8
double v8; // [rsp+10h] [rbp-48h] BYREF
double v9[8]; // [rsp+18h] [rbp-40h] BYREF
sincos(v9, &v8, a3);
v4 = v8;
v5 = v9[0];
sincos(v9, &v8, a1);
v6 = cos(a2 - a4);
return acos(v4 ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOVQ R13,XMM0
MOVQ RBP,XMM1
MOVAPD XMM0,XMM2
MOVSD qword ptr [RSP + 0x8],XMM3
LEA R14,[RSP + 0x18]
LEA R15,[RSP + 0x10]
MOV RSI,R15
MOV RDI,R14
CALL 0x00101090
MOV RBX,qword ptr [RSP + 0x10]
MOV R12,qword ptr [RSP + 0x18]
MOV RSI,R15
MOV ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2,double param_3,double param_4)
{
double dVar1;
double dVar2;
double dVar3;
double local_48;
double local_40 [2];
sincos(param_3,local_40,&local_48);
dVar1 = local_40[0];
d... |
4,614 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double slat, double slon, double elat, double elon) {
double dist = 6371.01 * acos(sin(slat) * sin(elat) + cos(slat) * cos(elat) * cos(slon - elon));
return dist;
}
| int main() {
assert(func0(23.5, 67.5, 25.5, 69.5) == 12179.372041317429);
assert(func0(10.5, 20.5, 30.5, 40.5) == 6069.397933300514);
assert(func0(10, 20, 30, 40) == 6783.751974994595);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
sub $0x48,%rsp
lea 0x38(%rsp),%rbp
lea 0x30(%rsp),%r12
movsd %xmm0,0x28(%rsp)
movapd %xmm2,%xmm0
mov %r12,%rsi
mov %rbp,%rdi
movsd %xmm1,0x20(%rsp)
movsd %xmm3,0x8(%rsp)
callq 1090 <sincos@plt>
movsd 0x28(%rsp),%xmm4
mov %r12,%rsi
mov %rbp,%rdi
movsd 0x3... | func0:
endbr64
push r12
push rbp
sub rsp, 48h
lea rbp, [rsp+58h+var_20]
lea r12, [rsp+58h+var_28]
movsd [rsp+58h+var_30], xmm0
movapd xmm0, xmm2
mov rsi, r12
mov rdi, rbp
movsd [rsp+58h+var_38], xmm1
movsd [rsp+58h+var_50], xmm3
call _sincos
movsd xmm4, [rsp+58h+var_30]
mov rsi... | double func0(double a1, double a2, double a3, double a4)
{
double v4; // xmm0_8
double v6; // [rsp+10h] [rbp-48h]
double v7; // [rsp+18h] [rbp-40h]
double v8; // [rsp+30h] [rbp-28h] BYREF
double v9[4]; // [rsp+38h] [rbp-20h] BYREF
sincos(v9, &v8, a3);
v7 = v8;
v6 = v9[0];
sincos(v9, &v8, a1);
v4 =... | func0:
ENDBR64
PUSH R12
PUSH RBP
SUB RSP,0x48
LEA RBP,[RSP + 0x38]
LEA R12,[RSP + 0x30]
MOVSD qword ptr [RSP + 0x28],XMM0
MOVAPD XMM0,XMM2
MOV RSI,R12
MOV RDI,RBP
MOVSD qword ptr [RSP + 0x20],XMM1
MOVSD qword ptr [RSP + 0x8],XMM3
CALL 0x00101090
MOVSD XMM4,qword ptr [RSP + 0x28]
MOV RSI,R12
MOV RDI,RBP
MOVSD XMM2,qword... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2,double param_3,double param_4)
{
double dVar1;
double dVar2;
double dVar3;
double local_28;
double local_20 [2];
sincos(param_3,local_20,&local_28);
dVar1 = local_20[0];
d... |
4,615 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double slat, double slon, double elat, double elon) {
double dist = 6371.01 * acos(sin(slat) * sin(elat) + cos(slat) * cos(elat) * cos(slon - elon));
return dist;
}
| int main() {
assert(func0(23.5, 67.5, 25.5, 69.5) == 12179.372041317429);
assert(func0(10.5, 20.5, 30.5, 40.5) == 6069.397933300514);
assert(func0(10, 20, 30, 40) == 6783.751974994595);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
sub $0x48,%rsp
lea 0x38(%rsp),%rbp
lea 0x30(%rsp),%r12
movsd %xmm0,0x28(%rsp)
movapd %xmm2,%xmm0
mov %r12,%rsi
mov %rbp,%rdi
movsd %xmm1,0x20(%rsp)
movsd %xmm3,0x8(%rsp)
callq 1090 <sincos@plt>
movsd 0x28(%rsp),%xmm4
mov %r12,%rsi
mov %rbp,%rdi
movsd 0x3... | func0:
endbr64
push r14
movq r14, xmm0
movapd xmm0, xmm2; x
push rbp
push rbx
sub rsp, 30h
lea rbx, [rsp+48h+sinx]
lea rbp, [rsp+48h+cosx]
movsd [rsp+48h+var_30], xmm1
mov rsi, rbp; cosx
mov rdi, rbx; sinx
movsd [rsp+48h+var_48], xmm3
call _sincos
mov rsi, rbp; cosx
mov r... | double func0(double a1, double a2, double a3, double a4)
{
double v4; // xmm0_8
double v6; // [rsp+8h] [rbp-40h]
double v7; // [rsp+10h] [rbp-38h]
double cosx; // [rsp+20h] [rbp-28h] BYREF
double sinx[4]; // [rsp+28h] [rbp-20h] BYREF
sincos(a3, sinx, &cosx);
v7 = cosx;
v6 = sinx[0];
sincos(a1, sinx,... | func0:
ENDBR64
PUSH R14
MOVQ R14,XMM0
MOVAPD XMM0,XMM2
PUSH RBP
PUSH RBX
SUB RSP,0x30
LEA RBX,[RSP + 0x28]
LEA RBP,[RSP + 0x20]
MOVSD qword ptr [RSP + 0x18],XMM1
MOV RSI,RBP
MOV RDI,RBX
MOVSD qword ptr [RSP],XMM3
CALL 0x00101090
MOV RSI,RBP
MOV RDI,RBX
MOVQ XMM0,R14
MOVSD XMM2,qword ptr [RSP + 0x20]
MOVSD XMM3,qword pt... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2,double param_3,double param_4)
{
double dVar1;
double dVar2;
double dVar3;
double local_28;
double local_20;
sincos(param_3,&local_20,&local_28);
dVar1 = local_20;
dVar3 =... |
4,616 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char *arr[], int n) {
if (n == 0)
return "";
char *prefix = strdup(arr[0]);
for (int i = 1; i < n; i++) {
int j = 0;
while (prefix[j] && arr[i][j] && prefix[j] == arr[i][j]) {
j++;
}
prefix[j] = '\0';
}
return prefix;
}
... | int main() {
char *arr1[] = {"tablets", "tables", "taxi", "tamarind"};
assert(strcmp(func0(arr1, 4), "ta") == 0);
char *arr2[] = {"apples", "ape", "april"};
assert(strcmp(func0(arr2, 3), "ap") == 0);
char *arr3[] = {"teens", "teenager", "teenmar"};
assert(strcmp(func0(arr3, 3), "teen")... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
cmpl $0x0,-0x1c(%rbp)
jne 11ce <func0+0x25>
lea 0xe3f(%rip),%rax
jmpq 128e <func0+0xe5>
mov -0x18(%rbp),%rax
mov (%rax),%rax
mov %rax,%rdi
callq 10b0 <strdup@plt>
mov %rax,-0x8(%rbp)
movl... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
cmp [rbp+var_1C], 0
jnz short loc_11CE
lea rax, unk_2008
jmp locret_128E
loc_11CE:
mov rax, [rbp+var_18]
mov rax, [rax]
mov rdi, rax; s
call _strdup
mov [rbp+var_8], rax
mo... | char * func0(const char **a1, int a2)
{
int i; // [rsp+10h] [rbp-10h]
int j; // [rsp+14h] [rbp-Ch]
char *v5; // [rsp+18h] [rbp-8h]
if ( !a2 )
return (char *)&unk_2008;
v5 = strdup(*a1);
for ( i = 1; i < a2; ++i )
{
for ( j = 0; v5[j] && a1[i][j] && v5[j] == a1[i][j]; ++j )
;
v5[j] = 0;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x001011ce
LEA RAX,[0x102008]
JMP 0x0010128e
LAB_001011ce:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],R... | char * func0(int8 *param_1,int param_2)
{
char *pcVar1;
int local_18;
int local_14;
if (param_2 == 0) {
pcVar1 = "";
}
else {
pcVar1 = strdup((char *)*param_1);
for (local_18 = 1; local_18 < param_2; local_18 = local_18 + 1) {
for (local_14 = 0;
((pcVar1[local_14] != '\0' && ... |
4,617 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char *arr[], int n) {
if (n == 0)
return "";
char *prefix = strdup(arr[0]);
for (int i = 1; i < n; i++) {
int j = 0;
while (prefix[j] && arr[i][j] && prefix[j] == arr[i][j]) {
j++;
}
prefix[j] = '\0';
}
return prefix;
}
... | int main() {
char *arr1[] = {"tablets", "tables", "taxi", "tamarind"};
assert(strcmp(func0(arr1, 4), "ta") == 0);
char *arr2[] = {"apples", "ape", "april"};
assert(strcmp(func0(arr2, 3), "ap") == 0);
char *arr3[] = {"teens", "teenager", "teenmar"};
assert(strcmp(func0(arr3, 3), "teen")... | O1 | c | func0:
endbr64
lea 0xe8f(%rip),%rax
test %esi,%esi
jne 1199 <func0+0x10>
retq
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %esi,%ebx
mov (%rdi),%rdi
callq 1090 <strdup@plt>
cmp $0x1,%ebx
jle 11f9 <func0+0x70>
lea 0x8(%rbp),%r8
lea -0x2(%rbx),%edx
lea 0x10(%rbp,%rdx,8),%r9
... | func0:
endbr64
lea rax, aTa+2; ""
test esi, esi
jnz short loc_11B9
retn
loc_11B9:
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, esi
mov rdi, [rdi]
call _strdup
cmp ebx, 1
jle short loc_1219
lea r8, [rbp+8]
lea edx, [rbx-2]
lea r9, [rbp+rdx*8+10h]
jmp shor... | char * func0(_QWORD *a1, int a2)
{
char *result; // rax
_BYTE **v3; // r8
long long v4; // r9
char *v5; // rcx
char v6; // dl
_BYTE *v7; // rdi
result = "";
if ( a2 )
{
result = (char *)strdup(*a1);
if ( a2 > 1 )
{
v3 = (_BYTE **)(a1 + 1);
v4 = (long long)&a1[(unsigned int)(a2... | func0:
ENDBR64
LEA RAX,[0x102023]
TEST ESI,ESI
JNZ 0x001011b9
RET
LAB_001011b9:
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
MOV RDI,qword ptr [RDI]
CALL 0x001010b0
CMP EBX,0x1
JLE 0x00101219
LEA R8,[RBP + 0x8]
LEA EDX,[RBX + -0x2]
LEA R9,[RBP + RDX*0x8 + 0x10]
JMP 0x001011ee
LAB_001011df:
MOV RCX,RAX
LAB_0010... | char * func0(int8 *param_1,int param_2)
{
char *pcVar1;
char *pcVar2;
char cVar3;
char *pcVar4;
int8 *puVar5;
if (param_2 == 0) {
return "";
}
pcVar1 = strdup((char *)*param_1);
if (1 < param_2) {
puVar5 = param_1 + 1;
do {
cVar3 = *pcVar1;
pcVar2 = pcVar1;
if (cVar3 ... |
4,618 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char *arr[], int n) {
if (n == 0)
return "";
char *prefix = strdup(arr[0]);
for (int i = 1; i < n; i++) {
int j = 0;
while (prefix[j] && arr[i][j] && prefix[j] == arr[i][j]) {
j++;
}
prefix[j] = '\0';
}
return prefix;
}
... | int main() {
char *arr1[] = {"tablets", "tables", "taxi", "tamarind"};
assert(strcmp(func0(arr1, 4), "ta") == 0);
char *arr2[] = {"apples", "ape", "april"};
assert(strcmp(func0(arr2, 3), "ap") == 0);
char *arr3[] = {"teens", "teenager", "teenmar"};
assert(strcmp(func0(arr3, 3), "teen")... | O2 | c | func0:
endbr64
test %esi,%esi
jne 13a0 <func0+0x10>
lea 0xc81(%rip),%rax
retq
jmpq 1300 <func0.part.0>
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
mov rdi, [rdi]
call _strdup
cmp ebp, 1
jle short loc_1389
lea edx, [rbp-2]
lea r8, [rbx+8]
lea r9, [rbx+rdx*8+10h]
nop dword ptr [rax+00h]
loc_1348:
movzx edx, byte ptr [rax]
test dl, dl
jz sh... | _BYTE * func0_part_0(_QWORD *a1, int a2)
{
_BYTE *result; // rax
_BYTE **v3; // r8
long long v4; // r9
char v5; // dl
_BYTE *v6; // rdi
_BYTE *v7; // rcx
result = (_BYTE *)strdup(*a1);
if ( a2 > 1 )
{
v3 = (_BYTE **)(a1 + 1);
v4 = (long long)&a1[(unsigned int)(a2 - 2) + 2];
do
{
... | func0.part.0:
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV RDI,qword ptr [RDI]
CALL 0x001010b0
CMP EBP,0x1
JLE 0x00101389
LEA EDX,[RBP + -0x2]
LEA R8,[RBX + 0x8]
LEA R9,[RBX + RDX*0x8 + 0x10]
NOP dword ptr [RAX]
LAB_00101348:
MOVZX EDX,byte ptr [RAX]
TEST DL,DL
JZ 0x00101390
MOV RDI,qword ptr [R8]
MOV RCX,... | void func0_part_0(int8 *param_1,int param_2)
{
char *pcVar1;
char *pcVar2;
char cVar3;
char *pcVar4;
int8 *puVar5;
pcVar1 = strdup((char *)*param_1);
if (1 < param_2) {
puVar5 = param_1 + 1;
do {
while (cVar3 = *pcVar1, cVar3 == '\0') {
puVar5 = puVar5 + 1;
*pcVar1 = '\0'... |
4,619 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char *arr[], int n) {
if (n == 0)
return "";
char *prefix = strdup(arr[0]);
for (int i = 1; i < n; i++) {
int j = 0;
while (prefix[j] && arr[i][j] && prefix[j] == arr[i][j]) {
j++;
}
prefix[j] = '\0';
}
return prefix;
}
... | int main() {
char *arr1[] = {"tablets", "tables", "taxi", "tamarind"};
assert(strcmp(func0(arr1, 4), "ta") == 0);
char *arr2[] = {"apples", "ape", "april"};
assert(strcmp(func0(arr2, 3), "ap") == 0);
char *arr3[] = {"teens", "teenager", "teenmar"};
assert(strcmp(func0(arr3, 3), "teen")... | O3 | c | func0:
endbr64
lea 0xc55(%rip),%rax
test %esi,%esi
jne 13d0 <func0+0x10>
retq
push %rbp
mov %rdi,%rbp
push %rbx
mov %esi,%ebx
sub $0x8,%rsp
mov (%rdi),%rdi
callq 1090 <strdup@plt>
cmp $0x1,%ebx
jle 1439 <func0+0x79>
lea -0x2(%rbx),%edx
lea 0x8(%rbp),%r8
lea 0x10(%rbp,%rdx,8),%r9
... | func0_part_0:
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
mov rdi, [rdi]; s
call _strdup
cmp ebp, 1
jle short loc_13A9
lea edx, [rbp-2]
lea r8, [rbx+8]
lea r9, [rbx+rdx*8+10h]
nop dword ptr [rax+00h]
loc_1368:
movzx edx, byte ptr [rax]
test dl, dl
jz ... | char * func0_part_0(const char **a1, int a2)
{
char *result; // rax
_BYTE **v3; // r8
long long v4; // r9
char v5; // dl
_BYTE *v6; // rdi
char *v7; // rcx
result = strdup(*a1);
if ( a2 > 1 )
{
v3 = (_BYTE **)(a1 + 1);
v4 = (long long)&a1[(unsigned int)(a2 - 2) + 2];
do
{
while ... | func0.part.0:
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV RDI,qword ptr [RDI]
CALL 0x001010b0
CMP EBP,0x1
JLE 0x001013a9
LEA EDX,[RBP + -0x2]
LEA R8,[RBX + 0x8]
LEA R9,[RBX + RDX*0x8 + 0x10]
NOP dword ptr [RAX]
LAB_00101368:
MOVZX EDX,byte ptr [RAX]
TEST DL,DL
JZ 0x001013b0
MOV RDI,qword ptr [R8]
MOV RCX,... | void func0_part_0(int8 *param_1,int param_2)
{
char *pcVar1;
char *pcVar2;
char cVar3;
char *pcVar4;
int8 *puVar5;
pcVar1 = strdup((char *)*param_1);
if (1 < param_2) {
puVar5 = param_1 + 1;
do {
while (cVar3 = *pcVar1, cVar3 == '\0') {
puVar5 = puVar5 + 1;
*pcVar1 = '\0'... |
4,620 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| void func0(char *string, char uppercase_characters[], char lowercase_characters[], char numerical_characters[], char special_characters[]) {
int upper_idx = 0, lower_idx = 0, num_idx = 0, special_idx = 0;
int len = strlen(string);
for (int i = 0; i < len; i++) {
if (isupper(string[i])) {
... | int main() {
char uppers[100], lowers[100], nums[100], specials[100];
func0("ThisIsGeeksforGeeks", uppers, lowers, nums, specials);
assert(strcmp(uppers, "TIGG") == 0);
assert(strcmp(lowers, "hisseeksforeeks") == 0);
assert(strcmp(nums, "") == 0);
assert(strcmp(specials, "") == 0);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %rdx,-0x38(%rbp)
mov %rcx,-0x40(%rbp)
mov %r8,-0x48(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
cal... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov [rbp+var_40], rcx
mov [rbp+var_48], r8
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov rax, [rbp+s]
mov rdi, rax; s... | _BYTE * func0(const char *a1, long long a2, long long a3, long long a4, long long a5)
{
int v5; // eax
int v6; // eax
int v7; // eax
int v8; // eax
_BYTE *result; // rax
int v13; // [rsp+38h] [rbp-18h]
int v14; // [rsp+3Ch] [rbp-14h]
int v15; // [rsp+40h] [rbp-10h]
int v16; // [rsp+44h] [rbp-Ch]
int... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV qword ptr [RBP + -0x40],RCX
MOV qword ptr [RBP + -0x48],R8
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [R... | void func0(char *param_1,long param_2,long param_3,long param_4,long param_5)
{
size_t sVar1;
ushort **ppuVar2;
int local_20;
int local_1c;
int local_18;
int local_14;
int local_10;
local_20 = 0;
local_1c = 0;
local_18 = 0;
local_14 = 0;
sVar1 = strlen(param_1);
for (local_10 = 0; local_10... |
4,621 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| void func0(char *string, char uppercase_characters[], char lowercase_characters[], char numerical_characters[], char special_characters[]) {
int upper_idx = 0, lower_idx = 0, num_idx = 0, special_idx = 0;
int len = strlen(string);
for (int i = 0; i < len; i++) {
if (isupper(string[i])) {
... | int main() {
char uppers[100], lowers[100], nums[100], specials[100];
func0("ThisIsGeeksforGeeks", uppers, lowers, nums, specials);
assert(strcmp(uppers, "TIGG") == 0);
assert(strcmp(lowers, "hisseeksforeeks") == 0);
assert(strcmp(nums, "") == 0);
assert(strcmp(specials, "") == 0);
... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %rsi,%rbp
mov %rdx,%r12
mov %rcx,%r14
mov %r8,%r15
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbx
test %ebx,%ebx
jle ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
mov rbx, rsi
mov rbp, rdx
mov r13, rcx
mov r15, r8
call _strlen
test eax, eax
jle loc_1294
mov r14, rax
call ___ctype_b_loc
mov rdi, rax
mov rax, r12
lea ed... | unsigned __int8 * func0(unsigned __int8 *a1, long long a2, long long a3, long long a4, long long a5)
{
unsigned __int8 *result; // rax
int v11; // r14d
_QWORD *v12; // rdi
long long v13; // r9
int v14; // r11d
int v15; // r10d
int v16; // r8d
int v17; // esi
unsigned long long v18; // r12
unsigned l... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV RBX,RSI
MOV RBP,RDX
MOV R13,RCX
MOV R15,R8
CALL 0x00101090
TEST EAX,EAX
JLE 0x00101294
MOV R14,RAX
CALL 0x001010d0
MOV RDI,RAX
MOV RAX,R12
LEA EDX,[R14 + -0x1]
LEA R9,[R12 + RDX*0x1 + 0x1]
MOV R11D,0x0
MOV R10D,0x0
MOV R8D,... | void func0(byte *param_1,long param_2,long param_3,long param_4,long param_5)
{
byte *pbVar1;
byte bVar2;
ushort uVar3;
size_t sVar4;
ushort **ppuVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
sVar4 = strlen((char *)param_1);
if ((int)sVar4 < 1) {
iVar9 = 0;
iVar8 = 0;
iVar7 = 0... |
4,622 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| void func0(char *string, char uppercase_characters[], char lowercase_characters[], char numerical_characters[], char special_characters[]) {
int upper_idx = 0, lower_idx = 0, num_idx = 0, special_idx = 0;
int len = strlen(string);
for (int i = 0; i < len; i++) {
if (isupper(string[i])) {
... | int main() {
char uppers[100], lowers[100], nums[100], specials[100];
func0("ThisIsGeeksforGeeks", uppers, lowers, nums, specials);
assert(strcmp(uppers, "TIGG") == 0);
assert(strcmp(lowers, "hisseeksforeeks") == 0);
assert(strcmp(nums, "") == 0);
assert(strcmp(specials, "") == 0);
... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rsi,%rbx
sub $0x38,%rsp
mov %rcx,0x8(%rsp)
mov %r8,0x10(%rsp)
callq 1080 <strlen@plt>
test %eax,%eax
jle 1620 <func0+0x170>
mov %rax,%r14
xor %r12d,%r12d
xor %r15d,%r1... | func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
mov r13, r8
push r12
mov r12, rcx
push rbp
mov rbp, rdx
push rbx
mov rbx, rsi
sub rsp, 8
call _strlen
test eax, eax
jle loc_1566
mov r15, rax
call ___ctype_b_loc
mov rdx, r14
xor r8d, r8d
xor r1... | long long func0(char *a1, _BYTE *a2, _BYTE *a3, _BYTE *a4, _BYTE *a5)
{
long long result; // rax
int v11; // r15d
long long v12; // rax
char *v13; // rdx
int v14; // r8d
int v15; // r11d
_QWORD *v16; // rdi
int v17; // r9d
int v18; // esi
long long v19; // r10
unsigned long long v20; // r14
lon... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
MOV R13,R8
PUSH R12
MOV R12,RCX
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x00101080
TEST EAX,EAX
JLE 0x00101566
MOV R15,RAX
CALL 0x001010b0
MOV RDX,R14
XOR R8D,R8D
XOR R11D,R11D
MOV RDI,RAX
LEA EAX,[R15 + -0x1]
XOR R9D,R9D
XOR ESI,ESI
LEA R10,[R14 ... | void func0(byte *param_1,int1 *param_2,int1 *param_3,int1 *param_4,
int1 *param_5)
{
byte *pbVar1;
byte bVar2;
ushort uVar3;
size_t sVar4;
ushort **ppuVar5;
long lVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
sVar4 = strlen((char *)param_1);
if (0 < (int)sVar4) {
ppuVar5 =... |
4,623 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
| void func0(char *string, char uppercase_characters[], char lowercase_characters[], char numerical_characters[], char special_characters[]) {
int upper_idx = 0, lower_idx = 0, num_idx = 0, special_idx = 0;
int len = strlen(string);
for (int i = 0; i < len; i++) {
if (isupper(string[i])) {
... | int main() {
char uppers[100], lowers[100], nums[100], specials[100];
func0("ThisIsGeeksforGeeks", uppers, lowers, nums, specials);
assert(strcmp(uppers, "TIGG") == 0);
assert(strcmp(lowers, "hisseeksforeeks") == 0);
assert(strcmp(nums, "") == 0);
assert(strcmp(specials, "") == 0);
... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rsi,%rbx
sub $0x38,%rsp
mov %rcx,0x8(%rsp)
mov %r8,0x10(%rsp)
callq 1080 <strlen@plt>
test %eax,%eax
jle 1620 <func0+0x170>
mov %rax,%r14
xor %r12d,%r12d
xor %r15d,%r1... | func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
mov r13, r8
push r12
mov r12, rcx
push rbp
mov rbp, rdx
push rbx
mov rbx, rsi
sub rsp, 8
call _strlen
test eax, eax
jle short loc_1545
mov r15, rax
call ___ctype_b_loc
mov rdx, r14
xor r11d, r11d
xo... | size_t func0(const char *a1, _BYTE *a2, _BYTE *a3, _BYTE *a4, _BYTE *a5)
{
size_t result; // rax
int v11; // r15d
const unsigned __int16 **v12; // rax
const char *v13; // rdx
int v14; // r11d
int v15; // r8d
const unsigned __int16 **v16; // r9
int v17; // r10d
int v18; // edi
long long v19; // r14
... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
MOV R13,R8
PUSH R12
MOV R12,RCX
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x00101080
TEST EAX,EAX
JLE 0x00101545
MOV R15,RAX
CALL 0x001010b0
MOV RDX,R14
XOR R11D,R11D
XOR R8D,R8D
MOV R9,RAX
LEA EAX,[R15 + -0x1]
XOR R10D,R10D
XOR EDI,EDI
LEA R14,[R14... | void func0(byte *param_1,int *param_2,int *param_3,int *param_4,int *param_5
)
{
byte *pbVar1;
byte bVar2;
ushort uVar3;
size_t sVar4;
ushort **ppuVar5;
long lVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
sVar4 = strlen((char *)param_1);
if (0 < (int)sVar4) {
ppuVar5 = __c... |
4,624 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] - arr[j] == k || arr[j] - arr[i] == k) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 5, 3, 4, 2};
int arr2[] = {8, 12, 16, 4, 0, 20};
int arr3[] = {2, 4, 1, 3, 4};
assert(func0(arr1, 5, 3) == 2);
assert(func0(arr2, 6, 4) == 5);
assert(func0(arr3, 5, 2) == 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,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmpq 1217 <func0+0xae>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 120b <func0+0xa2>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp loc_1213
loc_118E:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_1207
loc_1199:
mov eax, [rbp+var_8]
cd... | long long func0(long long a1, int a2, int a3)
{
unsigned int v4; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int j; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( a3 == *(_DWORD *)(4LL * i + a1) - *(_DWORD *)(4LL * j + a1)
|| a... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101213
LAB_0010118e:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00101207
LAB_0010... | int func0(long param_1,int param_2,int param_3)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_c = local_10, local_10 < param_2; local_10 = local_10 + 1) {
while (local_c = local_c + 1, local_c < param_2) {
if ((param_3 == *(int *)(param_1 + (long)local_10 *... |
4,625 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] - arr[j] == k || arr[j] - arr[i] == k) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 5, 3, 4, 2};
int arr2[] = {8, 12, 16, 4, 0, 20};
int arr3[] = {2, 4, 1, 3, 4};
assert(func0(arr1, 5, 3) == 2);
assert(func0(arr2, 6, 4) == 5);
assert(func0(arr3, 5, 2) == 3);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11bd <func0+0x54>
push %rbx
lea -0x1(%rsi),%ebx
add $0x1,%rbx
mov $0x1,%r11d
mov $0x0,%r10d
jmp 11ae <func0+0x45>
add $0x1,%r10d
add $0x1,%rax
cmp %eax,%esi
jle 11aa <func0+0x41>
mov (%rdi,%rax,4),%ecx
mov %r9d,%r8d
sub %ecx,%r8d
cmp %edx,%... | func0:
endbr64
test esi, esi
jle short loc_11B8
push rbx
mov ebx, esi
mov r11d, 1
mov r10d, 0
jmp short loc_11A9
loc_1182:
add r10d, 1
loc_1186:
add rax, 1
cmp esi, eax
jle short loc_11A5
loc_118E:
mov ecx, [rdi+rax*4]
mov r8d, r9d
sub r8d, ecx
cmp r8d, edx
jz ... | long long func0(long long a1, int a2, int a3)
{
long long v3; // r11
unsigned int v4; // r10d
long long v5; // rax
int v6; // ecx
int v7; // r9d
if ( a2 <= 0 )
return 0LL;
v3 = 1LL;
v4 = 0;
while ( v3 != a2 )
{
v7 = *(_DWORD *)(a1 + 4 * v3 - 4);
v5 = v3;
do
{
v6 = *(_DWOR... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011b8
PUSH RBX
MOV EBX,ESI
MOV R11D,0x1
MOV R10D,0x0
JMP 0x001011a9
LAB_00101182:
ADD R10D,0x1
LAB_00101186:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x001011a5
LAB_0010118e:
MOV ECX,dword ptr [RDI + RAX*0x4]
MOV R8D,R9D
SUB R8D,ECX
CMP R8D,EDX
JZ 0x00101182
SUB ECX,R9D
CMP ECX,EDX
JNZ 0x0010118... | int func0(long param_1,uint param_2,int param_3)
{
int iVar1;
int iVar2;
ulong uVar3;
int iVar4;
ulong uVar5;
if (0 < (int)param_2) {
iVar4 = 0;
for (uVar5 = 1; uVar5 != param_2; uVar5 = uVar5 + 1) {
iVar2 = *(int *)(param_1 + -4 + uVar5 * 4);
uVar3 = uVar5;
do {
iVar1 ... |
4,626 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] - arr[j] == k || arr[j] - arr[i] == k) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 5, 3, 4, 2};
int arr2[] = {8, 12, 16, 4, 0, 20};
int arr3[] = {2, 4, 1, 3, 4};
assert(func0(arr1, 5, 3) == 2);
assert(func0(arr2, 6, 4) == 5);
assert(func0(arr3, 5, 2) == 3);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1407 <func0+0x67>
push %rbx
lea -0x1(%rsi),%ebx
mov $0x1,%r11d
xor %r10d,%r10d
add $0x1,%rbx
cmp %rbx,%r11
je 1402 <func0+0x62>
xchg %ax,%ax
mov -0x4(%rdi,%r11,4),%r9d
mov %r11,%rax
jmp 13df <func0+0x3f>
nopw 0x0(%rax,%rax,1)
sub %r9d,%ecx
cmp ... | func0:
endbr64
test esi, esi
jle short loc_1327
push rbx
mov r11d, 1
movsxd rbx, esi
xor r10d, r10d
cmp r11, rbx
jz short loc_1322
nop word ptr [rax+rax+00h]
loc_12E0:
mov r9d, [rdi+r11*4-4]
mov rax, r11
jmp short loc_12FF
loc_12F0:
sub ecx, r9d
cmp ecx, edx
jz s... | long long func0(long long a1, int a2, int a3)
{
long long v3; // r11
unsigned int i; // r10d
int v5; // r9d
long long v6; // rax
int v7; // ecx
if ( a2 <= 0 )
return 0LL;
v3 = 1LL;
for ( i = 0; v3 != a2; ++v3 )
{
v5 = *(_DWORD *)(a1 + 4 * v3 - 4);
v6 = v3;
do
{
while ( 1 )
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101327
PUSH RBX
MOV R11D,0x1
MOVSXD RBX,ESI
XOR R10D,R10D
CMP R11,RBX
JZ 0x00101322
NOP word ptr [RAX + RAX*0x1]
LAB_001012e0:
MOV R9D,dword ptr [RDI + R11*0x4 + -0x4]
MOV RAX,R11
JMP 0x001012ff
LAB_001012f0:
SUB ECX,R9D
CMP ECX,EDX
JZ 0x0010130d
ADD RAX,0x1
CMP ESI,EAX
JLE 0x0010131... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
long lVar3;
int iVar4;
long lVar5;
if (param_2 < 1) {
return 0;
}
lVar5 = 1;
iVar4 = 0;
if ((long)param_2 != 1) {
do {
iVar1 = *(int *)(param_1 + -4 + lVar5 * 4);
lVar3 = lVar5;
do {
while (... |
4,627 | func0 |
#include <assert.h>
| int func0(int arr[], int n, int k) {
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] - arr[j] == k || arr[j] - arr[i] == k) {
count++;
}
}
}
return count;
}
| int main() {
int arr1[] = {1, 5, 3, 4, 2};
int arr2[] = {8, 12, 16, 4, 0, 20};
int arr3[] = {2, 4, 1, 3, 4};
assert(func0(arr1, 5, 3) == 2);
assert(func0(arr2, 6, 4) == 5);
assert(func0(arr3, 5, 2) == 3);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
test %esi,%esi
jle 150e <func0+0x19e>
cmp $0x1,%esi
je 150e <func0+0x19e>
movd %edx,%xmm6
lea 0x4(%rdi),%r11
xor %r12d,%r12d
mov $0x1,%ebx
pshufd $0x0,%xmm6,%xmm4
mov $0x1,%r8d
lea -0x1(%rsi),%ebp
pxor %xmm6,%xmm6
nopl (%rax... | func0:
endbr64
test esi, esi
jle loc_14AD
cmp esi, 1
jz loc_14AD
movd xmm7, edx
push r13
mov r11d, edx
lea r9, [rdi+4]
push r12
xor r10d, r10d
mov ecx, 1
lea r12d, [rsi-1]
push rbp
pshufd xmm4, xmm7, 0
mov ebp, 1
push rbx
mov rbx, rdi
nop
loc_1370:
mov edi... | long long func0(long long a1, int a2, unsigned int a3)
{
const __m128i *v4; // r9
unsigned int v5; // r10d
int v6; // ecx
__m128i v7; // xmm4
unsigned int v9; // r8d
unsigned int v10; // edi
__m128i v11; // xmm2
const __m128i *v12; // rax
__m128i v13; // xmm3
__m128i v14; // xmm5
__m128i v15; // ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001014ad
CMP ESI,0x1
JZ 0x001014ad
MOVD XMM7,EDX
PUSH R13
MOV R11D,EDX
LEA R9,[RDI + 0x4]
PUSH R12
XOR R10D,R10D
MOV ECX,0x1
LEA R12D,[RSI + -0x1]
PUSH RBP
PSHUFD XMM4,XMM7,0x0
MOV EBP,0x1
PUSH RBX
MOV RBX,RDI
NOP
LAB_00101370:
MOV EDI,ESI
MOV EAX,R12D
MOV R8D,dword ptr [R9 + -0x4]
SUB... | int func0(long param_1,int param_2,int param_3)
{
long lVar1;
int iVar2;
uint uVar3;
int iVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int iVar9;
int *piVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if ((param_2 < 1) || (param_2 == 1)) {
return 0... |
4,628 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int list[], int count, int num) {
for (int i = 0; i < count; i++) {
if (list[i] < num) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {220, 330, 500};
int arr2[] = {12, 17, 21};
int arr3[] = {1, 2, 3, 4};
assert(func0(arr1, 3, 200) == true);
assert(func0(arr2, 3, 20) == false);
assert(func0(arr3, 4, 10) == false);
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,-0x4(%rbp)
jmp 11aa <func0+0x41>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jle 11a6 <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_11AA
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)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( a3 > *(_DWORD *)(4LL * i + a1) )
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 + -0x20],EDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011aa
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... | int8 func0(long param_1,int param_2,int param_3)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 1;
}
if (*(int *)(param_1 + (long)local_c * 4) < param_3) break;
local_c = local_c + 1;
}
return 0;
} |
4,629 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int list[], int count, int num) {
for (int i = 0; i < count; i++) {
if (list[i] < num) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {220, 330, 500};
int arr2[] = {12, 17, 21};
int arr3[] = {1, 2, 3, 4};
assert(func0(arr1, 3, 200) == true);
assert(func0(arr2, 3, 20) == false);
assert(func0(arr3, 4, 10) == false);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 118f <func0+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%rcx
cmp %edx,(%rax)
jl 1195 <func0+0x2c>
add $0x4,%rax
cmp %rcx,%rax
jne 117c <func0+0x13>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| func0:
endbr64
test esi, esi
jle short loc_118F
mov rax, rdi
lea ecx, [rsi-1]
lea rcx, [rdi+rcx*4+4]
loc_117C:
cmp [rax], edx
jl short loc_1195
add rax, 4
cmp rax, rcx
jnz short loc_117C
mov eax, 1
retn
loc_118F:
mov eax, 1
retn
loc_1195:
mov eax, 0
retn | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = a1;
while ( *v3 >= a3 )
{
if ( ++v3 == &a1[a2 - 1 + 1] )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010118f
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RCX,[RDI + RCX*0x4 + 0x4]
LAB_0010117c:
CMP dword ptr [RAX],EDX
JL 0x00101195
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010117c
MOV EAX,0x1
RET
LAB_0010118f:
MOV EAX,0x1
RET
LAB_00101195:
MOV EAX,0x0
RET | int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (param_2 < 1) {
return 1;
}
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*param_1 < param_3) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return 1;
} |
4,630 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int list[], int count, int num) {
for (int i = 0; i < count; i++) {
if (list[i] < num) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {220, 330, 500};
int arr2[] = {12, 17, 21};
int arr3[] = {1, 2, 3, 4};
assert(func0(arr1, 3, 200) == true);
assert(func0(arr2, 3, 20) == false);
assert(func0(arr3, 4, 10) == false);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
cmp %edx,(%rdi)
jge 1158 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%... | func0:
endbr64
test esi, esi
jle short loc_1170
lea eax, [rsi-1]
lea rax, [rdi+rax*4+4]
jmp short loc_1161
loc_1158:
add rdi, 4
cmp rdi, rax
jz short loc_1170
loc_1161:
cmp [rdi], edx
jge short loc_1158
xor eax, eax
retn
loc_1170:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2, int a3)
{
long long v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = (long long)&a1[a2 - 1 + 1];
while ( *a1 >= a3 )
{
if ( ++a1 == (_DWORD *)v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
LEA EAX,[RSI + -0x1]
LEA RAX,[RDI + RAX*0x4 + 0x4]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101170
LAB_00101161:
CMP dword ptr [RDI],EDX
JGE 0x00101158
XOR EAX,EAX
RET
LAB_00101170:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
if (*param_1 < param_3) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 1;
} |
4,631 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int list[], int count, int num) {
for (int i = 0; i < count; i++) {
if (list[i] < num) {
return false;
}
}
return true;
}
| int main() {
int arr1[] = {220, 330, 500};
int arr2[] = {12, 17, 21};
int arr3[] = {1, 2, 3, 4};
assert(func0(arr1, 3, 200) == true);
assert(func0(arr2, 3, 20) == false);
assert(func0(arr3, 4, 10) == false);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rax
jmp 1161 <func0+0x21>
nopw 0x0(%rax,%rax,1)
add $0x4,%rdi
cmp %rax,%rdi
je 1170 <func0+0x30>
cmp %edx,(%rdi)
jge 1158 <func0+0x18>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%... | func0:
endbr64
test esi, esi
jle short loc_1170
movsxd rsi, esi
lea rax, [rdi+rsi*4]
jmp short loc_1161
loc_1158:
add rdi, 4
cmp rdi, rax
jz short loc_1170
loc_1161:
cmp [rdi], edx
jge short loc_1158
xor eax, eax
retn
loc_1170:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
if ( a2 <= 0 )
return 1LL;
v3 = &a1[a2];
while ( *a1 >= a3 )
{
if ( ++a1 == v3 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
MOVSXD RSI,ESI
LEA RAX,[RDI + RSI*0x4]
JMP 0x00101161
LAB_00101158:
ADD RDI,0x4
CMP RDI,RAX
JZ 0x00101170
LAB_00101161:
CMP dword ptr [RDI],EDX
JGE 0x00101158
XOR EAX,EAX
RET
LAB_00101170:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
if (0 < param_2) {
piVar1 = param_1 + param_2;
do {
if (*param_1 < param_3) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return 1;
} |
4,632 | func0 |
#include <assert.h>
#include <stdio.h>
| double* func0(double a, double b, double c) {
static double focus[2];
focus[0] = -b / (2 * a);
focus[1] = ((4 * a * c) - (b * b) + 1) / (4 * a);
return focus;
}
| int main() {
double *result;
result = func0(5, 3, 2);
assert(result[0] == -0.3);
assert(result[1] == 1.6);
result = func0(9, 8, 4);
assert(result[0] == -0.4444444444444444);
assert(result[1] == 2.25);
result = func0(2, 4, 6);
assert(result[0] == -1.0);
assert(resu... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x8(%rbp)
movsd %xmm1,-0x10(%rbp)
movsd %xmm2,-0x18(%rbp)
movsd -0x10(%rbp),%xmm0
movq 0xf63(%rip),%xmm1
xorpd %xmm0,%xmm1
movsd -0x8(%rbp),%xmm0
addsd %xmm0,%xmm0
divsd %xmm0,%xmm1
movapd %xmm1,%xmm0
movsd %xmm0,0x2e76(%rip)
movsd -0x8(%rbp),%xmm1
mo... | func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_8], xmm0
movsd [rbp+var_10], xmm1
movsd [rbp+var_18], xmm2
movsd xmm0, [rbp+var_10]
movq xmm1, cs:qword_20E0
xorpd xmm1, xmm0
movsd xmm0, [rbp+var_8]
movapd xmm2, xmm0
addsd xmm2, xmm0
divsd xmm1, xmm2
movapd xmm0, xmm1
movsd cs:focus_1, ... | long long * func0(double a1, double a2, double a3)
{
*(double *)&focus_1 = -a2 / (a1 + a1);
*(double *)&qword_4028 = (4.0 * a1 * a3 - a2 * a2 + 1.0) / (4.0 * a1);
return &focus_1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD qword ptr [RBP + -0x10],XMM1
MOVSD qword ptr [RBP + -0x18],XMM2
MOVSD XMM0,qword ptr [RBP + -0x10]
MOVQ XMM1,qword ptr [0x001020e0]
XORPD XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
MOVAPD XMM2,XMM0
ADDSD XMM2,XMM0
DIVSD XMM1,XMM2
MOVAPD XMM0,X... | int1 * func0(double param_1,double param_2,double param_3)
{
focus_1._0_8_ = (double)(DAT_001020e0 ^ (ulong)param_2) / (param_1 + param_1);
focus_1._8_8_ =
(DAT_001020f8 + (DAT_001020f0 * param_1 * param_3 - param_2 * param_2)) /
(DAT_001020f0 * param_1);
return focus_1;
} |
4,633 | func0 |
#include <assert.h>
#include <stdio.h>
| double* func0(double a, double b, double c) {
static double focus[2];
focus[0] = -b / (2 * a);
focus[1] = ((4 * a * c) - (b * b) + 1) / (4 * a);
return focus;
}
| int main() {
double *result;
result = func0(5, 3, 2);
assert(result[0] == -0.3);
assert(result[1] == 1.6);
result = func0(9, 8, 4);
assert(result[0] == -0.4444444444444444);
assert(result[1] == 2.25);
result = func0(2, 4, 6);
assert(result[0] == -1.0);
assert(resu... | O1 | c | func0:
endbr64
movapd %xmm1,%xmm3
xorpd 0xed7(%rip),%xmm3
movapd %xmm0,%xmm4
addsd %xmm0,%xmm4
divsd %xmm4,%xmm3
movsd %xmm3,0x2eb3(%rip)
mulsd 0xecb(%rip),%xmm0
mulsd %xmm0,%xmm2
mulsd %xmm1,%xmm1
subsd %xmm1,%xmm2
addsd 0xebf(%rip),%xmm2
divsd %xmm0,%xmm2
movsd %xmm2,0x2e93(%rip)
lea 0x2e84(%rip),%rax
r... | func0:
endbr64
movapd xmm3, xmm1
xorpd xmm3, cs:xmmword_2030
movapd xmm4, xmm0
addsd xmm4, xmm0
divsd xmm3, xmm4
movsd cs:focus_1, xmm3
mulsd xmm0, cs:qword_2040
mulsd xmm2, xmm0
mulsd xmm1, xmm1
subsd xmm2, xmm1
addsd xmm2, cs:qword_2048
divsd xmm2, xmm0
movsd cs:qword_4028, xmm2
lea rax, f... | long long * func0(double a1, double a2, double a3)
{
*(double *)&focus_1 = -a2 / (a1 + a1);
*(double *)&qword_4028 = (a3 * (a1 * 4.0) - a2 * a2 + 1.0) / (a1 * 4.0);
return &focus_1;
} | func0:
ENDBR64
MOVAPD XMM3,XMM1
XORPD XMM3,xmmword ptr [0x00102030]
MOVAPD XMM4,XMM0
ADDSD XMM4,XMM0
DIVSD XMM3,XMM4
MOVSD qword ptr [0x00104020],XMM3
MULSD XMM0,qword ptr [0x00102040]
MULSD XMM2,XMM0
MULSD XMM1,XMM1
SUBSD XMM2,XMM1
ADDSD XMM2,qword ptr [0x00102048]
DIVSD XMM2,XMM0
MOVSD qword ptr [0x00104028],XMM2
LEA... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 * func0(double param_1,double param_2,double param_3)
{
focus_1._0_8_ = (double)((ulong)param_2 ^ _DAT_00102030) / (param_1 + param_1);
focus_1._8_8_ =
((param_3 * param_1 * _DAT_00102040 - param_2 * param_2) + _DAT_0... |
4,634 | func0 |
#include <assert.h>
#include <stdio.h>
| double* func0(double a, double b, double c) {
static double focus[2];
focus[0] = -b / (2 * a);
focus[1] = ((4 * a * c) - (b * b) + 1) / (4 * a);
return focus;
}
| int main() {
double *result;
result = func0(5, 3, 2);
assert(result[0] == -0.3);
assert(result[1] == 1.6);
result = func0(9, 8, 4);
assert(result[0] == -0.4444444444444444);
assert(result[1] == 2.25);
result = func0(2, 4, 6);
assert(result[0] == -1.0);
assert(resu... | O2 | c | func0:
endbr64
movapd %xmm0,%xmm4
movapd %xmm1,%xmm3
xorpd 0xe8c(%rip),%xmm3
addsd %xmm0,%xmm4
mulsd %xmm1,%xmm1
lea 0x2e6d(%rip),%rax
mulsd 0xe85(%rip),%xmm0
divsd %xmm4,%xmm3
mulsd %xmm0,%xmm2
subsd %xmm1,%xmm2
addsd 0xe79(%rip),%xmm2
divsd %xmm0,%xmm2
movsd %xmm3,0x2e45(%rip)
movsd %xmm2,0x2e45(%rip)
r... | func0:
endbr64
movapd xmm4, xmm0
movapd xmm3, xmm1
xorpd xmm3, cs:xmmword_2030
addsd xmm4, xmm0
mulsd xmm1, xmm1
lea rax, focus_1
mulsd xmm0, cs:qword_2040
divsd xmm3, xmm4
mulsd xmm2, xmm0
subsd xmm2, xmm1
addsd xmm2, cs:qword_2048
divsd xmm2, xmm0
movsd cs:focus_1, xmm3
movsd cs:qword_4028... | long long * func0(double a1, double a2, double a3)
{
long long *result; // rax
result = &focus_1;
*(double *)&focus_1 = -a2 / (a1 + a1);
*(double *)&qword_4028 = (a3 * (a1 * 4.0) - a2 * a2 + 1.0) / (a1 * 4.0);
return result;
} | func0:
ENDBR64
MOVAPD XMM4,XMM0
MOVAPD XMM3,XMM1
XORPD XMM3,xmmword ptr [0x00102030]
ADDSD XMM4,XMM0
MULSD XMM1,XMM1
LEA RAX,[0x104020]
MULSD XMM0,qword ptr [0x00102040]
DIVSD XMM3,XMM4
MULSD XMM2,XMM0
SUBSD XMM2,XMM1
ADDSD XMM2,qword ptr [0x00102048]
DIVSD XMM2,XMM0
MOVSD qword ptr [0x00104020],XMM3
MOVSD qword ptr [0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 * func0(double param_1,double param_2,double param_3)
{
focus_1._0_8_ = (double)((ulong)param_2 ^ _DAT_00102030) / (param_1 + param_1);
focus_1._8_8_ =
((param_3 * param_1 * _DAT_00102040 - param_2 * param_2) + _DAT_0... |
4,635 | func0 |
#include <assert.h>
#include <stdio.h>
| double* func0(double a, double b, double c) {
static double focus[2];
focus[0] = -b / (2 * a);
focus[1] = ((4 * a * c) - (b * b) + 1) / (4 * a);
return focus;
}
| int main() {
double *result;
result = func0(5, 3, 2);
assert(result[0] == -0.3);
assert(result[1] == 1.6);
result = func0(9, 8, 4);
assert(result[0] == -0.4444444444444444);
assert(result[1] == 2.25);
result = func0(2, 4, 6);
assert(result[0] == -1.0);
assert(resu... | O3 | c | func0:
endbr64
movapd %xmm0,%xmm4
movapd %xmm1,%xmm3
xorpd 0xe9c(%rip),%xmm3
addsd %xmm0,%xmm4
mulsd %xmm1,%xmm1
lea 0x2e7d(%rip),%rax
mulsd 0xea5(%rip),%xmm0
divsd %xmm4,%xmm3
mulsd %xmm0,%xmm2
subsd %xmm1,%xmm2
addsd 0xe99(%rip),%xmm2
divsd %xmm0,%xmm2
movsd %xmm3,0x2e55(%rip)
movsd %xmm2,0x2e55(%rip)
r... | func0:
endbr64
unpcklpd xmm0, xmm0
movapd xmm4, xmm1
xorpd xmm4, cs:xmmword_2040
mulpd xmm0, cs:xmmword_2030
lea rax, focus_1
mulsd xmm1, xmm1
movapd xmm5, xmm0
unpckhpd xmm5, xmm5
movapd xmm3, xmm5
mulsd xmm3, xmm2
subsd xmm3, xmm1
addsd xmm3, cs:qword_2060
movapd xmm1, xmm4
unpcklpd xmm1, xmm3
div... | __int128 * func0(__m128d a1, __m128d a2, double a3)
{
__m128d v3; // xmm0
__int128 *result; // rax
__m128d v5; // xmm5
__m128d v6; // xmm3
v3 = _mm_mul_pd(_mm_unpacklo_pd(a1, a1), (__m128d)xmmword_2030);
result = &focus_1;
v5 = _mm_unpackhi_pd(v3, v3);
v6.m128d_f64[1] = v5.m128d_f64[1];
v6.m128d_f64[... | func0:
ENDBR64
UNPCKLPD XMM0,XMM0
MOVAPD XMM4,XMM1
XORPD XMM4,xmmword ptr [0x00102040]
MULPD XMM0,xmmword ptr [0x00102030]
LEA RAX,[0x104020]
MULSD XMM1,XMM1
MOVAPD XMM5,XMM0
UNPCKHPD XMM5,XMM5
MOVAPD XMM3,XMM5
MULSD XMM3,XMM2
SUBSD XMM3,XMM1
ADDSD XMM3,qword ptr [0x00102060]
MOVAPD XMM1,XMM4
UNPCKLPD XMM1,XMM3
DIVPD X... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 * func0(double param_1,double param_2,double param_3)
{
int auVar1 [16];
int auVar2 [16];
auVar2._8_8_ = (param_1 * _UNK_00102038 * param_3 - param_2 * param_2) + _DAT_00102060;
auVar2._0_8_ = (ulong)param_2 ^ _DAT_00... |
4,636 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char * func0(const char *text, const char *pattern) {
regex_t regex;
int reti;
reti = regcomp(®ex, pattern, 0);
if (reti) {
return ("Regex compilation failed!");
}
reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!reti) {
return ("Matched!");
... | int main() {
// Test the function implementation
assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "fox"), "Matched!") == 0);
assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "horse"), "Not Matched!") == 0);
assert(strcmp(func0("The quick brown fox jumps over the... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x70(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x0,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10f0 <regcomp@plt>
mov %eax,-0x54(%rbp)
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov [rbp+pattern], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 0; cflags
mov rsi, rcx; pattern
mov rdi, rax; preg
call _regcomp
mov ... | const char * func0(const char *a1, const char *a2)
{
int v3; // [rsp+1Ch] [rbp-54h]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v5; // [rsp+68h] [rbp-8h]
v5 = __readfsqword(0x28u);
if ( regcomp(&preg, a2, 0) )
return "Regex compilation failed!";
v3 = regexec(&preg, a1, 0LL, 0LL, 0);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RCX,qword ptr [RBP + -0x70]
LEA RAX,[RBP + -0x50]
MOV EDX,0x0
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010f0
MOV dword ptr [RBP + -0x54],EA... | char * func0(char *param_1,char *param_2)
{
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,param_2,0);
if (iVar1 == 0) {
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local... |
4,637 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char * func0(const char *text, const char *pattern) {
regex_t regex;
int reti;
reti = regcomp(®ex, pattern, 0);
if (reti) {
return ("Regex compilation failed!");
}
reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!reti) {
return ("Matched!");
... | int main() {
// Test the function implementation
assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "fox"), "Matched!") == 0);
assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "horse"), "Not Matched!") == 0);
assert(strcmp(func0("The quick brown fox jumps over the... | 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 $0x0,%edx
callq 10e0 <regcomp@plt>
mov %eax,%edx
lea 0xde8(%rip),%rax
test %edx,%edx
je 1237 <func0+0x4e>
mov 0x48(%rsp),%rcx
xor %fs:0x28,%rc... | 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, 0
call _regcomp
mov edx, eax
lea rax, aRegexCompilati; "Regex compilation failed!"
test edx, edx
jz short loc_1257
loc_1240:
mov ... | char * func0(long long a1, long long a2)
{
int v2; // edx
char *result; // rax
int v4; // ebx
_QWORD v5[13]; // [rsp+0h] [rbp-68h] BYREF
v5[9] = __readfsqword(0x28u);
v2 = regcomp(v5, a2, 0LL);
result = "Regex compilation failed!";
if ( !v2 )
{
v4 = regexec(v5, a1, 0LL, 0LL, 0LL);
regfree(v5)... | 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,0x0
CALL 0x001010f0
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JZ 0x00101257
LAB_00101240:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101295
ADD R... | char * func0(char *param_1,char *param_2)
{
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,param_2,0);
pcVar2 = "Regex compilation failed!";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1... |
4,638 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char * func0(const char *text, const char *pattern) {
regex_t regex;
int reti;
reti = regcomp(®ex, pattern, 0);
if (reti) {
return ("Regex compilation failed!");
}
reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!reti) {
return ("Matched!");
... | int main() {
// Test the function implementation
assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "fox"), "Matched!") == 0);
assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "horse"), "Not Matched!") == 0);
assert(strcmp(func0("The quick brown fox jumps over the... | O2 | c | func0:
endbr64
push %r12
xor %edx,%edx
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 10e0 <regcomp@plt>
mov %eax,%r8d
lea 0xcdf(%rip),%rax
test %r8d,%r8d
jne 1357 <func0+0x67>
xor %edx,%edx
xor %... | func0:
endbr64
push r12
xor edx, edx
mov r12, rdi
push rbp
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
mov r8d, eax
lea rax, aRegexCompilati; "Regex compilation failed!"
test r8d, r8d
jnz short loc_1369
... | char * func0(long long a1, long long a2)
{
int v2; // r8d
char *result; // rax
int v4; // r12d
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
v2 = regcomp(_0, a2, 0LL);
result = "Regex compilation failed!";
if ( !v2 )
{
v4 = regexec(_0, a1, 0LL, 0LL);
regfree(_0);
... | func0:
ENDBR64
PUSH R12
XOR EDX,EDX
MOV R12,RDI
PUSH RBP
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 0x001010f0
MOV R8D,EAX
LEA RAX,[0x102004]
TEST R8D,R8D
JNZ 0x00101369
XOR EDX,EDX
XOR ECX,ECX
MOV RSI,R12
MOV RDI,RBP
CALL 0x00101110
MOV RDI,RBP
MOV ... | char * func0(char *param_1,char *param_2)
{
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,param_2,0);
pcVar2 = "Regex compilation failed!";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1... |
4,639 | func0 | #include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
| char * func0(const char *text, const char *pattern) {
regex_t regex;
int reti;
reti = regcomp(®ex, pattern, 0);
if (reti) {
return ("Regex compilation failed!");
}
reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!reti) {
return ("Matched!");
... | int main() {
// Test the function implementation
assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "fox"), "Matched!") == 0);
assert(strcmp(func0("The quick brown fox jumps over the lazy dog.", "horse"), "Not Matched!") == 0);
assert(strcmp(func0("The quick brown fox jumps over the... | O3 | c | func0:
endbr64
push %r12
xor %edx,%edx
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 10e0 <regcomp@plt>
mov %eax,%r8d
lea 0xcdf(%rip),%rax
test %r8d,%r8d
jne 1357 <func0+0x67>
xor %edx,%edx
xor %... | func0:
endbr64
push rbp
xor edx, edx; cflags
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
mov edx, eax
lea rax, aRegexCompilati; "Regex compilation failed!"
test edx, edx
jnz s... | const char * func0(char *string, const char *a2)
{
int v2; // edx
const char *result; // rax
int v4; // ebx
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
v2 = regcomp(&_0, a2, 0);
result = "Regex compilation failed!";
if ( !v2 ... | func0:
ENDBR64
PUSH RBP
XOR EDX,EDX
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 0x001010f0
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JNZ 0x00101367
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x00101110
MOV ... | char * func0(char *param_1,char *param_2)
{
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,param_2,0);
pcVar2 = "Regex compilation failed!";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1... |
4,640 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (m == 0 || n == 0) {
return 0;
} else if (X[m-1] == Y[n-1]) {
return 1 + func0(X, Y, m-1, n-1);
} else {
int left = func0(X, Y, m, n-1);
int right = func0(X, Y, m-1, n);
return (left > right) ? left : ... | int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 4);
assert(func0("ABCDGH", "AEDFHR", 6, 6) == 3);
assert(func0("AXYT", "AYZX", 4, 4) == 2);
printf("All test cases passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %ecx,-0x28(%rbp)
cmpl $0x0,-0x24(%rbp)
je 118f <func0+0x26>
cmpl $0x0,-0x28(%rbp)
jne 1199 <func0+0x30>
mov $0x0,%eax
jmpq 122a <func0+0xc1>
mov -0x24(%rbp),%ea... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_28], ecx
cmp [rbp+var_24], 0
jz short loc_118F
cmp [rbp+var_28], 0
jnz short loc_1199
loc_118F:
mov eax, 0
jmp locret_122B
loc_1199:
mov ... | long long func0(long long a1, long long a2, unsigned int a3, unsigned int a4)
{
long long result; // rax
unsigned int v5; // edx
unsigned int v8; // [rsp+28h] [rbp-8h]
if ( !a3 || !a4 )
return 0LL;
if ( *(_BYTE *)((int)a3 - 1LL + a1) == *(_BYTE *)((int)a4 - 1LL + a2) )
return (unsigned int)func0(a1,... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0x28],ECX
CMP dword ptr [RBP + -0x24],0x0
JZ 0x0010118f
CMP dword ptr [RBP + -0x28],0x0
JNZ 0x00101199
LAB_0010118f:
MOV EAX,0x0
JMP 0x0010122b
LAB_00101... | int func0(long param_1,long param_2,int param_3,int param_4)
{
int iVar1;
int iVar2;
if ((param_3 == 0) || (param_4 == 0)) {
iVar1 = 0;
}
else if (*(char *)(param_1 + (long)param_3 + -1) == *(char *)(param_2 + (long)param_4 + -1)) {
iVar1 = func0(param_1,param_2,param_3 + -1,param_4 + -1);
iVa... |
4,641 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (m == 0 || n == 0) {
return 0;
} else if (X[m-1] == Y[n-1]) {
return 1 + func0(X, Y, m-1, n-1);
} else {
int left = func0(X, Y, m, n-1);
int right = func0(X, Y, m-1, n);
return (left > right) ? left : ... | int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 4);
assert(func0("ABCDGH", "AEDFHR", 6, 6) == 3);
assert(func0("AXYT", "AYZX", 4, 4) == 2);
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
je 11e3 <func0+0x7a>
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %rsi,%r13
mov %edx,%ebx
mov %ecx,%ebp
test %ecx,%ecx
je 11dc <func0+0x73>
movslq %edx,%rax
movslq %ecx,%rdx
movzbl -0x1(%rsi,%rdx,1),%esi
cmp %sil,-0x1(%rdi,%rax,1)... | func0:
endbr64
test edx, edx
jz short loc_11E3
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r13, rsi
mov ebx, edx
mov ebp, ecx
test ecx, ecx
jz short loc_11DC
movsxd rax, edx
movsxd rdx, ecx
movzx esi, byte ptr [rsi+rdx-1]
cmp [rdi+rax-1], sil
jz ... | long long func0(long long a1, long long a2, unsigned int a3, unsigned int a4)
{
int v6; // r14d
long long result; // rax
if ( !a3 )
return 0LL;
if ( !a4 )
return 0LL;
if ( *(_BYTE *)(a1 + (int)a3 - 1) == *(_BYTE *)(a2 + (int)a4 - 1) )
return (unsigned int)func0(a1, a2, a3 - 1, a4 - 1) + 1;
v6 ... | func0:
ENDBR64
TEST EDX,EDX
JZ 0x001011e3
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R13,RSI
MOV EBX,EDX
MOV EBP,ECX
TEST ECX,ECX
JZ 0x001011dc
MOVSXD RAX,EDX
MOVSXD RDX,ECX
MOVZX ESI,byte ptr [RSI + RDX*0x1 + -0x1]
CMP byte ptr [RDI + RAX*0x1 + -0x1],SIL
JZ 0x001011c9
LEA ECX,[RCX + -0x1]
MOV EDX,EBX... | int func0(long param_1,long param_2,int param_3,int param_4)
{
int iVar1;
int iVar2;
if (param_3 != 0) {
if (param_4 == 0) {
iVar2 = 0;
}
else if (*(char *)(param_1 + -1 + (long)param_3) == *(char *)(param_2 + -1 + (long)param_4)) {
iVar2 = func0(param_1,param_2,param_3 + -1,param_4 + ... |
4,642 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (m == 0 || n == 0) {
return 0;
} else if (X[m-1] == Y[n-1]) {
return 1 + func0(X, Y, m-1, n-1);
} else {
int left = func0(X, Y, m, n-1);
int right = func0(X, Y, m-1, n);
return (left > right) ? left : ... | int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 4);
assert(func0("ABCDGH", "AEDFHR", 6, 6) == 3);
assert(func0("AXYT", "AYZX", 4, 4) == 2);
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r15
movslq %ecx,%rax
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %eax,%eax
je 12fd <func0+0xad>
mov %edx,%r12d
test %edx,%edx
je 12fd <func0+0xad>
movslq %edx,%r8
lea -0x1(%rax),%ecx
mov %rdi,%r14
mov %rsi,%rbp
sub %rax,%r8
movslq %... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
test ecx, ecx
jz loc_12FE
mov r12d, edx
test edx, edx
jz loc_12FE
lea eax, [rcx-1]
mov rbp, rsi
movsxd rcx, ecx
movsxd rsi, edx
sub rsi, rcx
mov r14, rdi
cdqe
xor r13d, r13d
ad... | long long func0(long long a1, long long a2, unsigned int a3, int a4)
{
unsigned int v4; // r12d
long long v6; // rax
unsigned int v7; // r13d
long long v8; // rsi
bool v9; // cl
long long v10; // rdx
unsigned int v11; // r15d
int v12; // ebx
int v13; // eax
if ( a4 && (v4 = a3) != 0 )
{
v6 =... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ECX,ECX
JZ 0x001012fe
MOV R12D,EDX
TEST EDX,EDX
JZ 0x001012fe
LEA EAX,[RCX + -0x1]
MOV RBP,RSI
MOVSXD RCX,ECX
MOVSXD RSI,EDX
SUB RSI,RCX
MOV R14,RDI
CDQE
XOR R13D,R13D
ADD RSI,RDI
JMP 0x001012af
LAB_00101298:
ADD R13D,0x1
TEST R12D,R1... | int func0(long param_1,long param_2,int param_3,int param_4)
{
int iVar1;
int iVar2;
ulong uVar3;
int iVar4;
int iVar5;
if ((param_4 == 0) || (param_3 == 0)) {
iVar5 = 0;
}
else {
uVar3 = (ulong)(param_4 + -1);
iVar5 = 0;
iVar1 = param_3;
do {
iVar2 = (int)uVar3;
iVar... |
4,643 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (m == 0 || n == 0) {
return 0;
} else if (X[m-1] == Y[n-1]) {
return 1 + func0(X, Y, m-1, n-1);
} else {
int left = func0(X, Y, m, n-1);
int right = func0(X, Y, m-1, n);
return (left > right) ? left : ... | int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 4);
assert(func0("ABCDGH", "AEDFHR", 6, 6) == 3);
assert(func0("AXYT", "AYZX", 4, 4) == 2);
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r15
movslq %ecx,%rax
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
test %eax,%eax
je 12fd <func0+0xad>
mov %edx,%r12d
test %edx,%edx
je 12fd <func0+0xad>
movslq %edx,%r8
lea -0x1(%rax),%ecx
mov %rdi,%r14
mov %rsi,%rbp
sub %rax,%r8
movslq %... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_98], rdi
test edx, edx
jz loc_1B87
test ecx, ecx
jz loc_1B87
mov rax, rdi
lea ebp, [rcx-1]
movsxd rdi, edx
movsxd rcx, ecx
sub rdi, rcx
mov ebx, edx
movsxd rbp,... | long long func0(long long a1, long long a2, unsigned int a3, int a4)
{
unsigned int v4; // ebx
long long v5; // rbp
unsigned int v6; // r13d
long long v7; // rdi
unsigned int v8; // r14d
char v9; // al
char v10; // r12
bool v11; // cl
int v12; // r9d
long long v13; // r15
long long v14; // rdi
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP],RDI
TEST EDX,EDX
JZ 0x00101b87
TEST ECX,ECX
JZ 0x00101b87
MOV RAX,RDI
LEA EBP,[RCX + -0x1]
MOVSXD RDI,EDX
MOVSXD RCX,ECX
SUB RDI,RCX
MOV EBX,EDX
MOVSXD RBP,EBP
XOR R13D,R13D
ADD RDI,RAX
JMP 0x001012b0
LAB_00101298:
ADD... | int func0(long param_1,long param_2,int param_3,int param_4)
{
char cVar1;
char cVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
ulong uVar7;
ulong uVar8;
int iVar9;
long lVar10;
int iVar11;
int iVar12;
int iVar13;
uint uVar14;
int iVar15;
char cVar16;
int iVar17;
int iVar18;
in... |
4,644 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
for (int i = 2; i <= n; i++) {
if (i * i < (n + 1)) {
for (int j = 2; j <= n; j++) {
if ((i * i * j * j) == n) {
return true;
}
}
}
}
return false;
}
| int main() {
assert(func0(25) == false);
assert(func0(30) == false);
assert(func0(16) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x2,-0x8(%rbp)
jmp 119b <func0+0x52>
mov -0x8(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jl 1197 <func0+0x4e>
movl $0x2,-0x4(%rbp)
jmp 118f <func0+0x46>
mov -0x8(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax
imul... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 2
jmp short loc_119B
loc_115D:
mov eax, [rbp+var_8]
imul eax, eax
cmp [rbp+var_14], eax
jl short loc_1197
mov [rbp+var_4], 2
jmp short loc_118F
loc_1171:
mov eax, [rbp+var_8]
imul eax, eax
imul ... | long long func0(int a1)
{
int i; // [rsp+Ch] [rbp-8h]
int j; // [rsp+10h] [rbp-4h]
for ( i = 2; i <= a1; ++i )
{
if ( a1 >= i * i )
{
for ( j = 2; j <= a1; ++j )
{
if ( a1 == j * j * i * i )
return 1LL;
}
}
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x2
JMP 0x0010119b
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x14],EAX
JL 0x00101197
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0010118f
LAB_00101171:
MOV EAX,dword ptr [RBP + -0x8]
IMUL EAX,EA... | int8 func0(int param_1)
{
int local_10;
int local_c;
local_10 = 2;
do {
if (param_1 < local_10) {
return 0;
}
if (local_10 * local_10 <= param_1) {
for (local_c = 2; local_c <= param_1; local_c = local_c + 1) {
if (param_1 == local_10 * local_10 * local_c * local_c) {
... |
4,645 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
for (int i = 2; i <= n; i++) {
if (i * i < (n + 1)) {
for (int j = 2; j <= n; j++) {
if ((i * i * j * j) == n) {
return true;
}
}
}
}
return false;
}
| int main() {
assert(func0(25) == false);
assert(func0(30) == false);
assert(func0(16) == true);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%edi
jle 119e <func0+0x55>
mov $0x2,%ecx
jmp 1160 <func0+0x17>
add $0x1,%ecx
cmp %ecx,%edi
jl 1198 <func0+0x4f>
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 1159 <func0+0x10>
lea 0x0(,%rax,4),%edx
cmp %edx,%edi
je 11a4 <func0+0x5b>
mov %eax,%r8d
le... | func0:
endbr64
cmp edi, 1
jle short loc_119D
mov esi, 2
jmp short loc_1160
loc_1159:
add esi, 1
cmp edi, esi
jl short loc_1197
loc_1160:
mov ecx, esi
imul ecx, esi
cmp ecx, edi
jg short loc_1159
lea eax, ds:0[rcx*4]
cmp edi, eax
jz short loc_11A3
lea edx, [r... | long long func0(int a1)
{
int v1; // esi
int v2; // ecx
int v3; // edx
int v4; // eax
int v5; // r8d
if ( a1 <= 1 )
return 0LL;
v1 = 2;
while ( 1 )
{
v2 = v1 * v1;
if ( v1 * v1 <= a1 )
break;
LABEL_3:
if ( a1 < ++v1 )
return 0LL;
}
if ( a1 != 4 * v2 )
{
v3 = 3 *... | func0:
ENDBR64
CMP EDI,0x1
JLE 0x0010119d
MOV ESI,0x2
JMP 0x00101160
LAB_00101159:
ADD ESI,0x1
CMP EDI,ESI
JL 0x00101197
LAB_00101160:
MOV ECX,ESI
IMUL ECX,ESI
CMP ECX,EDI
JG 0x00101159
LEA EAX,[RCX*0x4]
CMP EDI,EAX
JZ 0x001011a3
LEA EDX,[RCX + RCX*0x2]
MOV EAX,0x2
LAB_0010117c:
ADD EAX,0x1
CMP EDI,EAX
JL 0x00101159
MO... | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_1 < 2) {
return 0;
}
iVar4 = 2;
do {
iVar2 = iVar4 * iVar4;
if (iVar2 <= param_1) {
if (param_1 == iVar2 * 4) {
return 1;
}
iVar3 = iVar2 * 3;
iVar1 = 2;
whi... |
4,646 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
for (int i = 2; i <= n; i++) {
if (i * i < (n + 1)) {
for (int j = 2; j <= n; j++) {
if ((i * i * j * j) == n) {
return true;
}
}
}
}
return false;
}
| int main() {
assert(func0(25) == false);
assert(func0(30) == false);
assert(func0(16) == true);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%edi
jle 1278 <func0+0x58>
mov $0x2,%ecx
jmp 1237 <func0+0x17>
add $0x1,%ecx
cmp %ecx,%edi
jl 1278 <func0+0x58>
mov %ecx,%esi
imul %ecx,%esi
cmp %edi,%esi
jg 1230 <func0+0x10>
lea 0x0(,%rsi,4),%eax
cmp %eax,%edi
je 126d <func0+0x4d>
lea (%rsi,%rsi,2... | func0:
endbr64
cmp edi, 1
jle short loc_1248
mov ecx, 2
jmp short loc_1207
loc_1200:
add ecx, 1
cmp edi, ecx
jl short loc_1248
loc_1207:
mov esi, ecx
imul esi, ecx
cmp esi, edi
jg short loc_1200
lea eax, ds:0[rsi*4]
cmp edi, eax
jz short loc_123D
lea edx, [r... | long long func0(int a1)
{
int v1; // ecx
int v2; // esi
int v3; // edx
int v4; // eax
if ( a1 <= 1 )
return 0LL;
v1 = 2;
while ( 1 )
{
v2 = v1 * v1;
if ( v1 * v1 <= a1 )
break;
LABEL_3:
if ( a1 < ++v1 )
return 0LL;
}
if ( a1 != 4 * v2 )
{
v3 = 3 * v2;
v4 = 3;
... | func0:
ENDBR64
CMP EDI,0x1
JLE 0x00101248
MOV ECX,0x2
JMP 0x00101207
LAB_00101200:
ADD ECX,0x1
CMP EDI,ECX
JL 0x00101248
LAB_00101207:
MOV ESI,ECX
IMUL ESI,ECX
CMP ESI,EDI
JG 0x00101200
LEA EAX,[RSI*0x4]
CMP EDI,EAX
JZ 0x0010123d
LEA EDX,[RSI + RSI*0x2]
MOV EAX,0x3
JMP 0x00101231
LAB_00101228:
ADD EAX,0x1
ADD EDX,ESI
C... | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (1 < param_1) {
iVar2 = 2;
do {
iVar4 = iVar2 * iVar2;
if (iVar4 <= param_1) {
if (param_1 == iVar4 * 4) {
return 1;
}
iVar3 = iVar4 * 3;
iVar1 = 3;
do {
... |
4,647 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
for (int i = 2; i <= n; i++) {
if (i * i < (n + 1)) {
for (int j = 2; j <= n; j++) {
if ((i * i * j * j) == n) {
return true;
}
}
}
}
return false;
}
| int main() {
assert(func0(25) == false);
assert(func0(30) == false);
assert(func0(16) == true);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%edi
jle 1278 <func0+0x58>
mov $0x2,%ecx
jmp 1237 <func0+0x17>
add $0x1,%ecx
cmp %ecx,%edi
jl 1278 <func0+0x58>
mov %ecx,%esi
imul %ecx,%esi
cmp %edi,%esi
jg 1230 <func0+0x10>
lea 0x0(,%rsi,4),%eax
cmp %eax,%edi
je 126d <func0+0x4d>
lea (%rsi,%rsi,2... | func0:
endbr64
cmp edi, 1
jle short loc_1198
mov esi, 2
jmp short loc_1157
loc_1150:
add esi, 1
cmp edi, esi
jl short loc_1198
loc_1157:
mov ecx, esi
imul ecx, esi
cmp ecx, edi
jg short loc_1150
lea eax, ds:0[rcx*4]
cmp edi, eax
jz short loc_118D
lea edx, [r... | long long func0(int a1)
{
int i; // esi
int v2; // ecx
int v3; // edx
int v4; // eax
int v5; // r8d
if ( a1 > 1 )
{
for ( i = 2; a1 >= i; ++i )
{
v2 = i * i;
if ( i * i <= a1 )
{
if ( a1 == 4 * v2 )
return 1LL;
v3 = 3 * v2;
v4 = 2;
whil... | func0:
ENDBR64
CMP EDI,0x1
JLE 0x00101198
MOV ESI,0x2
JMP 0x00101157
LAB_00101150:
ADD ESI,0x1
CMP EDI,ESI
JL 0x00101198
LAB_00101157:
MOV ECX,ESI
IMUL ECX,ESI
CMP ECX,EDI
JG 0x00101150
LEA EAX,[RCX*0x4]
CMP EDI,EAX
JZ 0x0010118d
LEA EDX,[RCX + RCX*0x2]
MOV EAX,0x2
NOP dword ptr [RAX + RAX*0x1]
LAB_00101178:
ADD EAX,0x... | int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (1 < param_1) {
iVar4 = 2;
do {
iVar3 = iVar4 * iVar4;
if (iVar3 <= param_1) {
if (param_1 == iVar3 * 4) {
return 1;
}
iVar2 = 2;
iVar1 = iVar3 * 3;
w... |
4,648 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int ptr = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
ptr = 1;
break;
}
}
if (ptr == 0) {
return 1;
}
for (int i = 0; i < n; i++) {
if (arr[i] <= 0 || arr[i] > n) {
arr[i] = 1;
... | int main() {
int arr1[] = {1, 2, 3, -1, 5};
int arr2[] = {0, -1, -2, 1, 5, 8};
int arr3[] = {0, 1, 2, 5, -8};
assert(func0(arr1, 5) == 4);
assert(func0(arr2, 6) == 2);
assert(func0(arr3, 5) == 3);
printf("All test cases passed\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
jmp 11d0 <func0+0x47>
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0x1,%eax
jne 11cc <func0+0x43>... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_14], 0
mov [rbp+var_10], 0
jmp short loc_11D0
loc_11A8:
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
cmp eax, 1
jnz sh... | long long func0(long long a1, int a2)
{
int v3; // eax
int v4; // [rsp+18h] [rbp-14h]
int i; // [rsp+1Ch] [rbp-10h]
int j; // [rsp+20h] [rbp-Ch]
int k; // [rsp+24h] [rbp-8h]
int m; // [rsp+28h] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) == 1 )
{
v4 = 1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001011d0
LAB_001011a8:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP ... | int func0(long param_1,int param_2)
{
bool bVar1;
int iVar2;
int local_18;
int local_14;
int local_10;
int local_c;
bVar1 = false;
local_18 = 0;
do {
if (param_2 <= local_18) {
LAB_001011d8:
if (bVar1) {
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
... |
4,649 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int ptr = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
ptr = 1;
break;
}
}
if (ptr == 0) {
return 1;
}
for (int i = 0; i < n; i++) {
if (arr[i] <= 0 || arr[i] > n) {
arr[i] = 1;
... | int main() {
int arr1[] = {1, 2, 3, -1, 5};
int arr2[] = {0, -1, -2, 1, 5, 8};
int arr3[] = {0, 1, 2, 5, -8};
assert(func0(arr1, 5) == 4);
assert(func0(arr2, 6) == 2);
assert(func0(arr3, 5) == 3);
printf("All test cases passed\n");
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1215 <func0+0x8c>
mov %rdi,%rcx
lea -0x1(%rsi),%r9d
lea 0x4(%rdi,%r9,4),%r8
mov %rdi,%rax
cmpl $0x1,(%rax)
je 11b8 <func0+0x2f>
add $0x4,%rax
cmp %r8,%rax
jne 11a4 <func0+0x1b>
mov $0x1,%eax
retq
mov %rdi,%rax
jmp 11cd <func0+0x44>
movl $0x1,(... | func0:
endbr64
mov ecx, esi
test esi, esi
jle short loc_120D
mov rsi, rdi
lea eax, [rcx-1]
lea r8, [rdi+rax*4+4]
mov rax, rdi
loc_11A1:
cmp dword ptr [rax], 1
jz short loc_11B5
add rax, 4
cmp rax, r8
jnz short loc_11A1
mov eax, 1
retn
loc_11B5:
mov rax, rdi
jmp ... | long long func0(_DWORD *a1, int a2)
{
_DWORD *v3; // rsi
long long v4; // r8
_DWORD *v5; // rax
int *v7; // rax
long long v8; // rax
if ( a2 <= 0 )
return 1LL;
v3 = a1;
v4 = (long long)&a1[a2 - 1 + 1];
v5 = a1;
while ( *v5 != 1 )
{
if ( ++v5 == (_DWORD *)v4 )
return 1LL;
}
v7 =... | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x0010120d
MOV RSI,RDI
LEA EAX,[RCX + -0x1]
LEA R8,[RDI + RAX*0x4 + 0x4]
MOV RAX,RDI
LAB_001011a1:
CMP dword ptr [RAX],0x1
JZ 0x001011b5
ADD RAX,0x4
CMP RAX,R8
JNZ 0x001011a1
MOV EAX,0x1
RET
LAB_001011b5:
MOV RAX,RDI
JMP 0x001011ca
LAB_001011ba:
MOV dword ptr [R9],0x1
LAB_001... | int func0(int *param_1,uint param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
ulong uVar4;
if ((int)param_2 < 1) {
return 1;
}
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
piVar2 = param_1;
do {
piVar3 = param_1;
if (*piVar2 == 1) {
do {
if (((int)param_2 < *piVar3) || (*... |
4,650 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int ptr = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
ptr = 1;
break;
}
}
if (ptr == 0) {
return 1;
}
for (int i = 0; i < n; i++) {
if (arr[i] <= 0 || arr[i] > n) {
arr[i] = 1;
... | int main() {
int arr1[] = {1, 2, 3, -1, 5};
int arr2[] = {0, -1, -2, 1, 5, 8};
int arr3[] = {0, 1, 2, 5, -8};
assert(func0(arr1, 5) == 4);
assert(func0(arr2, 6) == 2);
assert(func0(arr3, 5) == 3);
printf("All test cases passed\n");
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1380 <func0+0xa0>
lea -0x1(%rsi),%r9d
mov %rdi,%rcx
mov %rdi,%rax
lea 0x4(%rdi,%r9,4),%r8
jmp 1309 <func0+0x29>
nopl (%rax)
add $0x4,%rax
cmp %rax,%r8
je 1380 <func0+0xa0>
cmpl $0x1,(%rax)
jne 1300 <func0+0x20>
mov %rdi,%rax
nopl 0x0(%rax)
mov ... | func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1380
lea r9d, [rcx-1]
mov rsi, rdi
mov rax, rdi
lea r8, [rdi+r9*4+4]
jmp short loc_1309
loc_1300:
add rax, 4
cmp r8, rax
jz short loc_1380
loc_1309:
cmp dword ptr [rax], 1
jnz short loc_1300
mov rax, rdi
nop dw... | long long func0(int *a1, int a2)
{
long long v3; // r9
int *v4; // rsi
int *v5; // rax
long long v6; // r8
int *v7; // rax
int v8; // eax
long long v9; // rax
unsigned int v10; // r8d
if ( a2 <= 0 )
{
return 1;
}
else
{
v3 = (unsigned int)(a2 - 1);
v4 = a1;
v5 = a1;
v6 = ... | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101380
LEA R9D,[RCX + -0x1]
MOV RSI,RDI
MOV RAX,RDI
LEA R8,[RDI + R9*0x4 + 0x4]
JMP 0x00101309
LAB_00101300:
ADD RAX,0x4
CMP R8,RAX
JZ 0x00101380
LAB_00101309:
CMP dword ptr [RAX],0x1
JNZ 0x00101300
MOV RAX,RDI
NOP dword ptr [RAX]
LAB_00101318:
MOV EDX,dword ptr [RAX]
CMP... | ulong func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
piVar3 = param_1;
do {
piVar4 = param_1;
if (*piVar3 == 1) {
do {
if ((param_2 < *piVar4) || (*... |
4,651 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int arr[], int n) {
int ptr = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
ptr = 1;
break;
}
}
if (ptr == 0) {
return 1;
}
for (int i = 0; i < n; i++) {
if (arr[i] <= 0 || arr[i] > n) {
arr[i] = 1;
... | int main() {
int arr1[] = {1, 2, 3, -1, 5};
int arr2[] = {0, -1, -2, 1, 5, 8};
int arr3[] = {0, 1, 2, 5, -8};
assert(func0(arr1, 5) == 4);
assert(func0(arr2, 6) == 2);
assert(func0(arr3, 5) == 3);
printf("All test cases passed\n");
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1350 <func0+0xa0>
lea -0x1(%rsi),%r9d
mov %rdi,%rcx
mov %rdi,%rax
lea 0x4(%rdi,%r9,4),%r8
jmp 12d9 <func0+0x29>
nopl (%rax)
add $0x4,%rax
cmp %rax,%r8
je 1350 <func0+0xa0>
cmpl $0x1,(%rax)
jne 12d0 <func0+0x20>
mov %rdi,%rax
nopl 0x0(%rax)
mov ... | func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1348
movsxd r9, ecx
mov rsi, rdi
mov rax, rdi
lea r8, [rdi+r9*4]
jmp short loc_12D9
loc_12D0:
add rax, 4
cmp r8, rax
jz short loc_1348
loc_12D9:
cmp dword ptr [rax], 1
jnz short loc_12D0
mov rax, rdi
nop dword ptr... | long long func0(int *a1, int a2)
{
int *v3; // rsi
int *v4; // rax
int *v5; // r8
int *v6; // rax
int v7; // eax
long long result; // rax
if ( a2 <= 0 )
return 1LL;
v3 = a1;
v4 = a1;
v5 = &a1[a2];
while ( *v4 != 1 )
{
if ( v5 == ++v4 )
return 1LL;
}
v6 = a1;
do
{
if (... | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101348
MOVSXD R9,ECX
MOV RSI,RDI
MOV RAX,RDI
LEA R8,[RDI + R9*0x4]
JMP 0x001012d9
LAB_001012d0:
ADD RAX,0x4
CMP R8,RAX
JZ 0x00101348
LAB_001012d9:
CMP dword ptr [RAX],0x1
JNZ 0x001012d0
MOV RAX,RDI
NOP dword ptr [RAX]
LAB_001012e8:
MOV EDX,dword ptr [RAX]
CMP ECX,EDX
JL 0... | ulong func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
bool bVar6;
if (0 < param_2) {
piVar1 = param_1 + param_2;
piVar3 = param_1;
do {
piVar4 = param_1;
if (*piVar3 == 1) {
do {
if ((param_2 < *piVar4) || (*piV... |
4,652 | func0 |
#include <assert.h>
| int func0(int x1, int y1, int x2, int y2) {
return (y2 - y1 - 1) * (x2 - x1 - 1);
}
| int main() {
assert(func0(1, 1, 4, 4) == 4);
assert(func0(1, 2, 1, 2) == 1);
assert(func0(4, 2, 6, 4) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
mov %ecx,-0x10(%rbp)
mov -0x10(%rbp),%eax
sub -0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov -0xc(%rbp),%eax
sub -0x4(%rbp),%eax
sub $0x1,%eax
imul %edx,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov [rbp+var_10], ecx
mov eax, [rbp+var_10]
sub eax, [rbp+var_8]
lea edx, [rax-1]
mov eax, [rbp+var_C]
sub eax, [rbp+var_4]
sub eax, 1
imul eax, edx
pop rbp
retn | long long func0(int a1, int a2, int a3, int a4)
{
return (unsigned int)((a4 - a2 - 1) * (a3 - a1 - 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV dword ptr [RBP + -0x10],ECX
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,dword ptr [RBP + -0x8]
LEA EDX,[RAX + -0x1]
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
I... | int func0(int param_1,int param_2,int param_3,int param_4)
{
return ((param_3 - param_1) + -1) * ((param_4 - param_2) + -1);
} |
4,653 | func0 |
#include <assert.h>
| int func0(int x1, int y1, int x2, int y2) {
return (y2 - y1 - 1) * (x2 - x1 - 1);
}
| int main() {
assert(func0(1, 1, 4, 4) == 4);
assert(func0(1, 2, 1, 2) == 1);
assert(func0(4, 2, 6, 4) == 1);
return 0;
}
| O1 | c | func0:
endbr64
sub %esi,%ecx
lea -0x1(%rcx),%eax
sub %edi,%edx
lea -0x1(%rdx),%ecx
imul %ecx,%eax
retq
| func0:
endbr64
sub ecx, esi
lea eax, [rcx-1]
sub edx, edi
sub edx, 1
imul eax, edx
retn | long long func0(int a1, int a2, int a3, int a4)
{
return (unsigned int)((a3 - a1 - 1) * (a4 - a2 - 1));
} | func0:
ENDBR64
SUB ECX,ESI
LEA EAX,[RCX + -0x1]
SUB EDX,EDI
SUB EDX,0x1
IMUL EAX,EDX
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
return ((param_4 - param_2) + -1) * ((param_3 - param_1) + -1);
} |
4,654 | func0 |
#include <assert.h>
| int func0(int x1, int y1, int x2, int y2) {
return (y2 - y1 - 1) * (x2 - x1 - 1);
}
| int main() {
assert(func0(1, 1, 4, 4) == 4);
assert(func0(1, 2, 1, 2) == 1);
assert(func0(4, 2, 6, 4) == 1);
return 0;
}
| O2 | c | func0:
endbr64
sub %esi,%ecx
sub %edi,%edx
lea -0x1(%rcx),%eax
lea -0x1(%rdx),%ecx
imul %ecx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
sub ecx, esi
sub edx, edi
lea eax, [rcx-1]
sub edx, 1
imul eax, edx
retn | long long func0(int a1, int a2, int a3, int a4)
{
return (unsigned int)((a3 - a1 - 1) * (a4 - a2 - 1));
} | func0:
ENDBR64
SUB ECX,ESI
SUB EDX,EDI
LEA EAX,[RCX + -0x1]
SUB EDX,0x1
IMUL EAX,EDX
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
return ((param_4 - param_2) + -1) * ((param_3 - param_1) + -1);
} |
4,655 | func0 |
#include <assert.h>
| int func0(int x1, int y1, int x2, int y2) {
return (y2 - y1 - 1) * (x2 - x1 - 1);
}
| int main() {
assert(func0(1, 1, 4, 4) == 4);
assert(func0(1, 2, 1, 2) == 1);
assert(func0(4, 2, 6, 4) == 1);
return 0;
}
| O3 | c | func0:
endbr64
sub %esi,%ecx
sub %edi,%edx
lea -0x1(%rcx),%eax
lea -0x1(%rdx),%ecx
imul %ecx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| func0:
endbr64
sub ecx, esi
sub edx, edi
lea eax, [rcx-1]
sub edx, 1
imul eax, edx
retn | long long func0(int a1, int a2, int a3, int a4)
{
return (unsigned int)((a3 - a1 - 1) * (a4 - a2 - 1));
} | func0:
ENDBR64
SUB ECX,ESI
SUB EDX,EDI
LEA EAX,[RCX + -0x1]
SUB EDX,0x1
IMUL EAX,EDX
RET | int func0(int param_1,int param_2,int param_3,int param_4)
{
return ((param_4 - param_2) + -1) * ((param_3 - param_1) + -1);
} |
4,656 | func0 |
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(const char *monthname3) {
if (strcmp(monthname3, "April") == 0 || strcmp(monthname3, "June") == 0 ||
strcmp(monthname3, "September") == 0 || strcmp(monthname3, "November") == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("February") == false);
assert(func0("June") == true);
assert(func0("April") == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov -0x8(%rbp),%rax
lea 0xe84(%rip),%rsi
mov %rax,%rdi
callq 1070 <strcmp@plt>
test %eax,%eax
je 11d5 <func0+0x6c>
mov -0x8(%rbp),%rax
lea 0xe73(%rip),%rsi
mov %rax,%rdi
callq 1070 <strcmp@plt>
test %eax,%ea... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+s1], rdi
mov rax, [rbp+s1]
lea rdx, s2; "April"
mov rsi, rdx; s2
mov rdi, rax; s1
call _strcmp
test eax, eax
jz short loc_11E1
mov rax, [rbp+s1]
lea rdx, aJune; "June"
mov rsi, rdx; s2
mov rdi, rax; s1
c... | _BOOL8 func0(const char *a1)
{
return !strcmp(a1, "April") || !strcmp(a1, "June") || !strcmp(a1, "September") || !strcmp(a1, "November");
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x102004]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101070
TEST EAX,EAX
JZ 0x001011e1
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x10200a]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101070
TEST EAX,EAX
JZ 0x001011e1
MOV RA... | int8 func0(char *param_1)
{
int iVar1;
iVar1 = strcmp(param_1,"April");
if ((((iVar1 != 0) && (iVar1 = strcmp(param_1,"June"), iVar1 != 0)) &&
(iVar1 = strcmp(param_1,"September"), iVar1 != 0)) &&
(iVar1 = strcmp(param_1,"November"), iVar1 != 0)) {
return 0;
}
return 1;
} |
4,657 | func0 |
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(const char *monthname3) {
if (strcmp(monthname3, "April") == 0 || strcmp(monthname3, "June") == 0 ||
strcmp(monthname3, "September") == 0 || strcmp(monthname3, "November") == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("February") == false);
assert(func0("June") == true);
assert(func0("April") == true);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rax
mov $0x6,%ecx
lea 0xea8(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
mov $0x1,%ecx
test %dl,%dl
je 11cb <func0+0x82>
mov $0x5,%ecx
lea 0xe8e(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0... | func0:
endbr64
push rbx
mov rbx, rdi
lea rsi, aApril; "April"
call _strcmp
mov edx, eax
mov eax, 1
test edx, edx
jz short loc_11D0
lea rsi, aJune; "June"
mov rdi, rbx
call _strcmp
mov edx, eax
mov eax, 1
test edx, edx
jz short loc_11D0
lea rsi, aSeptember; "S... | bool func0(long long a1)
{
int v1; // edx
bool result; // al
int v3; // edx
int v4; // edx
v1 = strcmp(a1, "April");
result = 1;
if ( v1 )
{
v3 = strcmp(a1, "June");
result = 1;
if ( v3 )
{
v4 = strcmp(a1, "September");
result = 1;
if ( v4 )
return (unsigned i... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
LEA RSI,[0x102004]
CALL 0x00101070
MOV EDX,EAX
MOV EAX,0x1
TEST EDX,EDX
JZ 0x001011d0
LEA RSI,[0x10200a]
MOV RDI,RBX
CALL 0x00101070
MOV EDX,EAX
MOV EAX,0x1
TEST EDX,EDX
JZ 0x001011d0
LEA RSI,[0x10200f]
MOV RDI,RBX
CALL 0x00101070
MOV EDX,EAX
MOV EAX,0x1
TEST EDX,EDX
JZ 0x001011d0
LE... | int8 func0(char *param_1)
{
int iVar1;
int8 uVar2;
int4 extraout_var;
iVar1 = strcmp(param_1,"April");
uVar2 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"June");
uVar2 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"September");
uVar2 = 1;
if (iVar1 != 0) {
iVar1 =... |
4,658 | func0 |
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(const char *monthname3) {
if (strcmp(monthname3, "April") == 0 || strcmp(monthname3, "June") == 0 ||
strcmp(monthname3, "September") == 0 || strcmp(monthname3, "November") == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("February") == false);
assert(func0("June") == true);
assert(func0("April") == true);
return 0;
}
| O2 | c | func0:
endbr64
mov %rdi,%rax
mov $0x6,%ecx
lea 0xe01(%rip),%rdi
mov $0x1,%r8d
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 126a <func0+0x7a>
mov $0x5,%ecx
lea 0xde6(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0... | func0:
endbr64
push r12
lea rsi, aApril; "April"
mov r12d, 1
push rbp
mov rbp, rdi
sub rsp, 8
call _strcmp
test eax, eax
jz short loc_126F
lea rsi, aJune; "June"
mov rdi, rbp
call _strcmp
test eax, eax
jz short loc_126F
lea rsi, aSeptember; "September"
mov rdi... | long long func0(long long a1)
{
unsigned int v1; // r12d
v1 = 1;
if ( (unsigned int)strcmp(a1, "April") && (unsigned int)strcmp(a1, "June") && (unsigned int)strcmp(a1, "September") )
LOBYTE(v1) = (unsigned int)strcmp(a1, "November") == 0;
return v1;
} | func0:
ENDBR64
PUSH R12
LEA RSI,[0x102004]
MOV R12D,0x1
PUSH RBP
MOV RBP,RDI
SUB RSP,0x8
CALL 0x00101070
TEST EAX,EAX
JZ 0x0010126f
LEA RSI,[0x10200a]
MOV RDI,RBP
CALL 0x00101070
TEST EAX,EAX
JZ 0x0010126f
LEA RSI,[0x10200f]
MOV RDI,RBP
CALL 0x00101070
TEST EAX,EAX
JZ 0x0010126f
LEA RSI,[0x102019]
MOV RDI,RBP
CALL 0x00... | bool func0(char *param_1)
{
int iVar1;
bool bVar2;
bVar2 = true;
iVar1 = strcmp(param_1,"April");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"June");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"September");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"November");
bVar2 = iVar1... |
4,659 | func0 |
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(const char *monthname3) {
if (strcmp(monthname3, "April") == 0 || strcmp(monthname3, "June") == 0 ||
strcmp(monthname3, "September") == 0 || strcmp(monthname3, "November") == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0("February") == false);
assert(func0("June") == true);
assert(func0("April") == true);
return 0;
}
| O3 | c | func0:
endbr64
mov %rdi,%rax
mov $0x6,%ecx
lea 0xe01(%rip),%rdi
mov $0x1,%r8d
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0,%dl
test %dl,%dl
je 126a <func0+0x7a>
mov $0x5,%ecx
lea 0xde6(%rip),%rdi
mov %rax,%rsi
repz cmpsb %es:(%rdi),%ds:(%rsi)
seta %dl
sbb $0x0... | func0:
endbr64
push rbp
lea rsi, s2; "April"
mov ebp, 1
push rbx
mov rbx, rdi
sub rsp, 8
call _strcmp
test eax, eax
jz short loc_126D
lea rsi, aJune; "June"
mov rdi, rbx; s1
call _strcmp
test eax, eax
jz short loc_126D
lea rsi, aSeptember; "September"
mov rdi,... | long long func0(char *s1)
{
unsigned int v1; // ebp
v1 = 1;
if ( strcmp(s1, "April") && strcmp(s1, "June") && strcmp(s1, "September") )
LOBYTE(v1) = strcmp(s1, "November") == 0;
return v1;
} | func0:
ENDBR64
PUSH RBP
LEA RSI,[0x102004]
MOV EBP,0x1
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101070
TEST EAX,EAX
JZ 0x0010126d
LEA RSI,[0x10200a]
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JZ 0x0010126d
LEA RSI,[0x10200f]
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JZ 0x0010126d
LEA RSI,[0x102019]
MOV RDI,RBX
CALL 0x001... | bool func0(char *param_1)
{
int iVar1;
bool bVar2;
bVar2 = true;
iVar1 = strcmp(param_1,"April");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"June");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"September");
if (iVar1 != 0) {
iVar1 = strcmp(param_1,"November");
bVar2 = iVar1... |
4,660 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>
| int func0(const char *str) {
int flag_l = 0;
int flag_n = 0;
while (*str) {
if (isalpha((unsigned char)*str)) {
flag_l = 1;
}
if (isdigit((unsigned char)*str)) {
flag_n = 1;
}
str++;
}
return flag_l && flag_n;
}
| int main() {
assert(func0("thishasboth29") == 1);
assert(func0("python") == 0);
assert(func0("string") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ea <func0+0x81>
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rdx
mov -0x18(%rbp),%rax
movzbl (%rax),%eax
movzbl %al,%eax
add %rax,%rax
add %rdx,%rax
movzwl (%rax),%eax
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11EA
loc_1189:
call ___ctype_b_loc
mov rdx, [rax]
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
movzx eax, al
add rax, rax
add rax, rdx
movzx ... | _BOOL8 func0(_BYTE *a1)
{
int v3; // [rsp+18h] [rbp-8h]
int v4; // [rsp+1Ch] [rbp-4h]
v3 = 0;
v4 = 0;
while ( *a1 )
{
if ( ((*__ctype_b_loc())[(unsigned __int8)*a1] & 0x400) != 0 )
v3 = 1;
if ( ((*__ctype_b_loc())[(unsigned __int8)*a1] & 0x800) != 0 )
v4 = 1;
++a1;
}
return v3 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ea
LAB_00101189:
CALL 0x00101070
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOVZX EAX,AL
ADD RAX,RAX
ADD RAX,RDX
MOVZX EAX,word... | int8 func0(byte *param_1)
{
bool bVar1;
bool bVar2;
ushort **ppuVar3;
int8 uVar4;
byte *local_20;
bVar1 = false;
bVar2 = false;
for (local_20 = param_1; *local_20 != 0; local_20 = local_20 + 1) {
ppuVar3 = __ctype_b_loc();
if (((*ppuVar3)[*local_20] & 0x400) != 0) {
bVar1 = true;
}... |
4,661 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>
| int func0(const char *str) {
int flag_l = 0;
int flag_n = 0;
while (*str) {
if (isalpha((unsigned char)*str)) {
flag_l = 1;
}
if (isdigit((unsigned char)*str)) {
flag_n = 1;
}
str++;
}
return flag_l && flag_n;
}
| int main() {
assert(func0("thishasboth29") == 1);
assert(func0("python") == 0);
assert(func0("string") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 11c9 <func0+0x60>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rdi
mov $0x0,%edx
mov $0x0,%ecx
mov $0x1,%esi
movzbl %bl,%ebx
movzwl (%rdi,%rbx,2),%eax
test $0x4,%ah
cmovne %esi,%ecx
test $0x8... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_11C9
mov rbp, rdi
call ___ctype_b_loc
mov rdi, [rax]
mov edx, 0
mov ecx, 0
mov esi, 1
loc_1194:
movzx ebx, bl
movzx eax, word ptr [rdi+rbx*2]
test ah, 4
cmovnz ecx, esi
test ... | long long func0(unsigned __int8 *a1)
{
unsigned __int8 v1; // bl
unsigned __int8 *v2; // rbp
long long v3; // rdi
int v4; // edx
int v5; // ecx
__int16 v6; // ax
v1 = *a1;
if ( *a1 )
{
v2 = a1;
v3 = *(_QWORD *)__ctype_b_loc();
v4 = 0;
v5 = 0;
do
{
v6 = *(_WORD *)(v3 + 2... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001011c9
MOV RBP,RDI
CALL 0x00101070
MOV RDI,qword ptr [RAX]
MOV EDX,0x0
MOV ECX,0x0
MOV ESI,0x1
LAB_00101194:
MOVZX EBX,BL
MOVZX EAX,word ptr [RDI + RBX*0x2]
TEST AH,0x4
CMOVNZ ECX,ESI
TEST AH,0x8
CMOVNZ EDX,ESI
ADD RBP,0x1
MOVZX EBX... | byte func0(byte *param_1)
{
byte bVar1;
byte bVar2;
ushort **ppuVar3;
byte bVar4;
bVar4 = *param_1;
if (bVar4 == 0) {
bVar2 = 0;
bVar1 = 0;
}
else {
ppuVar3 = __ctype_b_loc();
bVar2 = 0;
bVar1 = 0;
do {
if (((*ppuVar3)[bVar4] & 0x400) != 0) {
bVar1 = 1;
}
... |
4,662 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>
| int func0(const char *str) {
int flag_l = 0;
int flag_n = 0;
while (*str) {
if (isalpha((unsigned char)*str)) {
flag_l = 1;
}
if (isdigit((unsigned char)*str)) {
flag_n = 1;
}
str++;
}
return flag_l && flag_n;
}
| int main() {
assert(func0("thishasboth29") == 1);
assert(func0("python") == 0);
assert(func0("string") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 1260 <func0+0x50>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
xor %ecx,%ecx
mov $0x1,%esi
mov (%rax),%rdi
xor %eax,%eax
nopl (%rax)
movzbl %bl,%ebx
movzwl (%rdi,%rbx,2),%edx
test $0x4,%dh
cmovne %esi,%e... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_1260
mov rbp, rdi
call ___ctype_b_loc
xor ecx, ecx
mov esi, 1
mov rdi, [rax]
xor eax, eax
nop dword ptr [rax]
loc_1238:
movzx edx, word ptr [rdi+rbx*2]
test dh, 4
cmovnz ea... | long long func0(unsigned __int8 *a1)
{
long long v1; // rbx
unsigned __int8 *v2; // rbp
long long *v3; // rax
int v4; // ecx
long long v5; // rdi
int v6; // eax
__int16 v7; // dx
v1 = *a1;
if ( !(_BYTE)v1 )
return 0LL;
v2 = a1;
v3 = (long long *)__ctype_b_loc();
v4 = 0;
v5 = *v3;
v6 = ... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101260
MOV RBP,RDI
CALL 0x00101070
XOR ECX,ECX
MOV ESI,0x1
MOV RDI,qword ptr [RAX]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101238:
MOVZX EDX,word ptr [RDI + RBX*0x2]
TEST DH,0x4
CMOVNZ EAX,ESI
AND DH,0x8
CMOVNZ ECX,ESI
MOVZX EBX,byte ... | uint func0(byte *param_1)
{
byte bVar1;
uint uVar2;
ushort **ppuVar3;
uint uVar4;
bVar1 = *param_1;
if (bVar1 != 0) {
ppuVar3 = __ctype_b_loc();
uVar4 = 0;
uVar2 = 0;
do {
if (((*ppuVar3)[bVar1] & 0x400) != 0) {
uVar2 = 1;
}
if (((*ppuVar3)[bVar1] & 0x800) != 0)... |
4,663 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>
| int func0(const char *str) {
int flag_l = 0;
int flag_n = 0;
while (*str) {
if (isalpha((unsigned char)*str)) {
flag_l = 1;
}
if (isdigit((unsigned char)*str)) {
flag_n = 1;
}
str++;
}
return flag_l && flag_n;
}
| int main() {
assert(func0("thishasboth29") == 1);
assert(func0("python") == 0);
assert(func0("string") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 1260 <func0+0x50>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
xor %ecx,%ecx
mov $0x1,%esi
mov (%rax),%rdi
xor %eax,%eax
nopl (%rax)
movzbl %bl,%ebx
movzwl (%rdi,%rbx,2),%edx
test $0x4,%dh
cmovne %esi,%e... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_1260
mov rbp, rdi
call ___ctype_b_loc
xor ecx, ecx
mov esi, 1
mov rdi, [rax]
xor eax, eax
nop dword ptr [rax]
loc_1238:
movzx ebx, bl
movzx edx, word ptr [rdi+rbx*2]
test ... | long long func0(unsigned __int8 *a1)
{
unsigned __int8 v1; // bl
unsigned __int8 *v2; // rbp
const unsigned __int16 **v3; // rax
int v4; // ecx
const unsigned __int16 *v5; // rdi
int v6; // eax
unsigned __int16 v7; // dx
v1 = *a1;
if ( !*a1 )
return 0LL;
v2 = a1;
v3 = __ctype_b_loc();
v4 =... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101260
MOV RBP,RDI
CALL 0x00101070
XOR ECX,ECX
MOV ESI,0x1
MOV RDI,qword ptr [RAX]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101238:
MOVZX EBX,BL
MOVZX EDX,word ptr [RDI + RBX*0x2]
TEST DH,0x4
CMOVNZ EAX,ESI
AND DH,0x8
CMOVNZ ECX,ESI
MO... | uint func0(byte *param_1)
{
uint uVar1;
ushort **ppuVar2;
uint uVar3;
byte bVar4;
bVar4 = *param_1;
if (bVar4 != 0) {
ppuVar2 = __ctype_b_loc();
uVar3 = 0;
uVar1 = 0;
do {
if (((*ppuVar2)[bVar4] & 0x400) != 0) {
uVar1 = 1;
}
if (((*ppuVar2)[bVar4] & 0x800) != 0)... |
4,664 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *test_tup, int size, int **result, int *result_size) {
int *temp_res = malloc(size * sizeof(int));
int count = 0;
for (int i = 0; i < size; i++) {
int j;
for (j = 0; j < count; j++) {
if (test_tup[i] == temp_res[j]) {
break;
}
... | int main() {
int i;
int tup1[] = {1, 3, 5, 2, 3, 5, 1, 1, 3};
int *res1;
int res1_size;
func0(tup1, 9, &res1, &res1_size);
assert(res1_size == 4);
for (i = 0; i < res1_size; i++) {
assert((res1[i] == 1) || (res1[i] == 2) || (res1[i] == 3) || (res1[i] == 5));
}
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov %rcx,-0x40(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_40], rcx
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov [rbp+var_18], 0
mov [rbp+var_14], 0... | void func0(long long a1, int a2, void **a3, _DWORD *a4)
{
int v4; // eax
int v7; // [rsp+28h] [rbp-18h]
int i; // [rsp+2Ch] [rbp-14h]
int j; // [rsp+30h] [rbp-10h]
int k; // [rsp+34h] [rbp-Ch]
_DWORD *ptr; // [rsp+38h] [rbp-8h]
ptr = malloc(4LL * a2);
v7 = 0;
for ( i = 0; i < a2; ++i )
{
for (... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x18],0x0
MOV... | void func0(long param_1,int param_2,long *param_3,int *param_4)
{
void *__ptr;
void *pvVar1;
int local_20;
int local_1c;
int local_18;
int local_14;
__ptr = malloc((long)param_2 << 2);
local_20 = 0;
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
local_18 = 0;
while ((loc... |
4,665 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *test_tup, int size, int **result, int *result_size) {
int *temp_res = malloc(size * sizeof(int));
int count = 0;
for (int i = 0; i < size; i++) {
int j;
for (j = 0; j < count; j++) {
if (test_tup[i] == temp_res[j]) {
break;
}
... | int main() {
int i;
int tup1[] = {1, 3, 5, 2, 3, 5, 1, 1, 3};
int *res1;
int res1_size;
func0(tup1, 9, &res1, &res1_size);
assert(res1_size == 4);
for (i = 0; i < res1_size; i++) {
assert((res1[i] == 1) || (res1[i] == 2) || (res1[i] == 3) || (res1[i] == 5));
}
... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r14
mov %esi,%ebp
mov %rdx,%r12
mov %rcx,%r13
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rbx
test %ebp,%ebp
jle 128b <func0+0xe2>
mov %r14,%r8
lea -0x1(%rbp),%eax
lea (%r14,%rax,4)... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov ebx, esi
mov r12, rdx
mov r13, rcx
movsxd rdi, esi
shl rdi, 2
call _malloc
mov rbp, rax
test ebx, ebx
jle loc_1277
mov rsi, r14
lea eax, [rbx-1]
lea rdi, [r14+rax*4]
mov ebx, 0
... | long long func0(_DWORD *a1, int a2, _QWORD *a3, int *a4)
{
long long v7; // rbp
_DWORD *v8; // rsi
_DWORD *v9; // rdi
int v10; // ebx
int v11; // eax
_DWORD *v12; // rdx
long long v13; // rax
v7 = malloc(4LL * a2);
if ( a2 <= 0 )
{
*a3 = malloc(0LL);
v10 = 0;
}
else
{
v8 = a1;
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV EBX,ESI
MOV R12,RDX
MOV R13,RCX
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010b0
MOV RBP,RAX
TEST EBX,EBX
JLE 0x00101277
MOV RSI,R14
LEA EAX,[RBX + -0x1]
LEA RDI,[R14 + RAX*0x4]
MOV EBX,0x0
MOV EAX,0x0
JMP 0x00101204
LAB_001011ed:
MOVSXD RAX,EBX
MOV ... | void func0(int *param_1,int param_2,long *param_3,uint *param_4)
{
int *piVar1;
uint uVar2;
uint uVar3;
int *__ptr;
void *pvVar4;
long lVar5;
int *piVar6;
uint uVar7;
__ptr = (int *)malloc((long)param_2 << 2);
if (param_2 < 1) {
pvVar4 = malloc(0);
*param_3 = (long)pvVar4;
uVar7 = 0;... |
4,666 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *test_tup, int size, int **result, int *result_size) {
int *temp_res = malloc(size * sizeof(int));
int count = 0;
for (int i = 0; i < size; i++) {
int j;
for (j = 0; j < count; j++) {
if (test_tup[i] == temp_res[j]) {
break;
}
... | int main() {
int i;
int tup1[] = {1, 3, 5, 2, 3, 5, 1, 1, 3};
int *res1;
int res1_size;
func0(tup1, 9, &res1, &res1_size);
assert(res1_size == 4);
for (i = 0; i < res1_size; i++) {
assert((res1[i] == 1) || (res1[i] == 2) || (res1[i] == 3) || (res1[i] == 5));
}
... | O2 | c | func0:
endbr64
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
mov %rdi,%r13
shl $0x2,%rdi
push %r12
mov %rdx,%r12
push %rbp
push %rbx
mov %rcx,%rbx
callq 10b0 <malloc@plt>
mov %rax,%rbp
test %r13d,%r13d
jle 1560 <func0+0xf0>
lea -0x1(%r13),%eax
mov %r14,%rdi
xor %r13d,%r13... | func0:
endbr64
push r14
push r13
mov r13, rdi
movsxd rdi, esi
push r12
mov r14, rdi
shl rdi, 2
mov r12, rdx
push rbp
push rbx
mov rbx, rcx
call _malloc
mov rbp, rax
test r14d, r14d
jle loc_1561
lea eax, [r14-1]
mov rdi, r13
lea r8, [r13+rax*4+4]
xor r13d... | long long func0(int *a1, long long a2, long long *a3, int *a4)
{
long long v6; // rbp
long long v7; // r8
int v8; // r13d
long long v9; // rax
long long v10; // rax
int v12; // edx
long long v13; // rax
v6 = malloc(4LL * (int)a2);
if ( (int)a2 <= 0 )
{
v8 = 0;
*a3 = malloc(0LL);
goto L... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RDI
MOVSXD RDI,ESI
PUSH R12
MOV R14,RDI
SHL RDI,0x2
MOV R12,RDX
PUSH RBP
PUSH RBX
MOV RBX,RCX
CALL 0x001010d0
MOV RBP,RAX
TEST R14D,R14D
JLE 0x00101561
LEA EAX,[R14 + -0x1]
MOV RDI,R13
LEA R8,[R13 + RAX*0x4 + 0x4]
XOR R13D,R13D
NOP
LAB_001014d0:
XOR ESI,ESI
TEST R13D,R13D
JLE 0x... | void func0(int *param_1,int param_2,int8 *param_3,int *param_4)
{
int *piVar1;
void *__src;
ulong uVar2;
void *pvVar3;
long lVar4;
int iVar5;
int iVar6;
__src = malloc((long)param_2 << 2);
if (param_2 < 1) {
iVar6 = 0;
pvVar3 = malloc(0);
*param_3 = pvVar3;
}
else {
piVar1 = pa... |
4,667 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int *test_tup, int size, int **result, int *result_size) {
int *temp_res = malloc(size * sizeof(int));
int count = 0;
for (int i = 0; i < size; i++) {
int j;
for (j = 0; j < count; j++) {
if (test_tup[i] == temp_res[j]) {
break;
}
... | int main() {
int i;
int tup1[] = {1, 3, 5, 2, 3, 5, 1, 1, 3};
int *res1;
int res1_size;
func0(tup1, 9, &res1, &res1_size);
assert(res1_size == 4);
for (i = 0; i < res1_size; i++) {
assert((res1[i] == 1) || (res1[i] == 2) || (res1[i] == 3) || (res1[i] == 5));
}
... | O3 | c | func0:
endbr64
push %r14
mov %rdi,%r14
movslq %esi,%rdi
push %r13
mov %rdi,%r13
shl $0x2,%rdi
push %r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rcx,%rbx
callq 10d0 <malloc@plt>
mov %rax,%r12
test %r13d,%r13d
jle 1590 <func0+0xe0>
lea -0x1(%r13),%eax
mov %r14,%rdi
xor %r13d,%r13... | func0:
endbr64
push r15
push r14
push r13
mov r13, rdi
movsxd rdi, esi
push r12
mov r15, rdi
mov r12, rdx
push rbp
mov rbp, rcx
push rbx
lea rbx, ds:0[rdi*4]
mov rdi, rbx; size
sub rsp, 8
call _malloc
mov r14, rax
test r15d, r15d
jle loc_15A3
lea rdi, [r1... | void func0(int *a1, int a2, void **a3, _DWORD *a4)
{
_DWORD *v7; // r14
int *v8; // rdi
int *v9; // rsi
long long v10; // rbx
int v11; // eax
_DWORD *v12; // rdx
void *v13; // rax
void *v14; // rdi
int v15; // eax
int v16; // r13d
void *v17; // rax
v7 = malloc(4LL * a2);
if ( a2 <= 0 )
{
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
MOVSXD RDI,ESI
PUSH R12
MOV R15,RDI
MOV R12,RDX
PUSH RBP
MOV RBP,RCX
PUSH RBX
LEA RBX,[RDI*0x4]
MOV RDI,RBX
SUB RSP,0x8
CALL 0x001010d0
MOV R14,RAX
TEST R15D,R15D
JLE 0x001015a3
LEA RDI,[R13 + RBX*0x1]
MOV RSI,R13
XOR EBX,EBX
LAB_001014f7:
XOR EAX,EAX
TEST EBX,EBX
J... | void func0(int *param_1,int param_2,int8 *param_3,int4 *param_4)
{
int *piVar1;
int iVar2;
int *__src;
void *pvVar3;
int *piVar4;
int iVar5;
ulong uVar6;
uint uVar7;
__src = (int *)malloc((long)param_2 * 4);
if (0 < param_2) {
piVar1 = param_1 + param_2;
uVar6 = 0;
LAB_001014f7:
iVar... |
4,668 | func0 |
#include <assert.h>
| int func0(int n) {
int num = n;
int dec_value = 0;
int base = 1;
int temp = num;
while (temp) {
int last_digit = temp % 10;
temp = temp / 10;
dec_value += last_digit * base;
base = base * 8;
}
return dec_value;
}
| int main() {
assert(func0(25) == 21);
assert(func0(30) == 24);
assert(func0(40) == 32);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
mov -0x24(%rbp),%eax
mov %eax,-0x8(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x1,-0x10(%rbp)
mov -0x8(%rbp),%eax
mov %eax,-0xc(%rbp)
jmp 11c9 <func0+0x80>
mov -0xc(%rbp),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov eax, [rbp+var_24]
mov [rbp+var_8], eax
mov [rbp+var_14], 0
mov [rbp+var_10], 1
mov eax, [rbp+var_8]
mov [rbp+var_C], eax
jmp short loc_11C7
loc_1170:
mov edx, [rbp+var_C]
movsxd rax, edx
imul rax, 66666667h
shr... | long long func0(int a1)
{
unsigned int v2; // [rsp+10h] [rbp-14h]
int v3; // [rsp+14h] [rbp-10h]
int v5; // [rsp+20h] [rbp-4h]
v2 = 0;
v3 = 1;
while ( a1 )
{
v5 = a1 % 10;
a1 /= 10;
v2 += v3 * v5;
v3 *= 8;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x1
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001011c7
LAB_00101170:
MOV EDX,dword ptr [RBP + -0xc]
MOV... | int func0(int param_1)
{
int4 local_1c;
int4 local_18;
int4 local_14;
local_1c = 0;
local_18 = 1;
for (local_14 = param_1; local_14 != 0; local_14 = local_14 / 10) {
local_1c = local_1c + (local_14 % 10) * local_18;
local_18 = local_18 << 3;
}
return local_1c;
} |
4,669 | func0 |
#include <assert.h>
| int func0(int n) {
int num = n;
int dec_value = 0;
int base = 1;
int temp = num;
while (temp) {
int last_digit = temp % 10;
temp = temp / 10;
dec_value += last_digit * base;
base = base * 8;
}
return dec_value;
}
| int main() {
assert(func0(25) == 21);
assert(func0(30) == 24);
assert(func0(40) == 32);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
je 118c <func0+0x43>
mov $0x1,%edx
mov $0x0,%esi
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edi,%ecx
sar $0x1f,%ecx
sub %ecx,%eax
mov %eax,%ecx
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%edi
mov %edi,%eax
mov %ecx,%edi
im... | func0:
endbr64
test edi, edi
jz short loc_118F
mov ecx, 1
mov r8d, 0
loc_115C:
movsxd rax, edi
imul rax, 66666667h
sar rax, 22h
mov edx, edi
sar edx, 1Fh
sub eax, edx
mov esi, eax
lea edx, [rax+rax*4]
add edx, edx
mov eax, edi
sub eax, edx
mov edi, esi
imul ... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // r8d
int v3; // eax
if ( a1 )
{
v1 = 1;
v2 = 0;
do
{
v3 = a1 % 10;
a1 /= 10;
v2 += v1 * v3;
v1 *= 8;
}
while ( a1 );
}
else
{
return 0;
}
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x0010118f
MOV ECX,0x1
MOV R8D,0x0
LAB_0010115c:
MOVSXD RAX,EDI
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDX,EDI
SAR EDX,0x1f
SUB EAX,EDX
MOV ESI,EAX
LEA EDX,[RAX + RAX*0x4]
ADD EDX,EDX
MOV EAX,EDI
SUB EAX,EDX
MOV EDI,ESI
IMUL EAX,ECX
ADD R8D,EAX
SHL ECX,0x3
TEST ESI,ESI
JNZ 0x0010115c
LA... | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (param_1 == 0) {
iVar3 = 0;
}
else {
iVar2 = 1;
iVar3 = 0;
do {
iVar1 = param_1 / 10;
iVar3 = iVar3 + (param_1 % 10) * iVar2;
iVar2 = iVar2 << 3;
param_1 = iVar1;
} while (iVar1 != 0);
}
return i... |
4,670 | func0 |
#include <assert.h>
| int func0(int n) {
int num = n;
int dec_value = 0;
int base = 1;
int temp = num;
while (temp) {
int last_digit = temp % 10;
temp = temp / 10;
dec_value += last_digit * base;
base = base * 8;
}
return dec_value;
}
| int main() {
assert(func0(25) == 21);
assert(func0(30) == 24);
assert(func0(40) == 32);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
je 1188 <func0+0x48>
mov $0x1,%ecx
xor %r8d,%r8d
movslq %edi,%rax
mov %edi,%edx
imul $0x66666667,%rax,%rax
sar $0x1f,%edx
sar $0x22,%rax
sub %edx,%eax
mov %eax,%edx
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%edi
mov %edi,%eax
mov %edx,%edi
im... | func0:
endbr64
test edi, edi
jz short loc_1188
mov esi, 1
xor r8d, r8d
loc_1150:
movsxd rax, edi
mov edx, edi
imul rax, 66666667h
sar edx, 1Fh
sar rax, 22h
sub eax, edx
lea ecx, [rax+rax*4]
mov edx, eax
mov eax, edi
add ecx, ecx
mov edi, edx
sub eax, ecx
imul ... | long long func0(int a1)
{
int v1; // esi
unsigned int v2; // r8d
int v3; // eax
int v4; // ecx
int v5; // eax
if ( !a1 )
return 0LL;
v1 = 1;
v2 = 0;
do
{
v3 = a1;
v4 = 10 * (a1 / 10);
a1 /= 10;
v5 = v1 * (v3 - v4);
v1 *= 8;
v2 += v5;
}
while ( a1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101188
MOV ESI,0x1
XOR R8D,R8D
LAB_00101150:
MOVSXD RAX,EDI
MOV EDX,EDI
IMUL RAX,RAX,0x66666667
SAR EDX,0x1f
SAR RAX,0x22
SUB EAX,EDX
LEA ECX,[RAX + RAX*0x4]
MOV EDX,EAX
MOV EAX,EDI
ADD ECX,ECX
MOV EDI,EDX
SUB EAX,ECX
IMUL EAX,ESI
SHL ESI,0x3
ADD R8D,EAX
TEST EDX,EDX
JNZ 0x00101150
MO... | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_1 != 0) {
iVar3 = 1;
iVar4 = 0;
do {
iVar1 = param_1 / 10;
iVar2 = (param_1 % 10) * iVar3;
iVar3 = iVar3 << 3;
iVar4 = iVar4 + iVar2;
param_1 = iVar1;
} while (iVar1 != 0);
retu... |
4,671 | func0 |
#include <assert.h>
| int func0(int n) {
int num = n;
int dec_value = 0;
int base = 1;
int temp = num;
while (temp) {
int last_digit = temp % 10;
temp = temp / 10;
dec_value += last_digit * base;
base = base * 8;
}
return dec_value;
}
| int main() {
assert(func0(25) == 21);
assert(func0(30) == 24);
assert(func0(40) == 32);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
je 1188 <func0+0x48>
mov $0x1,%ecx
xor %r8d,%r8d
movslq %edi,%rax
mov %edi,%edx
imul $0x66666667,%rax,%rax
sar $0x1f,%edx
sar $0x22,%rax
sub %edx,%eax
mov %eax,%edx
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%edi
mov %edi,%eax
mov %edx,%edi
im... | func0:
endbr64
test edi, edi
jz short loc_1188
mov esi, 1
xor r8d, r8d
loc_1150:
movsxd rax, edi
mov edx, edi
imul rax, 66666667h
sar edx, 1Fh
sar rax, 22h
sub eax, edx
lea ecx, [rax+rax*4]
mov edx, eax
mov eax, edi
add ecx, ecx
mov edi, edx
sub eax, ecx
imul ... | long long func0(int a1)
{
int v1; // esi
unsigned int v2; // r8d
int v3; // eax
int v4; // ecx
int v5; // eax
if ( !a1 )
return 0LL;
v1 = 1;
v2 = 0;
do
{
v3 = a1;
v4 = 10 * (a1 / 10);
a1 /= 10;
v5 = v1 * (v3 - v4);
v1 *= 8;
v2 += v5;
}
while ( a1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101188
MOV ESI,0x1
XOR R8D,R8D
LAB_00101150:
MOVSXD RAX,EDI
MOV EDX,EDI
IMUL RAX,RAX,0x66666667
SAR EDX,0x1f
SAR RAX,0x22
SUB EAX,EDX
LEA ECX,[RAX + RAX*0x4]
MOV EDX,EAX
MOV EAX,EDI
ADD ECX,ECX
MOV EDI,EDX
SUB EAX,ECX
IMUL EAX,ESI
SHL ESI,0x3
ADD R8D,EAX
TEST EDX,EDX
JNZ 0x00101150
MO... | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_1 != 0) {
iVar3 = 1;
iVar4 = 0;
do {
iVar1 = param_1 / 10;
iVar2 = (param_1 % 10) * iVar3;
iVar3 = iVar3 << 3;
iVar4 = iVar4 + iVar2;
param_1 = iVar1;
} while (iVar1 != 0);
retu... |
4,672 | 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,4,5,6,6};
int arr2[] = {1,2,2,2,3,2,2,4,2};
int arr3[] = {1,2,3};
assert(func0(arr1, 6, 7) == 5);
assert(func0(arr2, 2, 9) == 1);
assert(func0(arr3, 1, 3) == 0);
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... |
4,673 | 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,4,5,6,6};
int arr2[] = {1,2,2,2,3,2,2,4,2};
int arr3[] = {1,2,3};
assert(func0(arr1, 6, 7) == 5);
assert(func0(arr2, 2, 9) == 1);
assert(func0(arr3, 1, 3) == 0);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1,%edx
js 11af <func0+0x46>
mov $0xffffffff,%r9d
mov $0x0,%r8d
jmp 118b <func0+0x22>
jge 11a7 <func0+0x3e>
lea 0x1(%rax),%r8d
cmp %edx,%r8d
jg 11b5 <func0+0x4c>
lea (%r8,%rdx,1),%ecx
mov %ecx,%eax
shr $0x1f,%eax
add %ecx,%eax
sar %eax
movslq %eax,%rcx
mo... | func0:
endbr64
sub edx, 1
js short loc_11AF
mov r9d, 0FFFFFFFFh
mov r8d, 0
jmp short loc_118B
loc_1180:
jge short loc_11A7
lea r8d, [rax+1]
loc_1186:
cmp r8d, edx
jg short loc_11B5
loc_118B:
lea ecx, [r8+rdx]
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
mov... | 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 0x001011af
MOV R9D,0xffffffff
MOV R8D,0x0
JMP 0x0010118b
LAB_00101180:
JGE 0x001011a7
LEA R8D,[RAX + 0x1]
LAB_00101186:
CMP R8D,EDX
JG 0x001011b5
LAB_0010118b:
LEA ECX,[R8 + RDX*0x1]
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOVSXD RCX,EAX
MOV ECX,dword ptr [RDI + RCX*0x4]
CMP ECX,E... | 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) {
iVar2 = -1;
}
else {
iVar3 = 0;
iVar4 = -1;
do {
iVar2 = (iVar3 + param_3) / 2;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (... |
4,674 | 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,4,5,6,6};
int arr2[] = {1,2,2,2,3,2,2,4,2};
int arr3[] = {1,2,3};
assert(func0(arr1, 6, 7) == 5);
assert(func0(arr2, 2, 9) == 1);
assert(func0(arr3, 1, 3) == 0);
return 0;
}
| O2 | c | func0:
endbr64
mov $0xffffffff,%r9d
sub $0x1,%edx
js 1396 <func0+0x36>
xor %ecx,%ecx
jmp 137f <func0+0x1f>
nopl 0x0(%rax,%rax,1)
lea -0x1(%rax),%edx
cmp %ecx,%edx
jl 1396 <func0+0x36>
lea (%rdx,%rcx,1),%eax
sar %eax
movslq %eax,%r8
cmp %esi,(%rdi,%r8,4)
jg 1378 <func0+0x18>
jge ... | func0:
endbr64
mov r9d, 0FFFFFFFFh
sub edx, 1
js short loc_1306
xor ecx, ecx
jmp short loc_12EF
loc_12E8:
lea edx, [rax-1]
loc_12EB:
cmp edx, ecx
jl short loc_1306
loc_12EF:
lea eax, [rdx+rcx]
sar eax, 1
movsxd r8, eax
cmp [rdi+r8*4], esi
jg short loc_12E8
jge sho... | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r9d
int v4; // edx
int v5; // ecx
int v6; // eax
v3 = -1;
v4 = a3 - 1;
if ( v4 >= 0 )
{
v5 = 0;
do
{
while ( 1 )
{
v6 = (v4 + v5) >> 1;
if ( *(_DWORD *)(a1 + 4LL * v6) <= a2 )
break;
... | func0:
ENDBR64
MOV R9D,0xffffffff
SUB EDX,0x1
JS 0x00101306
XOR ECX,ECX
JMP 0x001012ef
LAB_001012e8:
LEA EDX,[RAX + -0x1]
LAB_001012eb:
CMP EDX,ECX
JL 0x00101306
LAB_001012ef:
LEA EAX,[RDX + RCX*0x1]
SAR EAX,0x1
MOVSXD R8,EAX
CMP dword ptr [RDI + R8*0x4],ESI
JG 0x001012e8
JGE 0x00101310
LEA ECX,[RAX + 0x1]
CMP EDX,ECX
... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
iVar5 = -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);
... |
4,675 | 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,4,5,6,6};
int arr2[] = {1,2,2,2,3,2,2,4,2};
int arr3[] = {1,2,3};
assert(func0(arr1, 6, 7) == 5);
assert(func0(arr2, 2, 9) == 1);
assert(func0(arr3, 1, 3) == 0);
return 0;
}
| O3 | c | func0:
endbr64
mov $0xffffffff,%r9d
sub $0x1,%edx
js 1376 <func0+0x36>
xor %ecx,%ecx
jmp 135f <func0+0x1f>
nopl 0x0(%rax,%rax,1)
lea -0x1(%rax),%edx
cmp %edx,%ecx
jg 1376 <func0+0x36>
lea (%rdx,%rcx,1),%eax
sar %eax
movslq %eax,%r8
cmp (%rdi,%r8,4),%esi
jl 1358 <func0+0x18>
jle ... | func0:
endbr64
mov r9d, 0FFFFFFFFh
sub edx, 1
js short loc_1390
xor r8d, r8d
jmp short loc_1370
loc_1368:
lea edx, [rax-1]
loc_136B:
cmp r8d, edx
jg short loc_1390
loc_1370:
lea ecx, [rdx+r8]
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
movsxd rcx, eax
cmp ... | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r9d
int v4; // edx
int v5; // r8d
int v6; // eax
v3 = -1;
v4 = a3 - 1;
if ( v4 >= 0 )
{
v5 = 0;
do
{
while ( 1 )
{
v6 = (v4 + v5) / 2;
if ( a2 >= *(_DWORD *)(a1 + 4LL * v6) )
break;
... | func0:
ENDBR64
MOV R9D,0xffffffff
SUB EDX,0x1
JS 0x00101390
XOR R8D,R8D
JMP 0x00101370
LAB_00101368:
LEA EDX,[RAX + -0x1]
LAB_0010136b:
CMP R8D,EDX
JG 0x00101390
LAB_00101370:
LEA ECX,[RDX + R8*0x1]
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOVSXD RCX,EAX
CMP ESI,dword ptr [RDI + RCX*0x4]
JL 0x00101368
JLE 0x001... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
iVar5 = -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);
... |
4,676 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
struct Tuple {
int *elements;
int size;
};
struct TupleList {
struct Tuple *tuples;
int size;
};
struct TupleList remove_tuples(struct TupleList test_list, int K) {
struct TupleList res;
res.tuples = malloc(test_list.s... | int func0(struct TupleList l1, struct TupleList l2) {
if (l1.size != l2.size) return 0;
for (int i = 0; i < l1.size; i++) {
if (!compare_tuples(l1.tuples[i], l2.tuples[i])) return 0;
}
return 1;
}
| int main() {
int tuple1[] = {4, 5};
int tuple2[] = {4};
int tuple3[] = {8, 6, 7};
int tuple4[] = {1};
int tuple5[] = {3, 4, 6, 7};
struct Tuple tuples1[] = {{tuple1, 2}, {tuple2, 1}, {tuple3, 3}, {tuple4, 1}, {tuple5, 4}};
struct TupleList test_list1 = {tuples1, 5};
struct Tuple ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rsi,%rax
mov %rdi,%r8
mov %r8,%rsi
mov %r9,%rdi
mov %rax,%rdi
mov %rsi,-0x20(%rbp)
mov %rdi,-0x18(%rbp)
mov %rdx,-0x30(%rbp)
mov %rcx,-0x28(%rbp)
mov -0x18(%rbp),%edx
mov -0x28(%rbp),%eax
cmp %eax,%edx
je 131a <fu... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, rdi
mov r8, rsi
mov rsi, rax
mov rdi, rdx
mov rdi, r8
mov [rbp+var_20], rsi
mov [rbp+var_18], rdi
mov [rbp+var_30], rdx
mov [rbp+var_28], rcx
mov edx, dword ptr [rbp+var_18]
mov eax, dword ptr [rbp+var_28]
... | long long func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+2Ch] [rbp-4h]
if ( a2 != a4 )
return 0LL;
for ( i = 0; i < a2; ++i )
{
if ( !(unsigned int)compare_tuples(
*(_QWORD *)(a1 + 16LL * i),
*(_QWORD *)(a1 + 16LL * i + 8),
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,RDI
MOV R8,RSI
MOV RSI,RAX
MOV RDI,RDX
MOV RDI,R8
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x30],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x28]
CMP EDX,EAX
JZ 0x0010... | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
int iVar1;
int8 uVar2;
int8 *puVar3;
int8 *puVar4;
int local_c;
if (param_2 == param_4) {
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
puVar3 = (int8 *)(param_3 + (long)local_c * 0x10);
puVar4 = (int8 *)((lo... |
4,677 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
struct Tuple {
int *elements;
int size;
};
struct TupleList {
struct Tuple *tuples;
int size;
};
struct TupleList remove_tuples(struct TupleList test_list, int K) {
struct TupleList res;
res.tuples = malloc(test_list.s... | int func0(struct TupleList l1, struct TupleList l2) {
if (l1.size != l2.size) return 0;
for (int i = 0; i < l1.size; i++) {
if (!compare_tuples(l1.tuples[i], l2.tuples[i])) return 0;
}
return 1;
}
| int main() {
int tuple1[] = {4, 5};
int tuple2[] = {4};
int tuple3[] = {8, 6, 7};
int tuple4[] = {1};
int tuple5[] = {3, 4, 6, 7};
struct Tuple tuples1[] = {{tuple1, 2}, {tuple2, 1}, {tuple3, 3}, {tuple4, 1}, {tuple5, 4}};
struct TupleList test_list1 = {tuples1, 5};
struct Tuple ... | O1 | c | func0:
endbr64
mov $0x0,%eax
cmp %ecx,%esi
jne 12aa <func0+0x5c>
test %esi,%esi
jle 12a4 <func0+0x56>
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %rdx,%rbp
lea -0x1(%rsi),%eax
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%r12
mov (%rbx),%rdi
mov 0x8(%rbx),%rsi
mov 0x0(%rbp),%rdx
m... | func0:
endbr64
mov eax, 0
cmp esi, ecx
jnz short locret_12AA
test esi, esi
jle short loc_12A4
push r12
push rbp
push rbx
mov rbx, rdi
mov rbp, rdx
lea eax, [rsi-1]
shl rax, 4
lea r12, [rdi+rax+10h]
loc_1275:
mov rdi, [rbx]
mov rsi, [rbx+8]
mov rdx, [rbp+0]
mov... | long long func0(_QWORD *a1, int a2, _QWORD *a3, int a4)
{
long long result; // rax
_QWORD *v5; // rbx
result = 0LL;
if ( a2 == a4 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v5 = a1;
while ( 1 )
{
result = compare_tuples(*v5, v5[1], *a3, a3[1]);
if (... | func0:
ENDBR64
MOV EAX,0x0
CMP ESI,ECX
JNZ 0x001012aa
TEST ESI,ESI
JLE 0x001012a4
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RBP,RDX
LEA EAX,[RSI + -0x1]
SHL RAX,0x4
LEA R12,[RDI + RAX*0x1 + 0x10]
LAB_00101275:
MOV RDI,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RBP]
MOV RCX,qword ptr [RBP + 0x8]
C... | int8 func0(int8 *param_1,int param_2,int8 *param_3,int param_4)
{
int8 *puVar1;
int8 uVar2;
if (param_2 != param_4) {
return 0;
}
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) * 2 + 2;
do {
uVar2 = compare_tuples(*param_1,param_1[1],*param_3,param_3[1]);
if ((int)uVar2... |
4,678 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
struct Tuple {
int *elements;
int size;
};
struct TupleList {
struct Tuple *tuples;
int size;
};
struct TupleList remove_tuples(struct TupleList test_list, int K) {
struct TupleList res;
res.tuples = malloc(test_list.s... | int func0(struct TupleList l1, struct TupleList l2) {
if (l1.size != l2.size) return 0;
for (int i = 0; i < l1.size; i++) {
if (!compare_tuples(l1.tuples[i], l2.tuples[i])) return 0;
}
return 1;
}
| int main() {
int tuple1[] = {4, 5};
int tuple2[] = {4};
int tuple3[] = {8, 6, 7};
int tuple4[] = {1};
int tuple5[] = {3, 4, 6, 7};
struct Tuple tuples1[] = {{tuple1, 2}, {tuple2, 1}, {tuple3, 3}, {tuple4, 1}, {tuple5, 4}};
struct TupleList test_list1 = {tuples1, 5};
struct Tuple ... | O2 | c | func0:
endbr64
xor %eax,%eax
cmp %ecx,%esi
jne 173e <func0+0x6e>
test %esi,%esi
jle 1739 <func0+0x69>
lea -0x1(%rsi),%eax
xor %esi,%esi
add $0x1,%rax
shl $0x4,%rax
mov %rax,%r11
mov 0x8(%rdi,%rsi,1),%eax
cmp 0x8(%rdx,%rsi,1),%eax
jne 1726 <func0+0x56>
test %eax,%eax
jle 1730 <... | func0:
endbr64
mov r10, rdi
xor eax, eax
cmp esi, ecx
jnz short locret_1740
movsxd r11, esi
xor ecx, ecx
shl r11, 4
test esi, esi
jle short loc_1739
nop word ptr [rax+rax+00h]
loc_16F0:
mov rsi, [r10+rcx]
mov r9d, [r10+rcx+8]
mov rdi, [rdx+rcx]
cmp r9d, [rdx+rcx+8]
jn... | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v5; // rcx
int v6; // r9d
long long v7; // rax
result = 0LL;
if ( a2 == a4 )
{
v5 = 0LL;
if ( a2 <= 0 )
{
return 1LL;
}
else
{
while ( 1 )
{
v6 = *(_DWORD *)... | func0:
ENDBR64
MOV R10,RDI
XOR EAX,EAX
CMP ESI,ECX
JNZ 0x00101740
MOVSXD R11,ESI
XOR ECX,ECX
SHL R11,0x4
TEST ESI,ESI
JLE 0x00101739
NOP word ptr [RAX + RAX*0x1]
LAB_001016f0:
MOV RSI,qword ptr [R10 + RCX*0x1]
MOV R9D,dword ptr [R10 + RCX*0x1 + 0x8]
MOV RDI,qword ptr [RDX + RCX*0x1]
CMP R9D,dword ptr [RDX + RCX*0x1 + 0... | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
int iVar1;
long lVar2;
long lVar3;
if (param_2 != param_4) {
return 0;
}
lVar3 = 0;
if (0 < param_2) {
do {
iVar1 = *(int *)(param_1 + 8 + lVar3);
if (iVar1 != *(int *)(param_3 + 8 + lVar3)) {
return 0;
}... |
4,679 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
struct Tuple {
int *elements;
int size;
};
struct TupleList {
struct Tuple *tuples;
int size;
};
struct TupleList remove_tuples(struct TupleList test_list, int K) {
struct TupleList res;
res.tuples = malloc(test_list.s... | int func0(struct TupleList l1, struct TupleList l2) {
if (l1.size != l2.size) return 0;
for (int i = 0; i < l1.size; i++) {
if (!compare_tuples(l1.tuples[i], l2.tuples[i])) return 0;
}
return 1;
}
| int main() {
int tuple1[] = {4, 5};
int tuple2[] = {4};
int tuple3[] = {8, 6, 7};
int tuple4[] = {1};
int tuple5[] = {3, 4, 6, 7};
struct Tuple tuples1[] = {{tuple1, 2}, {tuple2, 1}, {tuple3, 3}, {tuple4, 1}, {tuple5, 4}};
struct TupleList test_list1 = {tuples1, 5};
struct Tuple ... | O3 | c | func0:
endbr64
xor %eax,%eax
cmp %ecx,%esi
jne 172e <func0+0x6e>
test %esi,%esi
jle 1729 <func0+0x69>
lea -0x1(%rsi),%eax
xor %esi,%esi
add $0x1,%rax
shl $0x4,%rax
mov %rax,%r11
mov 0x8(%rdi,%rsi,1),%eax
cmp 0x8(%rdx,%rsi,1),%eax
jne 1716 <func0+0x56>
test %eax,%eax
jle 1720 <... | func0:
endbr64
mov r10, rdi
xor eax, eax
cmp esi, ecx
jnz short locret_1725
test esi, esi
jle short loc_1739
movsxd rsi, esi
xor edi, edi
shl rsi, 4
loc_16EA:
movsxd rcx, dword ptr [r10+rdi+8]
cmp ecx, [rdx+rdi+8]
jnz short loc_1723
test ecx, ecx
jle short loc_1730
mov ... | long long func0(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v6; // rdi
long long v7; // rsi
long long v8; // rcx
long long v9; // rcx
long long v10; // rax
result = 0LL;
if ( a2 == a4 )
{
if ( a2 <= 0 )
{
return 1LL;
}
else
{
v6 = ... | func0:
ENDBR64
MOV R10,RDI
XOR EAX,EAX
CMP ESI,ECX
JNZ 0x00101725
TEST ESI,ESI
JLE 0x00101739
MOVSXD RSI,ESI
XOR EDI,EDI
SHL RSI,0x4
LAB_001016ea:
MOVSXD RCX,dword ptr [R10 + RDI*0x1 + 0x8]
CMP ECX,dword ptr [RDX + RDI*0x1 + 0x8]
JNZ 0x00101723
TEST ECX,ECX
JLE 0x00101730
MOV R9,qword ptr [R10 + RDI*0x1]
MOV R8,qword p... | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
int iVar1;
long lVar2;
long lVar3;
if (param_2 != param_4) {
return 0;
}
if (0 < param_2) {
lVar3 = 0;
do {
iVar1 = *(int *)(param_1 + 8 + lVar3);
if (iVar1 != *(int *)(param_3 + 8 + lVar3)) {
return 0;
... |
4,680 | func0 |
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int test_tup1[], int test_tup2[], int n) {
int* res = malloc(sizeof(int) * n);
for(int i = 0; i < n; i++) {
res[i] = (int)pow(test_tup1[i], test_tup2[i]);
}
return res;
}
| int main() {
int test1_tup1[] = {10, 4, 5, 6};
int test1_tup2[] = {5, 6, 7, 5};
int expected1[] = {100000, 4096, 78125, 7776};
int* res1 = func0(test1_tup1, test1_tup2, 4);
assert(memcmp(res1, expected1, sizeof(expected1)) == 0);
free(res1);
int test2_tup1[] = {11, 5, 6, 7};
in... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov -0x24(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1275 <func0+0x8c>
mov -0xc(%rbp),%eax
cltq... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov eax, [rbp+var_24]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_128B
loc_121E:
mov eax, [r... | _DWORD * func0(long long a1, long long a2, int a3)
{
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v6; // [rsp+28h] [rbp-8h]
v6 = malloc(4LL * a3);
for ( i = 0; i < a3; ++i )
v6[i] = (int)pow((double)*(int *)(4LL * i + a1), (double)*(int *)(4LL * i + a2));
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010128b
LAB_0010121e:
MOV EAX... | void * func0(long param_1,long param_2,int param_3)
{
void *pvVar1;
double dVar2;
int4 local_14;
pvVar1 = malloc((long)param_3 << 2);
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
dVar2 = pow((double)*(int *)(param_1 + (long)local_14 * 4),
(double)*(int *)(param_2 +... |
4,681 | func0 |
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
| int* func0(int test_tup1[], int test_tup2[], int n) {
int* res = malloc(sizeof(int) * n);
for(int i = 0; i < n; i++) {
res[i] = (int)pow(test_tup1[i], test_tup2[i]);
}
return res;
}
| int main() {
int test1_tup1[] = {10, 4, 5, 6};
int test1_tup2[] = {5, 6, 7, 5};
int expected1[] = {100000, 4096, 78125, 7776};
int* res1 = func0(test1_tup1, test1_tup2, 4);
assert(memcmp(res1, expected1, sizeof(expected1)) == 0);
free(res1);
int test2_tup1[] = {11, 5, 6, 7};
in... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %rsi,%r13
mov %edx,%ebx
movslq %edx,%rdi
shl $0x2,%rdi
callq 10f0 <malloc@plt>
mov %rax,%rbp
test %ebx,%ebx
jle 1247 <func0+0x5e>
lea -0x1(%rbx),%r14d
mov $0x0,%ebx
pxor %xmm0,%xmm0
cvtsi2sdl (%r12,... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r13, rdi
mov r14, rsi
mov ebp, edx
movsxd rdi, edx
shl rdi, 2
call _malloc
mov r12, rax
test ebp, ebp
jle short loc_1242
mov ebp, ebp
mov ebx, 0
loc_1217:
pxor xmm0, xmm0
cvtsi2sd xmm0, dword ptr [r1... | long long func0(long long a1, long long a2, int a3)
{
long long v4; // r12
long long v5; // rbx
v4 = malloc(4LL * a3);
if ( a3 > 0 )
{
v5 = 0LL;
do
{
*(_DWORD *)(v4 + 4 * v5) = (int)pow((double)*(int *)(a1 + 4 * v5), (double)*(int *)(a2 + 4 * v5));
++v5;
}
while ( v5 != a3 );... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13,RDI
MOV R14,RSI
MOV EBP,EDX
MOVSXD RDI,EDX
SHL RDI,0x2
CALL 0x001010f0
MOV R12,RAX
TEST EBP,EBP
JLE 0x00101242
MOV EBP,EBP
MOV EBX,0x0
LAB_00101217:
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [R13 + RBX*0x4]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [R14 + RB... | void * func0(long param_1,long param_2,uint param_3)
{
void *pvVar1;
ulong uVar2;
double dVar3;
pvVar1 = malloc((long)(int)param_3 << 2);
if (0 < (int)param_3) {
uVar2 = 0;
do {
dVar3 = pow((double)*(int *)(param_1 + uVar2 * 4),(double)*(int *)(param_2 + uVar2 * 4));
*(int *)((long)pvV... |
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.