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,182 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 4 != 2) {
return true;
}
return false;
}
| int main() {
assert(func0(5) == true);
assert(func0(10) == false);
assert(func0(15) == true);
return 0;
}
| O2 | c | func0:
endbr64
and $0x80000003,%edi
cmp $0x2,%edi
setne %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
and edi, 80000003h
cmp edi, 2
setnz al
retn | bool func0(int a1)
{
return (a1 & 0x80000003) != 2;
} | func0:
ENDBR64
AND EDI,0x80000003
CMP EDI,0x2
SETNZ AL
RET | bool func0(uint param_1)
{
return (param_1 & 0x80000003) != 2;
} |
4,183 | func0 |
#include <assert.h>
#include <stdbool.h>
| bool func0(int n) {
if (n % 4 != 2) {
return true;
}
return false;
}
| int main() {
assert(func0(5) == true);
assert(func0(10) == false);
assert(func0(15) == true);
return 0;
}
| O3 | c | func0:
endbr64
and $0x80000003,%edi
cmp $0x2,%edi
setne %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
and edi, 80000003h
cmp edi, 2
setnz al
retn | bool func0(int a1)
{
return (a1 & 0x80000003) != 2;
} | func0:
ENDBR64
AND EDI,0x80000003
CMP EDI,0x2
SETNZ AL
RET | bool func0(uint param_1)
{
return (param_1 & 0x80000003) != 2;
} |
4,184 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char** tokens;
int count;
} split_result;
| split_result func0(const char* text) {
split_result result;
result.tokens = NULL;
result.count = 0;
const char* delimiters[] = {"; ", ", ", "*", "\n"};
int num_delimiters = 4;
char* temp = strdup(text);
char* ptr = temp;
char* match;
int min_index;
while (*ptr) {
... | int main(){
split_result res1 = func0("Forces of the \ndarkness*are coming into the play.");
assert(res1.count == 3);
assert(strcmp(res1.tokens[0], "Forces of the ") == 0);
assert(strcmp(res1.tokens[1], "darkness") == 0);
assert(strcmp(res1.tokens[2], "are coming into the play.") == 0);
fo... | 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
movq $0x0,-0x50(%rbp)
movl $0x0,-0x48(%rbp)
lea 0xd83(%rip),%rax
mov %rax,-0x40(%rbp)
lea 0xd7b(%rip),%rax
mov %rax,-0x38(%rbp)
lea 0xd73(%ri... | 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+ptr], 0
mov dword ptr [rbp+var_48], 0
lea rax, unk_2008
mov [rbp+needle], rax
lea rax, unk_200B
mov [rbp+var_38], rax
lea rax,... | void * func0(const char *a1)
{
int v1; // eax
int v3; // [rsp+1Ch] [rbp-84h]
int i; // [rsp+20h] [rbp-80h]
char *haystack; // [rsp+28h] [rbp-78h]
size_t n; // [rsp+30h] [rbp-70h]
char *v7; // [rsp+38h] [rbp-68h]
char *v8; // [rsp+40h] [rbp-60h]
char *v9; // [rsp+48h] [rbp-58h]
void *ptr; // [rsp+50h] ... | 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 qword ptr [RBP + -0x50],0x0
MOV dword ptr [RBP + -0x48],0x0
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[0x10200b]
MOV qword ptr [RBP + -0x... | void * func0(char *param_1)
{
char *__ptr;
char *pcVar1;
size_t sVar2;
long in_FS_OFFSET;
int local_8c;
int local_88;
char *local_80;
ulong local_78;
void *local_58;
int local_50;
int *local_48 [5];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = (void *)0x0;
local... |
4,185 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char** tokens;
int count;
} split_result;
| split_result func0(const char* text) {
split_result result;
result.tokens = NULL;
result.count = 0;
const char* delimiters[] = {"; ", ", ", "*", "\n"};
int num_delimiters = 4;
char* temp = strdup(text);
char* ptr = temp;
char* match;
int min_index;
while (*ptr) {
... | int main(){
split_result res1 = func0("Forces of the \ndarkness*are coming into the play.");
assert(res1.count == 3);
assert(strcmp(res1.tokens[0], "Forces of the ") == 0);
assert(strcmp(res1.tokens[1], "darkness") == 0);
assert(strcmp(res1.tokens[2], "are coming into the play.") == 0);
fo... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0xdd2(%rip),%rax
mov %rax,0x20(%rsp)
lea 0xdc9(%rip),%rax
mov %rax,0x28(%rsp)
lea 0xdc0(%rip),%rax
mov %rax,0x30(%rsp)
lea 0xdb6(... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
lea rax, unk_2004
mov [rsp+78h+var_68], rax
lea rax, unk_2007
mov [rsp+78h+var_60], rax
lea rax, unk_200A
mov [rsp+78h+var_58... | long long func0()
{
_BYTE *v0; // rax
_BYTE *v1; // rbp
int v2; // r15d
long long v3; // rbx
long long v4; // rax
unsigned long long v5; // rax
unsigned long long v6; // r12
int v7; // r13d
long long v9; // [rsp+0h] [rbp-78h]
_BYTE *v10; // [rsp+8h] [rbp-70h]
_QWORD v11[13]; // [rsp+10h] [rbp-68h]... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x10],RAX
LEA RAX,[0x102007]
MOV qword ptr [RSP + 0x18],RAX
LEA RAX,[0x10200a]
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[0x10200c... | void * func0(char *param_1)
{
char *__ptr;
char *pcVar1;
size_t sVar2;
ulong __n;
ulong uVar3;
char *pcVar4;
ulong uVar5;
int iVar6;
long in_FS_OFFSET;
void *local_78;
int *local_68 [5];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_68[0] = &DAT_00102004;
local_68[1] ... |
4,186 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char** tokens;
int count;
} split_result;
| split_result func0(const char* text) {
split_result result;
result.tokens = NULL;
result.count = 0;
const char* delimiters[] = {"; ", ", ", "*", "\n"};
int num_delimiters = 4;
char* temp = strdup(text);
char* ptr = temp;
char* match;
int min_index;
while (*ptr) {
... | int main(){
split_result res1 = func0("Forces of the \ndarkness*are coming into the play.");
assert(res1.count == 3);
assert(strcmp(res1.tokens[0], "Forces of the ") == 0);
assert(strcmp(res1.tokens[1], "darkness") == 0);
assert(strcmp(res1.tokens[2], "are coming into the play.") == 0);
fo... | O2 | c | func0:
endbr64
push %r15
push %r14
lea 0xa85(%rip),%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0xa67(%rip),%rax
mov %r14,0x20(%rsp)
mov %rax,0x28(%rsp)
lea 0xa59(%rip),%rax
mov %rax,0x30(%rsp)
lea 0xa4f(... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
lea rax, unk_2004
mov [rsp+78h+var_68], rax
lea rax, unk_2007
mov [rsp+78h+var_60], rax
lea rax, unk_200A
mov [rsp+78h+var_58], rax
lea ra... | long long func0()
{
_BYTE *v0; // rax
_BYTE *v1; // r15
long long v2; // r12
int v3; // r13d
long long v4; // r14
long long v5; // rbp
unsigned long long v6; // rbx
long long v7; // rax
unsigned long long v8; // rax
_BYTE *v10; // [rsp+8h] [rbp-70h]
_QWORD v11[13]; // [rsp+10h] [rbp-68h]
v11[5]... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
LEA RAX,[0x102004]
MOV qword ptr [RSP + 0x10],RAX
LEA RAX,[0x102007]
MOV qword ptr [RSP + 0x18],RAX
LEA RAX,[0x10200a]
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[0x10200c]
MOV qword ... | void * func0(char *param_1)
{
long lVar1;
char *__ptr;
ulong __n;
char *pcVar2;
size_t sVar3;
void *__ptr_00;
long lVar4;
int iVar5;
char *pcVar6;
long in_FS_OFFSET;
int *local_70 [6];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_70[1] = &DAT_00102004;
local_70[2] = ... |
4,187 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char** tokens;
int count;
} split_result;
| split_result func0(const char* text) {
split_result result;
result.tokens = NULL;
result.count = 0;
const char* delimiters[] = {"; ", ", ", "*", "\n"};
int num_delimiters = 4;
char* temp = strdup(text);
char* ptr = temp;
char* match;
int min_index;
while (*ptr) {
... | int main(){
split_result res1 = func0("Forces of the \ndarkness*are coming into the play.");
assert(res1.count == 3);
assert(strcmp(res1.tokens[0], "Forces of the ") == 0);
assert(strcmp(res1.tokens[1], "darkness") == 0);
assert(strcmp(res1.tokens[2], "are coming into the play.") == 0);
fo... | O3 | c | func0:
endbr64
push %r15
lea 0xa6b(%rip),%rcx
push %r14
movq %rcx,%xmm0
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0xa46(%rip),%rax
movq %rax,%xmm1
punpcklqdq %xmm1,%xmm0
movaps %xmm0,0x10(%rsp)
callq 1140 <strdup@plt... | func0:
endbr64
push r15
lea rdx, asc_200A; "*"
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
movq xmm0, cs:off_3D70; "; "
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
lea rax, asc_200C; "\n"
movhps xmm0, cs:off_3D78; ", "
movq xmm1, rax
movaps xmmw... | char * func0(const char *a1)
{
char *v1; // rax
const char *v2; // rbx
char *v3; // rbp
int v4; // r12d
int v5; // r15d
size_t v6; // r14
char *v7; // rax
unsigned long long v8; // rax
int v9; // r15d
char *v10; // rax
unsigned long long v11; // rax
char *v12; // r13
char *v13; // rax
unsign... | func0:
ENDBR64
PUSH R15
LEA RDX,[0x10200a]
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOVQ XMM0,qword ptr [0x00103d70]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA RAX,[0x10200c]
MOVHPS XMM0,qword ptr [0x00103d78]
MOVQ XMM1,RAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVQ XMM0,... | void * func0(char *param_1)
{
char *__ptr;
ulong uVar1;
char *pcVar2;
ulong uVar3;
char *pcVar4;
size_t sVar5;
ulong __n;
void *__ptr_00;
char *pcVar6;
int iVar7;
uint uVar8;
long in_FS_OFFSET;
bool bVar9;
int *local_68 [5];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
... |
4,188 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(char** colors, int colors_len, char** patterns, int patterns_len){
if (colors_len != patterns_len){
return false;
}
// Initialize sdict as arrays: patterns and for each pattern, a list of colors.
// Also pset and sset
// To keep it simple, define max unique patterns and co... | int main(){
char* colors1[] = {"red", "green", "green"};
char* patterns1[] = {"a", "b", "b"};
assert(func0(colors1, 3, patterns1, 3) == true);
char* colors2[] = {"red", "green", "greenn"};
char* patterns2[] = {"a", "b", "b"};
assert(func0(colors2, 3, patterns2, 3) == false);
char*... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
lea -0x14000(%rsp),%r11
sub $0x1000,%rsp
orq $0x0,(%rsp)
cmp %r11,%rsp
jne 1199 <func0+0x10>
sub $0x250,%rsp
mov %rdi,-0x14238(%rbp)
mov %esi,-0x1423c(%rbp)
mov %rdx,-0x14248(%rbp)
mov %ecx,-0x14240(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
lea r11, [rsp+var_14000]
loc_1199:
sub rsp, 1000h
or [rsp+1000h+var_1000], 0
cmp rsp, r11
jnz short loc_1199
sub rsp, 250h
mov [rbp+var_14238], rdi
mov [rbp+var_1423C], esi
mov [rbp+var_14248], rdx
mov [rbp+var_14240], ecx
mov rax,... | long long func0(long long a1, int a2, long long a3, int a4)
{
int v5; // eax
int v6; // eax
char v9; // [rsp+23h] [rbp-14225h]
char v10; // [rsp+23h] [rbp-14225h]
int v11; // [rsp+24h] [rbp-14224h]
int v12; // [rsp+28h] [rbp-14220h]
int v13; // [rsp+2Ch] [rbp-1421Ch]
int i; // [rsp+30h] [rbp-14218h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
LEA R11,[RSP + -0x14000]
LAB_00101199:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x00101199
SUB RSP,0x250
MOV qword ptr [RBP + -0x14238],RDI
MOV dword ptr [RBP + -0x1423c],ESI
MOV qword ptr [RBP + -0x14248],RDX
MOV dword ptr [RBP + -0x14240],ECX
MOV RAX,qword ptr FS:[0x28... | int8 func0(long param_1,int param_2,long param_3,int param_4)
{
long lVar1;
char *pcVar2;
char *pcVar3;
bool bVar4;
int *puVar5;
int iVar6;
int8 uVar7;
int *puVar8;
long in_FS_OFFSET;
int iStack_1422c;
int iStack_14228;
int iStack_14224;
int iStack_14220;
int iStack_1421c;
int iStack_1421... |
4,189 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(char** colors, int colors_len, char** patterns, int patterns_len){
if (colors_len != patterns_len){
return false;
}
// Initialize sdict as arrays: patterns and for each pattern, a list of colors.
// Also pset and sset
// To keep it simple, define max unique patterns and co... | int main(){
char* colors1[] = {"red", "green", "green"};
char* patterns1[] = {"a", "b", "b"};
assert(func0(colors1, 3, patterns1, 3) == true);
char* colors2[] = {"red", "green", "greenn"};
char* patterns2[] = {"a", "b", "b"};
assert(func0(colors2, 3, patterns2, 3) == false);
char*... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
lea -0x14000(%rsp),%r11
sub $0x1000,%rsp
orq $0x0,(%rsp)
cmp %r11,%rsp
jne 119f <func0+0x16>
sub $0x228,%rsp
mov %fs:0x28,%rax
mov %rax,0x14218(%rsp)
xor %eax,%eax
cmp %ecx,%esi
jne 1407 <func0+0x27e>... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
lea r11, [rsp+30h+var_14030]
loc_119F:
sub rsp, 1000h
or [rsp+1030h+var_1030], 0
cmp rsp, r11
jnz short loc_119F
sub rsp, 228h
mov rax, fs:28h
mov [rsp+1258h+arg_12FB8], rax
xor eax, eax
cmp e... | // positive sp value has been detected, the output may be wrong!
long long func0(_QWORD *a1, int a2, _QWORD *a3, int a4)
{
long long result; // rax
_QWORD *v5; // rbp
int v7; // r13d
long long v8; // rdx
int v9; // eax
bool v10; // si
bool v11; // cl
long long v12; // rdx
long long v13; // rcx
_BYT... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA R11,[RSP + -0x14000]
LAB_0010119f:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x0010119f
SUB RSP,0x228
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x14218],RAX
XOR EAX,EAX
CMP ESI,ECX
JNZ 0x001012dc
TEST ECX,ECX
JLE 0x0010136d
MOV ... | int8 func0(int8 *param_1,int param_2,int8 *param_3,int param_4)
{
long lVar1;
uint uVar2;
char *pcVar3;
char *pcVar4;
int8 *puVar5;
int1 *puVar6;
int iVar7;
int iVar8;
int8 uVar9;
long lVar10;
ulong uVar11;
int8 *puVar12;
int1 *puVar13;
int iVar14;
long in_FS_OFFSET;
int1 auStack_14030 ... |
4,190 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(char** colors, int colors_len, char** patterns, int patterns_len){
if (colors_len != patterns_len){
return false;
}
// Initialize sdict as arrays: patterns and for each pattern, a list of colors.
// Also pset and sset
// To keep it simple, define max unique patterns and co... | int main(){
char* colors1[] = {"red", "green", "green"};
char* patterns1[] = {"a", "b", "b"};
assert(func0(colors1, 3, patterns1, 3) == true);
char* colors2[] = {"red", "green", "greenn"};
char* patterns2[] = {"a", "b", "b"};
assert(func0(colors2, 3, patterns2, 3) == false);
char*... | O2 | c | func0:
endbr64
mov %esi,%r8d
mov %rdx,%rsi
cmp %ecx,%r8d
jne 1630 <func0+0x20>
mov %r8d,%edx
jmpq 12a0 <func0.part.0>
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0_part_0:
push r15
push r14
push r13
push r12
push rbp
push rbx
lea r11, [rsp+30h+var_14030]
loc_12B2:
sub rsp, 1000h
or [rsp+1030h+var_1030], 0
cmp rsp, r11
jnz short loc_12B2
sub rsp, 238h
mov rax, fs:28h
mov [rsp+1268h+arg_12FB8], rax
xor eax, eax
test ed... | // positive sp value has been detected, the output may be wrong!
long long func0_part_0(long long *a1, long long *a2, int a3)
{
long long v3; // rbx
_BYTE *v4; // r12
long long v5; // r12
_BYTE *v6; // r13
long long v7; // r13
long long v8; // r14
int v9; // eax
long long v10; // rdx
long long result... | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA R11,[RSP + -0x14000]
LAB_001012b2:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x001012b2
SUB RSP,0x238
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x14228],RAX
XOR EAX,EAX
TEST EDX,EDX
JLE 0x001015c9
LEA EAX,[RDX + -0x1]
MOV qword p... | int8 func0_part_0(int8 param_1,long param_2,int param_3)
{
char *pcVar1;
char *pcVar2;
char *pcVar3;
int8 *puVar4;
int1 *puVar5;
int iVar6;
int iVar7;
int8 uVar8;
int1 *puVar9;
long lVar10;
int8 *puVar11;
long lVar12;
long lVar13;
long in_FS_OFFSET;
int1 auStack_14030 [81920];
puVar5... |
4,191 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(char** colors, int colors_len, char** patterns, int patterns_len){
if (colors_len != patterns_len){
return false;
}
// Initialize sdict as arrays: patterns and for each pattern, a list of colors.
// Also pset and sset
// To keep it simple, define max unique patterns and co... | int main(){
char* colors1[] = {"red", "green", "green"};
char* patterns1[] = {"a", "b", "b"};
assert(func0(colors1, 3, patterns1, 3) == true);
char* colors2[] = {"red", "green", "greenn"};
char* patterns2[] = {"a", "b", "b"};
assert(func0(colors2, 3, patterns2, 3) == false);
char*... | O3 | c | func0:
endbr64
mov %esi,%r8d
mov %rdx,%rsi
cmp %ecx,%r8d
jne 1660 <func0+0x20>
mov %r8d,%edx
jmpq 12d0 <func0.part.0>
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
lea r11, [rsp+30h+var_14030]
loc_1366:
sub rsp, 1000h
or [rsp+1030h+var_1030], 0
cmp rsp, r11
jnz short loc_1366
sub rsp, 228h
mov rax, fs:28h
mov [rsp+1258h+arg_12FB8], rax
xor eax, eax
cmp e... | // positive sp value has been detected, the output may be wrong!
long long func0(const char **a1, int a2, const char **a3, int a4)
{
const char **v4; // r13
const char *v5; // rbx
long long v6; // r12
const char **v7; // r14
const char *v8; // rbp
long long v9; // r14
const char **v10; // r15
long long... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA R11,[RSP + -0x14000]
LAB_00101366:
SUB RSP,0x1000
OR qword ptr [RSP],0x0
CMP RSP,R11
JNZ 0x00101366
SUB RSP,0x228
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x14218],RAX
XOR EAX,EAX
CMP ESI,ECX
JNZ 0x001015a4
TEST ESI,ESI
JLE 0x00101650
MOVS... | int8 func0(int8 param_1,int param_2,int8 *param_3,int param_4)
{
char *pcVar1;
char *pcVar2;
char *pcVar3;
int8 *puVar4;
int *puVar5;
int iVar6;
int8 uVar7;
ulong uVar8;
int *puVar9;
int8 *puVar10;
long lVar11;
int8 *puVar12;
long lVar13;
long in_FS_OFFSET;
int auStack_14030 [81920];
... |
4,192 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| char* func0(int test_list[][3], int list_size, int K) {
static char res[100];
int index = 0;
res[index++] = '[';
for (int i = 0; i < list_size; i++) {
bool divisible = true;
for (int j = 0; j < 3; j++) {
if (test_list[i][j] % K != 0) {
divisible = fals... | int main() {
int list1[][3] = {{6, 24, 12}, {7, 9, 6}, {12, 18, 21}};
int list2[][3] = {{5, 25, 30}, {4, 2, 3}, {7, 8, 9}};
int list3[][3] = {{7, 9, 16}, {8, 16, 4}, {19, 17, 18}};
assert(strcmp(func0(list1, 3, 6), "[(6, 24, 12)]") == 0);
assert(strcmp(func0(list2, 3, 5), "[(5, 25, 30)]")... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %edx,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x28(%rbp)
mov -0x28(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x28(%rbp)
cltq
lea 0x2e59(%rip),%rdx
m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_28], 0
mov eax, [rbp+var_28]
lea edx, [rax+1]
mov [rbp+var_28], edx
cdqe
lea rdx, res_... | _BYTE * func0(long long a1, int a2, int a3)
{
int v3; // eax
int v4; // eax
int v5; // eax
int v6; // eax
int v7; // eax
char v10; // [rsp+17h] [rbp-29h]
int v11; // [rsp+18h] [rbp-28h]
int v12; // [rsp+18h] [rbp-28h]
int i; // [rsp+1Ch] [rbp-24h]
int j; // [rsp+20h] [rbp-20h]
int k; // [rsp+24h] ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x28],0x0
MOV EAX,dword ptr [RBP + -0x28]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP +... | int1 * func0(long param_1,int param_2,int param_3)
{
int iVar1;
bool bVar2;
long in_FS_OFFSET;
int local_30;
int local_2c;
int local_28;
int local_24;
int local_20;
char local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = 1;
res_1[0] = 0x5b;
local_2c = 0;
... |
4,193 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| char* func0(int test_list[][3], int list_size, int K) {
static char res[100];
int index = 0;
res[index++] = '[';
for (int i = 0; i < list_size; i++) {
bool divisible = true;
for (int j = 0; j < 3; j++) {
if (test_list[i][j] % K != 0) {
divisible = fals... | int main() {
int list1[][3] = {{6, 24, 12}, {7, 9, 6}, {12, 18, 21}};
int list2[][3] = {{5, 25, 30}, {4, 2, 3}, {7, 8, 9}};
int list3[][3] = {{7, 9, 16}, {8, 16, 4}, {19, 17, 18}};
assert(strcmp(func0(list1, 3, 6), "[(6, 24, 12)]") == 0);
assert(strcmp(func0(list2, 3, 5), "[(5, 25, 30)]")... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movb $0x5b,0x2e8e(%rip)
test %esi,%esi
jle 11f2 <func0+0x69>
mov %edx,%r12d
mov %rdi,%rbp
lea -0x1(%rsi),%eax
lea (%rax,%rax,2),%rax
le... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov [rsp+78h+var_6C], edx
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov cs:res_1, 5Bh ; '['
test esi, esi
jle short loc_1208
mov rbp, rdi
lea eax, [rsi-1]
lea rax, ... | char * func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rbp
int v4; // esi
int v5; // ecx
char *result; // rax
int v7; // eax
int v8; // r12d
long long i; // r13
char v10; // dl
long long v11; // rax
long long v13; // [rsp+10h] [rbp-68h]
_BYTE v14[10]; // [rsp+2Eh] [rbp-4Ah] BYREF
unsigned lon... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RSP + 0xc],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV byte ptr [0x00104040],0x5b
TEST ESI,ESI
JLE 0x00101208
MOV RBP,RDI
LEA EAX,[RSI + -0x1]
LEA RAX,[RAX + RAX*0x2]
LEA RAX,[RDI + RAX*0x... | void func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
long lVar3;
char cVar4;
int iVar5;
long lVar6;
long lVar7;
long in_FS_OFFSET;
char local_4a [10];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1 = 0x5b;
if (param_2 < 1) {
iVar5 = 1;
}
else ... |
4,194 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| char* func0(int test_list[][3], int list_size, int K) {
static char res[100];
int index = 0;
res[index++] = '[';
for (int i = 0; i < list_size; i++) {
bool divisible = true;
for (int j = 0; j < 3; j++) {
if (test_list[i][j] % K != 0) {
divisible = fals... | int main() {
int list1[][3] = {{6, 24, 12}, {7, 9, 6}, {12, 18, 21}};
int list2[][3] = {{5, 25, 30}, {4, 2, 3}, {7, 8, 9}};
int list3[][3] = {{7, 9, 16}, {8, 16, 4}, {19, 17, 18}};
assert(strcmp(func0(list1, 3, 6), "[(6, 24, 12)]") == 0);
assert(strcmp(func0(list2, 3, 5), "[(5, 25, 30)]")... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movb $0x5b,0x2c87(%rip)
test %esi,%esi
jle 1522 <func0+0x192>
lea -0x1(%rsi),%eax
lea 0x2c75(%rip),%r13
mov %edx,%r14d
mov %rdi,%rbp
le... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov cs:res_1, 5Bh ; '['
test esi, esi
jle loc_151E
lea eax, [rsi-1]
lea r13, res_1
mov r15d, edx
mov rbp, rdi
lea rax,... | char * func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v4; // rbp
int v5; // ecx
int v6; // eax
int v7; // ebx
long long v8; // r9
char v9; // dl
long long v10; // rax
_BYTE *v11; // rcx
long long v12; // rax
int v13; // eax
long long v15; // [rsp+0h] [rbp-68h]
_BYTE v16[10]; // [rsp+1Eh] [rbp-4Ah] ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV byte ptr [0x00104040],0x5b
TEST ESI,ESI
JLE 0x0010151e
LEA EAX,[RSI + -0x1]
LEA R13,[0x104040]
MOV R15D,EDX
MOV RBP,RDI
LEA RAX,[RAX + RAX*0x2]
MOV ECX,0x1
LEA R14... | int1 * func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
long lVar2;
int iVar3;
char cVar4;
int iVar5;
long lVar6;
long lVar7;
long in_FS_OFFSET;
char local_4a [10];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
res_1 = 0x5b;
if (param_2 < 1) {
iVar5 = 2;
iVar3... |
4,195 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
| char* func0(int test_list[][3], int list_size, int K) {
static char res[100];
int index = 0;
res[index++] = '[';
for (int i = 0; i < list_size; i++) {
bool divisible = true;
for (int j = 0; j < 3; j++) {
if (test_list[i][j] % K != 0) {
divisible = fals... | int main() {
int list1[][3] = {{6, 24, 12}, {7, 9, 6}, {12, 18, 21}};
int list2[][3] = {{5, 25, 30}, {4, 2, 3}, {7, 8, 9}};
int list3[][3] = {{7, 9, 16}, {8, 16, 4}, {19, 17, 18}};
assert(strcmp(func0(list1, 3, 6), "[(6, 24, 12)]") == 0);
assert(strcmp(func0(list2, 3, 5), "[(5, 25, 30)]")... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movb $0x5b,0x2ce7(%rip)
test %esi,%esi
jle 1567 <func0+0x237>
lea -0x1(%rsi),%eax
mov %edx,%r13d
mov %rdi,%r12
mov $0x1,%ecx
lea (%r... | func0:
endbr64
push r15
mov ecx, 1
push r14
push r13
push r12
push rbp
lea rbp, res_1
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov cs:res_1, 5Bh ; '['
mov eax, 2
test esi, esi
jle loc_151E
movsxd rsi, esi
mov rbx, rdi
mov ... | char * func0(unsigned int *a1, int a2, int a3)
{
int v3; // ecx
int v4; // eax
unsigned int *v5; // rbx
long long v7; // rax
int v8; // r15d
unsigned int *v9; // r14
int v10; // eax
int v11; // edx
char v13; // [rsp+1Eh] [rbp-4Ah] BYREF
char v14; // [rsp+1Fh] [rbp-49h]
char v15; // [rsp+20h] [rbp-... | func0:
ENDBR64
PUSH R15
MOV ECX,0x1
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
LEA RBP,[0x104040]
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV byte ptr [0x00104040],0x5b
MOV EAX,0x2
TEST ESI,ESI
JLE 0x0010151e
MOVSXD RSI,ESI
MOV RBX,RDI
MOV R13D,EDX
MOV ECX,0x1
LEA RAX,[RSI ... | int1 * func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
long lVar3;
int iVar4;
int iVar5;
int *piVar6;
long in_FS_OFFSET;
char local_4a;
char local_49;
char local_48;
char local_47;
char local_46;
char local_45;
char local_44;
char local_43;
char local_42;
long lo... |
4,196 | func0 |
#include <assert.h>
| int func0(int m, int n) {
if (n < m) {
int temp = m;
m = n;
n = temp;
}
return (int)(m * (m + 1) * (2 * m + 1) / 6 + (n - m) * m * (m + 1) / 2);
}
| int main() {
assert(func0(4, 3) == 20);
assert(func0(2, 2) == 5);
assert(func0(1, 1) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x14(%rbp),%eax
jge 1171 <func0+0x28>
mov -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0x18(%rbp)
mov -0x14(... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jge short loc_1171
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
mov eax, [rbp+var_18]
mov [rbp+var_14], eax
mov eax, [rbp+var_4]
mov [rbp+var_18],... | long long func0(int a1, int a2)
{
int v3; // [rsp+0h] [rbp-18h]
int v4; // [rsp+4h] [rbp-14h]
v4 = a1;
v3 = a2;
if ( a2 < a1 )
{
v4 = a2;
v3 = a1;
}
return (unsigned int)((2 * v4 + 1) * v4 * (v4 + 1) / 6 + (v4 + 1) * v4 * (v3 - v4) / 2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x00101171
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ... | int func0(int param_1,int param_2)
{
int4 local_20;
int4 local_1c;
local_20 = param_2;
local_1c = param_1;
if (param_2 < param_1) {
local_20 = param_1;
local_1c = param_2;
}
return ((local_20 - local_1c) * local_1c * (local_1c + 1)) / 2 +
((local_1c + 1) * local_1c * (local_1c * 2 + 1... |
4,197 | func0 |
#include <assert.h>
| int func0(int m, int n) {
if (n < m) {
int temp = m;
m = n;
n = temp;
}
return (int)(m * (m + 1) * (2 * m + 1) / 6 + (n - m) * m * (m + 1) / 2);
}
| int main() {
assert(func0(4, 3) == 20);
assert(func0(2, 2) == 5);
assert(func0(1, 1) == 1);
return 0;
}
| O1 | c | func0:
endbr64
cmp %edi,%esi
jge 1157 <func0+0xe>
mov %edi,%eax
mov %esi,%edi
mov %eax,%esi
lea 0x1(%rdi),%ecx
lea 0x1(%rdi,%rdi,1),%edx
mov %ecx,%eax
imul %edi,%eax
imul %eax,%edx
movslq %edx,%rax
imul $0x2aaaaaab,%rax,%rax
shr $0x20,%rax
sar $0x1f,%edx
sub %edx,%eax
mov %eax,... | func0:
endbr64
cmp esi, edi
jge short loc_1157
mov eax, edi
mov edi, esi
mov esi, eax
loc_1157:
lea ecx, [rdi+1]
lea edx, [rdi+rdi+1]
mov eax, ecx
imul eax, edi
imul edx, eax
movsxd rax, edx
imul rax, 2AAAAAABh
shr rax, 20h
sar edx, 1Fh
sub eax, edx
sub esi, edi... | long long func0(int a1, int a2)
{
int v2; // eax
if ( a2 < a1 )
{
v2 = a1;
a1 = a2;
a2 = v2;
}
return (unsigned int)((a1 + 1) * a1 * (a2 - a1) / 2 + a1 * (a1 + 1) * (2 * a1 + 1) / 6);
} | func0:
ENDBR64
CMP ESI,EDI
JGE 0x00101157
MOV EAX,EDI
MOV EDI,ESI
MOV ESI,EAX
LAB_00101157:
LEA ECX,[RDI + 0x1]
LEA EDX,[RDI + RDI*0x1 + 0x1]
MOV EAX,ECX
IMUL EAX,EDI
IMUL EDX,EAX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SAR EDX,0x1f
SUB EAX,EDX
SUB ESI,EDI
IMUL ESI,EDI
IMUL ESI,ECX
MOV EDX,ESI
SHR EDX,0x1f
... | int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_2;
if (param_2 < param_1) {
iVar1 = param_1;
param_1 = param_2;
}
return ((param_1 * 2 + 1) * (param_1 + 1) * param_1) / 6 +
((iVar1 - param_1) * param_1 * (param_1 + 1)) / 2;
} |
4,198 | func0 |
#include <assert.h>
| int func0(int m, int n) {
if (n < m) {
int temp = m;
m = n;
n = temp;
}
return (int)(m * (m + 1) * (2 * m + 1) / 6 + (n - m) * m * (m + 1) / 2);
}
| int main() {
assert(func0(4, 3) == 20);
assert(func0(2, 2) == 5);
assert(func0(1, 1) == 1);
return 0;
}
| O2 | c | func0:
endbr64
cmp %edi,%esi
jge 114e <func0+0xe>
mov %edi,%eax
mov %esi,%edi
mov %eax,%esi
lea 0x1(%rdi),%ecx
lea 0x1(%rdi,%rdi,1),%edx
sub %edi,%esi
mov %ecx,%eax
imul %edi,%esi
imul %edi,%eax
imul %ecx,%esi
imul %eax,%edx
movslq %edx,%rax
sar $0x1f,%edx
imul $0x2aaaaaab,%rax,%... | func0:
endbr64
cmp esi, edi
jge short loc_120E
mov eax, edi
mov edi, esi
mov esi, eax
loc_120E:
lea ecx, [rdi+1]
lea edx, [rdi+rdi+1]
sub esi, edi
mov eax, ecx
imul esi, edi
imul eax, edi
imul esi, ecx
imul edx, eax
movsxd rax, edx
sar edx, 1Fh
imul rax, 2AAAAAABh... | long long func0(int a1, int a2)
{
int v2; // eax
if ( a2 < a1 )
{
v2 = a1;
a1 = a2;
a2 = v2;
}
return (unsigned int)((a1 + 1) * a1 * (a2 - a1) / 2 + a1 * (a1 + 1) * (2 * a1 + 1) / 6);
} | func0:
ENDBR64
CMP ESI,EDI
JGE 0x0010120e
MOV EAX,EDI
MOV EDI,ESI
MOV ESI,EAX
LAB_0010120e:
LEA ECX,[RDI + 0x1]
LEA EDX,[RDI + RDI*0x1 + 0x1]
SUB ESI,EDI
MOV EAX,ECX
IMUL ESI,EDI
IMUL EAX,EDI
IMUL ESI,ECX
IMUL EDX,EAX
MOVSXD RAX,EDX
SAR EDX,0x1f
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SUB EAX,EDX
MOV EDX,ESI
SHR EDX,0x1f
... | int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_2;
if (param_2 < param_1) {
iVar1 = param_1;
param_1 = param_2;
}
return ((param_1 * 2 + 1) * (param_1 + 1) * param_1) / 6 +
((iVar1 - param_1) * param_1 * (param_1 + 1)) / 2;
} |
4,199 | func0 |
#include <assert.h>
| int func0(int m, int n) {
if (n < m) {
int temp = m;
m = n;
n = temp;
}
return (int)(m * (m + 1) * (2 * m + 1) / 6 + (n - m) * m * (m + 1) / 2);
}
| int main() {
assert(func0(4, 3) == 20);
assert(func0(2, 2) == 5);
assert(func0(1, 1) == 1);
return 0;
}
| O3 | c | func0:
endbr64
cmp %edi,%esi
jge 114e <func0+0xe>
mov %edi,%eax
mov %esi,%edi
mov %eax,%esi
lea 0x1(%rdi),%ecx
lea 0x1(%rdi,%rdi,1),%edx
sub %edi,%esi
mov %ecx,%eax
imul %edi,%esi
imul %edi,%eax
imul %ecx,%esi
imul %eax,%edx
movslq %edx,%rax
sar $0x1f,%edx
imul $0x2aaaaaab,%rax,%... | func0:
endbr64
cmp esi, edi
jl short loc_114E
mov eax, esi
mov esi, edi
mov edi, eax
loc_114E:
lea ecx, [rsi+1]
lea edx, [rsi+rsi+1]
sub edi, esi
mov eax, ecx
imul edi, esi
imul eax, esi
imul edi, ecx
imul edx, eax
movsxd rax, edx
sar edx, 1Fh
imul rax, 2AAAAAABh... | long long func0(int a1, int a2)
{
int v2; // eax
if ( a2 >= a1 )
{
v2 = a2;
a2 = a1;
a1 = v2;
}
return (unsigned int)((a2 + 1) * a2 * (a1 - a2) / 2 + a2 * (a2 + 1) * (2 * a2 + 1) / 6);
} | func0:
ENDBR64
CMP ESI,EDI
JL 0x0010114e
MOV EAX,ESI
MOV ESI,EDI
MOV EDI,EAX
LAB_0010114e:
LEA ECX,[RSI + 0x1]
LEA EDX,[RSI + RSI*0x1 + 0x1]
SUB EDI,ESI
MOV EAX,ECX
IMUL EDI,ESI
IMUL EAX,ESI
IMUL EDI,ECX
IMUL EDX,EAX
MOVSXD RAX,EDX
SAR EDX,0x1f
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SUB EAX,EDX
MOV EDX,EDI
SHR EDX,0x1f
A... | int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_2;
if (param_1 <= param_2) {
iVar1 = param_1;
param_1 = param_2;
}
return ((iVar1 * 2 + 1) * (iVar1 + 1) * iVar1) / 6 + ((param_1 - iVar1) * iVar1 * (iVar1 + 1)) / 2
;
} |
4,200 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
return (n % 11 == 0);
}
| int main() {
assert(func0(12345) == false);
assert(func0(1212112) == true);
assert(func0(1212) == false);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%ecx
movslq %ecx,%rax
imul $0x2e8ba2e9,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar %edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
add %edx,%eax
... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov ecx, [rbp+var_4]
movsxd rax, ecx
imul rax, 2E8BA2E9h
shr rax, 20h
mov edx, eax
sar edx, 1
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
add eax, edx
sub... | bool func0(int a1)
{
return a1 % 11 == 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x2e8ba2e9
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x1
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
SUB ECX,EAX
MOV EDX,ECX
TEST EDX,EDX
SETZ AL
POP ... | int4 func0(int param_1)
{
return CONCAT31((int3)((uint)((param_1 / 0xb) * 0xb) >> 8),param_1 % 0xb == 0);
} |
4,201 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
return (n % 11 == 0);
}
| int main() {
assert(func0(12345) == false);
assert(func0(1212112) == true);
assert(func0(1212) == false);
return 0;
}
| O1 | c | func0:
endbr64
movslq %edi,%rax
imul $0x2e8ba2e9,%rax,%rax
sar $0x21,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,4),%edx
lea (%rax,%rdx,2),%eax
cmp %eax,%edi
sete %al
retq
| func0:
endbr64
movsxd rax, edi
imul rax, 2E8BA2E9h
sar rax, 21h
mov edx, edi
sar edx, 1Fh
sub eax, edx
lea edx, [rax+rax*4]
lea eax, [rax+rdx*2]
cmp edi, eax
setz al
retn | bool func0(int a1)
{
return a1 == 11 * (a1 / 11);
} | func0:
ENDBR64
MOVSXD RAX,EDI
IMUL RAX,RAX,0x2e8ba2e9
SAR RAX,0x21
MOV EDX,EDI
SAR EDX,0x1f
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x4]
LEA EAX,[RAX + RDX*0x2]
CMP EDI,EAX
SETZ AL
RET | int4 func0(int param_1)
{
int iVar1;
iVar1 = (param_1 / 0xb) * 0xb;
return CONCAT31((int3)((uint)iVar1 >> 8),param_1 == iVar1);
} |
4,202 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
return (n % 11 == 0);
}
| int main() {
assert(func0(12345) == false);
assert(func0(1212112) == true);
assert(func0(1212) == false);
return 0;
}
| O2 | c | func0:
endbr64
imul $0xba2e8ba3,%edi,%edi
add $0xba2e8ba,%edi
cmp $0x1745d174,%edi
setbe %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
imul edi, 0BA2E8BA3h
add edi, 0BA2E8BAh
cmp edi, 1745D174h
setbe al
retn | bool func0(int a1)
{
return (unsigned int)(-1171354717 * a1 + 195225786) <= 0x1745D174;
} | func0:
ENDBR64
IMUL EDI,EDI,-0x45d1745d
ADD EDI,0xba2e8ba
CMP EDI,0x1745d174
SETBE AL
RET | bool func0(int param_1)
{
return param_1 * -0x45d1745d + 0xba2e8baU < 0x1745d175;
} |
4,203 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
return (n % 11 == 0);
}
| int main() {
assert(func0(12345) == false);
assert(func0(1212112) == true);
assert(func0(1212) == false);
return 0;
}
| O3 | c | func0:
endbr64
imul $0xba2e8ba3,%edi,%edi
add $0xba2e8ba,%edi
cmp $0x1745d174,%edi
setbe %al
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
imul edi, 0BA2E8BA3h
add edi, 0BA2E8BAh
cmp edi, 1745D174h
setbe al
retn | bool func0(int a1)
{
return (unsigned int)(-1171354717 * a1 + 195225786) <= 0x1745D174;
} | func0:
ENDBR64
IMUL EDI,EDI,-0x45d1745d
ADD EDI,0xba2e8ba
CMP EDI,0x1745d174
SETBE AL
RET | bool func0(int param_1)
{
return param_1 * -0x45d1745d + 0xba2e8baU < 0x1745d175;
} |
4,204 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n % 2 != 0) {
return (n + 1) / 2;
}
int count = 0;
for (int i = 0; i < 32; i++) { // Assuming 32 bit integer
count += (n >> i) & 1;
}
int ans = n / 2;
if (count % 2 != 0) {
ans += 1;
}
return ans;
}
| int main() {
assert(func0(5) == 3);
assert(func0(10) == 5);
assert(func0(15) == 8);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
and $0x1,%eax
test %eax,%eax
je 116f <func0+0x26>
mov -0x14(%rbp),%eax
add $0x1,%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
jmp 11bb <func0+0x72>
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
and eax, 1
test eax, eax
jz short loc_116F
mov eax, [rbp+var_14]
add eax, 1
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
jmp short loc_11BB
loc_116F:
mov [rbp+var_C], 0
mov ... | long long func0(int a1)
{
int v2; // [rsp+8h] [rbp-Ch]
int i; // [rsp+Ch] [rbp-8h]
unsigned int v4; // [rsp+10h] [rbp-4h]
if ( (a1 & 1) != 0 )
return (unsigned int)((a1 + 1) / 2);
v2 = 0;
for ( i = 0; i <= 31; ++i )
v2 += (a1 >> i) & 1;
v4 = a1 / 2;
if ( (v2 & 1) != 0 )
++v4;
return v4;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
TEST EAX,EAX
JZ 0x0010116f
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
JMP 0x001011bb
LAB_0010116f:
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0... | int func0(uint param_1)
{
int iVar1;
int4 local_14;
int4 local_10;
if ((param_1 & 1) == 0) {
local_14 = 0;
for (local_10 = 0; local_10 < 0x20; local_10 = local_10 + 1) {
local_14 = local_14 + ((int)param_1 >> ((byte)local_10 & 0x1f) & 1U);
}
iVar1 = (int)param_1 / 2;
if ((local_14 ... |
4,205 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n % 2 != 0) {
return (n + 1) / 2;
}
int count = 0;
for (int i = 0; i < 32; i++) { // Assuming 32 bit integer
count += (n >> i) & 1;
}
int ans = n / 2;
if (count % 2 != 0) {
ans += 1;
}
return ans;
}
| int main() {
assert(func0(5) == 3);
assert(func0(10) == 5);
assert(func0(15) == 8);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%ecx
mov $0x0,%edx
test $0x1,%dil
jne 1181 <func0+0x38>
mov %edi,%eax
sar %cl,%eax
and $0x1,%eax
add %eax,%edx
add $0x1,%ecx
cmp $0x20,%ecx
jne 115d <func0+0x14>
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
and $0x1,%edx
cmp $0x1,%edx
sbb ... | func0:
endbr64
mov ecx, 0
mov edx, 0
test dil, 1
jnz short loc_1181
loc_115D:
mov eax, edi
sar eax, cl
and eax, 1
add edx, eax
add ecx, 1
cmp ecx, 20h ; ' '
jnz short loc_115D
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
and edx, 1
cmp edx, 1
sbb ... | long long func0(int a1)
{
int v1; // ecx
int v2; // edx
v1 = 0;
v2 = 0;
if ( (a1 & 1) != 0 )
return (unsigned int)((a1 + 1) / 2);
do
v2 += (a1 >> v1++) & 1;
while ( v1 != 32 );
return a1 / 2 - ((unsigned int)((v2 & 1) == 0) - 1);
} | func0:
ENDBR64
MOV ECX,0x0
MOV EDX,0x0
TEST DIL,0x1
JNZ 0x00101181
LAB_0010115d:
MOV EAX,EDI
SAR EAX,CL
AND EAX,0x1
ADD EDX,EAX
ADD ECX,0x1
CMP ECX,0x20
JNZ 0x0010115d
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
AND EDX,0x1
CMP EDX,0x1
SBB EAX,-0x1
RET
LAB_00101181:
ADD EDI,0x1
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI... | int func0(ulong param_1)
{
int iVar1;
uint uVar2;
int iVar3;
iVar1 = 0;
uVar2 = 0;
iVar3 = (int)param_1;
if ((param_1 & 1) == 0) {
do {
uVar2 = uVar2 + (iVar3 >> ((byte)iVar1 & 0x1f) & 1U);
iVar1 = iVar1 + 1;
} while (iVar1 != 0x20);
return (((int)(((uint)(param_1 >> 0x1f) & 1)... |
4,206 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n % 2 != 0) {
return (n + 1) / 2;
}
int count = 0;
for (int i = 0; i < 32; i++) { // Assuming 32 bit integer
count += (n >> i) & 1;
}
int ans = n / 2;
if (count % 2 != 0) {
ans += 1;
}
return ans;
}
| int main() {
assert(func0(5) == 3);
assert(func0(10) == 5);
assert(func0(15) == 8);
return 0;
}
| O2 | c | func0:
endbr64
xor %edx,%edx
xor %ecx,%ecx
test $0x1,%dil
jne 11d8 <func0+0x38>
xchg %ax,%ax
mov %edi,%eax
sar %cl,%eax
add $0x1,%ecx
and $0x1,%eax
add %eax,%edx
cmp $0x20,%ecx
jne 11b0 <func0+0x10>
mov %edi,%eax
and $0x1,%edx
shr $0x1f,%eax
add %edi,%eax
sar %eax
cmp ... | func0:
endbr64
xor edx, edx
xor ecx, ecx
test dil, 1
jnz short loc_11E8
xchg ax, ax
loc_11C0:
mov eax, edi
sar eax, cl
add ecx, 1
and eax, 1
add edx, eax
cmp ecx, 20h ; ' '
jnz short loc_11C0
mov eax, edi
and edx, 1
shr eax, 1Fh
add eax, edi
sar eax, 1
c... | long long func0(int a1)
{
char v1; // dl
int v2; // ecx
int v3; // eax
v1 = 0;
v2 = 0;
if ( (a1 & 1) != 0 )
return (unsigned int)((a1 + 1) / 2);
do
{
v3 = a1 >> v2++;
v1 += v3 & 1;
}
while ( v2 != 32 );
return a1 / 2 - ((unsigned int)((v1 & 1) == 0) - 1);
} | func0:
ENDBR64
XOR EDX,EDX
XOR ECX,ECX
TEST DIL,0x1
JNZ 0x001011e8
NOP
LAB_001011c0:
MOV EAX,EDI
SAR EAX,CL
ADD ECX,0x1
AND EAX,0x1
ADD EDX,EAX
CMP ECX,0x20
JNZ 0x001011c0
MOV EAX,EDI
AND EDX,0x1
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
CMP EDX,0x1
SBB EAX,-0x1
RET
LAB_001011e8:
ADD EDI,0x1
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX... | int func0(ulong param_1)
{
byte bVar1;
int iVar2;
uint uVar3;
int iVar4;
uVar3 = 0;
iVar2 = 0;
iVar4 = (int)param_1;
if ((param_1 & 1) == 0) {
do {
bVar1 = (byte)iVar2;
iVar2 = iVar2 + 1;
uVar3 = uVar3 + (iVar4 >> (bVar1 & 0x1f) & 1U);
} while (iVar2 != 0x20);
return ((... |
4,207 | func0 | #include <stdio.h>
#include <assert.h>
| int func0(int n) {
if (n % 2 != 0) {
return (n + 1) / 2;
}
int count = 0;
for (int i = 0; i < 32; i++) { // Assuming 32 bit integer
count += (n >> i) & 1;
}
int ans = n / 2;
if (count % 2 != 0) {
ans += 1;
}
return ans;
}
| int main() {
assert(func0(5) == 3);
assert(func0(10) == 5);
assert(func0(15) == 8);
return 0;
}
| O3 | c | func0:
endbr64
xor %edx,%edx
xor %ecx,%ecx
test $0x1,%dil
jne 11d8 <func0+0x38>
xchg %ax,%ax
mov %edi,%eax
sar %cl,%eax
add $0x1,%ecx
and $0x1,%eax
add %eax,%edx
cmp $0x20,%ecx
jne 11b0 <func0+0x10>
mov %edi,%eax
and $0x1,%edx
shr $0x1f,%eax
add %edi,%eax
sar %eax
cmp ... | func0:
endbr64
mov edx, edi
xor ecx, ecx
and edx, 1
jnz short loc_11E8
nop dword ptr [rax]
loc_11C0:
mov eax, edi
sar eax, cl
add ecx, 1
and eax, 1
add edx, eax
cmp ecx, 20h ; ' '
jnz short loc_11C0
mov eax, edi
and edx, 1
shr eax, 1Fh
add eax, edi
sar ... | long long func0(int a1)
{
int v1; // ecx
char v2; // dl
int v3; // eax
v1 = 0;
v2 = a1 & 1;
if ( (a1 & 1) != 0 )
return (unsigned int)((a1 + 1) / 2);
do
{
v3 = a1 >> v1++;
v2 += v3 & 1;
}
while ( v1 != 32 );
return a1 / 2 - ((unsigned int)((v2 & 1) == 0) - 1);
} | func0:
ENDBR64
MOV EDX,EDI
XOR ECX,ECX
AND EDX,0x1
JNZ 0x001011e8
NOP dword ptr [RAX]
LAB_001011c0:
MOV EAX,EDI
SAR EAX,CL
ADD ECX,0x1
AND EAX,0x1
ADD EDX,EAX
CMP ECX,0x20
JNZ 0x001011c0
MOV EAX,EDI
AND EDX,0x1
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
CMP EDX,0x1
SBB EAX,-0x1
RET
LAB_001011e8:
ADD EDI,0x1
MOV EAX,EDI
SHR E... | int func0(uint param_1)
{
byte bVar1;
int iVar2;
uint uVar3;
iVar2 = 0;
uVar3 = param_1 & 1;
if (uVar3 == 0) {
do {
bVar1 = (byte)iVar2;
iVar2 = iVar2 + 1;
uVar3 = uVar3 + ((int)param_1 >> (bVar1 & 0x1f) & 1U);
} while (iVar2 != 0x20);
return ((int)param_1 / 2 + 1) - (uint)... |
4,208 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *s) {
char *token = strtok(s, " ");
while (token != NULL) {
if (strlen(token) % 2 != 0) {
return 1;
} else {
return 0;
}
token = strtok(NULL, " ");
}
return 0;
}
| int main() {
assert(func0("Hadoop") == 0);
assert(func0("great") == 1);
assert(func0("structure") == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
lea 0xe64(%rip),%rsi
mov %rax,%rdi
callq 1090 <strtok@plt>
mov %rax,-0x8(%rbp)
cmpq $0x0,-0x8(%rbp)
je 11d9 <func0+0x50>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
and $... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
lea rdx, delim; " "
mov rsi, rdx; delim
mov rdi, rax; s
call _strtok
mov [rbp+var_8], rax
nop
cmp [rbp+var_8], 0
jz short loc_11DD
mov rax, [rbp+var_8]
mov rdi, rax; s
call _strl... | _BOOL8 func0(char *a1)
{
const char *v2; // [rsp+18h] [rbp-8h]
v2 = strtok(a1, " ");
return v2 && (strlen(v2) & 1) != 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102004]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101090
MOV qword ptr [RBP + -0x8],RAX
NOP
CMP qword ptr [RBP + -0x8],0x0
JZ 0x001011dd
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101070
AND EAX,0... | int8 func0(char *param_1)
{
char *__s;
size_t sVar1;
int8 uVar2;
__s = strtok(param_1," ");
if (__s == (char *)0x0) {
uVar2 = 0;
}
else {
sVar1 = strlen(__s);
if ((sVar1 & 1) == 0) {
uVar2 = 0;
}
else {
uVar2 = 1;
}
}
return uVar2;
} |
4,209 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *s) {
char *token = strtok(s, " ");
while (token != NULL) {
if (strlen(token) % 2 != 0) {
return 1;
} else {
return 0;
}
token = strtok(NULL, " ");
}
return 0;
}
| int main() {
assert(func0("Hadoop") == 0);
assert(func0("great") == 1);
assert(func0("structure") == 1);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x8,%rsp
lea 0xe8c(%rip),%rsi
callq 1070 <strtok@plt>
mov %rax,%rdi
mov $0x0,%eax
test %rdi,%rdi
je 1198 <func0+0x2f>
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
mov %ecx,%eax
and $0x1,%eax
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
lea rsi, unk_2004
call _strtok
mov rdi, rax
mov eax, 0
test rdi, rdi
jz short loc_11B2
call _strlen
and eax, 1
loc_11B2:
add rsp, 8
retn | long long func0(long long a1)
{
long long v1; // rdi
long long result; // rax
v1 = strtok(a1, &unk_2004);
result = 0LL;
if ( v1 )
return strlen() & 1;
return result;
} | func0:
ENDBR64
SUB RSP,0x8
LEA RSI,[0x102004]
CALL 0x00101090
MOV RDI,RAX
MOV EAX,0x0
TEST RDI,RDI
JZ 0x001011b2
CALL 0x00101070
AND EAX,0x1
LAB_001011b2:
ADD RSP,0x8
RET | uint func0(char *param_1)
{
uint uVar1;
char *__s;
size_t sVar2;
__s = strtok(param_1," ");
uVar1 = 0;
if (__s != (char *)0x0) {
sVar2 = strlen(__s);
uVar1 = (uint)sVar2 & 1;
}
return uVar1;
} |
4,210 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *s) {
char *token = strtok(s, " ");
while (token != NULL) {
if (strlen(token) % 2 != 0) {
return 1;
} else {
return 0;
}
token = strtok(NULL, " ");
}
return 0;
}
| int main() {
assert(func0("Hadoop") == 0);
assert(func0("great") == 1);
assert(func0("structure") == 1);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x8,%rsp
lea 0xdc5(%rip),%rsi
callq 1090 <strtok@plt>
mov %rax,%rdi
xor %eax,%eax
test %rdi,%rdi
je 1256 <func0+0x26>
callq 1070 <strlen@plt>
and $0x1,%eax
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
sub rsp, 8
lea rsi, unk_2004
call _strtok
mov rdi, rax
xor eax, eax
test rdi, rdi
jz short loc_1256
call _strlen
and eax, 1
loc_1256:
add rsp, 8
retn | long long func0(long long a1)
{
long long v1; // rdi
long long result; // rax
v1 = strtok(a1, &unk_2004);
result = 0LL;
if ( v1 )
return strlen() & 1;
return result;
} | func0:
ENDBR64
SUB RSP,0x8
LEA RSI,[0x102004]
CALL 0x00101090
MOV RDI,RAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101256
CALL 0x00101070
AND EAX,0x1
LAB_00101256:
ADD RSP,0x8
RET | uint func0(char *param_1)
{
uint uVar1;
char *__s;
size_t sVar2;
__s = strtok(param_1," ");
uVar1 = 0;
if (__s != (char *)0x0) {
sVar2 = strlen(__s);
uVar1 = (uint)sVar2 & 1;
}
return uVar1;
} |
4,211 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(char *s) {
char *token = strtok(s, " ");
while (token != NULL) {
if (strlen(token) % 2 != 0) {
return 1;
} else {
return 0;
}
token = strtok(NULL, " ");
}
return 0;
}
| int main() {
assert(func0("Hadoop") == 0);
assert(func0("great") == 1);
assert(func0("structure") == 1);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x8,%rsp
lea 0xdc5(%rip),%rsi
callq 1090 <strtok@plt>
mov %rax,%rdi
xor %eax,%eax
test %rdi,%rdi
je 1256 <func0+0x26>
callq 1070 <strlen@plt>
and $0x1,%eax
add $0x8,%rsp
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
sub rsp, 8
lea rsi, delim; " "
call _strtok
mov rdi, rax; s
xor eax, eax
test rdi, rdi
jz short loc_1256
call _strlen
and eax, 1
loc_1256:
add rsp, 8
retn | size_t func0(char *a1)
{
char *v1; // rdi
size_t result; // rax
v1 = strtok(a1, " ");
result = 0LL;
if ( v1 )
return strlen(v1) & 1;
return result;
} | func0:
ENDBR64
SUB RSP,0x8
LEA RSI,[0x102004]
CALL 0x00101090
MOV RDI,RAX
XOR EAX,EAX
TEST RDI,RDI
JZ 0x00101256
CALL 0x00101070
AND EAX,0x1
LAB_00101256:
ADD RSP,0x8
RET | uint func0(char *param_1)
{
uint uVar1;
char *__s;
size_t sVar2;
__s = strtok(param_1," ");
uVar1 = 0;
if (__s != (char *)0x0) {
sVar2 = strlen(__s);
uVar1 = (uint)sVar2 & 1;
}
return uVar1;
} |
4,212 | func0 |
#include <assert.h>
| double func0(int n) {
return (n * (n + 1) * (n + 2)) / 6.0;
}
| int main() {
assert(func0(5) == 35.0);
assert(func0(6) == 56.0);
assert(func0(7) == 84.0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
add $0x1,%eax
imul -0x4(%rbp),%eax
mov -0x4(%rbp),%edx
add $0x2,%edx
imul %edx,%eax
cvtsi2sd %eax,%xmm0
movsd 0xf0d(%rip),%xmm1
divsd %xmm1,%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
add eax, 1
imul eax, [rbp+var_4]
mov edx, [rbp+var_4]
add edx, 2
imul eax, edx
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
movsd xmm1, cs:qword_2060
divsd xmm0, xmm1
pop rbp
retn | double func0(int a1)
{
return (double)((a1 + 2) * a1 * (a1 + 1)) / 6.0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x4]
MOV EDX,dword ptr [RBP + -0x4]
ADD EDX,0x2
IMUL EAX,EDX
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr [0x00102060]
DIVSD XMM0,XMM1
POP RBP
RET | double func0(int param_1)
{
return (double)((param_1 + 1) * param_1 * (param_1 + 2)) / DAT_00102060;
} |
4,213 | func0 |
#include <assert.h>
| double func0(int n) {
return (n * (n + 1) * (n + 2)) / 6.0;
}
| int main() {
assert(func0(5) == 35.0);
assert(func0(6) == 56.0);
assert(func0(7) == 84.0);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
lea 0x1(%rdi),%edi
imul %eax,%edi
add $0x2,%eax
imul %eax,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
divsd 0xebd(%rip),%xmm0
retq
| func0:
endbr64
lea eax, [rdi+1]
imul eax, edi
add edi, 2
imul eax, edi
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
divsd xmm0, cs:qword_2008
retn | double func0(int a1)
{
return (double)((a1 + 2) * a1 * (a1 + 1)) / 6.0;
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
IMUL EAX,EDI
ADD EDI,0x2
IMUL EAX,EDI
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
DIVSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
return (double)((param_1 + 1) * param_1 * (param_1 + 2)) / _DAT_00102008;
} |
4,214 | func0 |
#include <assert.h>
| double func0(int n) {
return (n * (n + 1) * (n + 2)) / 6.0;
}
| int main() {
assert(func0(5) == 35.0);
assert(func0(6) == 56.0);
assert(func0(7) == 84.0);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
lea 0x1(%rdi),%edi
pxor %xmm0,%xmm0
imul %eax,%edi
add $0x2,%eax
imul %eax,%edi
cvtsi2sd %edi,%xmm0
divsd 0xea6(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
lea eax, [rdi+1]
pxor xmm0, xmm0
imul eax, edi
add edi, 2
imul eax, edi
cvtsi2sd xmm0, eax
divsd xmm0, cs:qword_2008
retn | double func0(int a1)
{
return (double)((a1 + 2) * a1 * (a1 + 1)) / 6.0;
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
PXOR XMM0,XMM0
IMUL EAX,EDI
ADD EDI,0x2
IMUL EAX,EDI
CVTSI2SD XMM0,EAX
DIVSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
return (double)((param_1 + 1) * param_1 * (param_1 + 2)) / _DAT_00102008;
} |
4,215 | func0 |
#include <assert.h>
| double func0(int n) {
return (n * (n + 1) * (n + 2)) / 6.0;
}
| int main() {
assert(func0(5) == 35.0);
assert(func0(6) == 56.0);
assert(func0(7) == 84.0);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
lea 0x1(%rdi),%edi
pxor %xmm0,%xmm0
imul %eax,%edi
add $0x2,%eax
imul %eax,%edi
cvtsi2sd %edi,%xmm0
divsd 0xea6(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
lea eax, [rdi+1]
pxor xmm0, xmm0
imul eax, edi
add edi, 2
imul eax, edi
cvtsi2sd xmm0, eax
divsd xmm0, cs:qword_2008
retn | double func0(int a1)
{
return (double)((a1 + 2) * a1 * (a1 + 1)) / 6.0;
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
PXOR XMM0,XMM0
IMUL EAX,EDI
ADD EDI,0x2
IMUL EAX,EDI
CVTSI2SD XMM0,EAX
DIVSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
return (double)((param_1 + 1) * param_1 * (param_1 + 2)) / _DAT_00102008;
} |
4,216 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} Pair;
| Pair* func0(int *test_tup1, int len1, int *test_tup2, int len2) {
Pair *res = (Pair*)malloc(sizeof(Pair) * len1);
for (int i = 0; i < len1; i++) {
res[i].first = test_tup1[i];
res[i].second = test_tup2[i % len2];
}
return res;
}
| int main() {
int test_tup1_1[] = {7, 8, 4, 5, 9, 10};
int test_tup2_1[] = {1, 5, 6};
Pair *result1 = func0(test_tup1_1, 6, test_tup2_1, 3);
Pair expected1[] = {{7, 1}, {8, 5}, {4, 6}, {5, 1}, {9, 5}, {10, 6}};
for (int i = 0; i < 6; i++) {
assert(result1[i].first == expected1[i].first ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0xc(%rbp)
jmp 1246 <func0+0x9d>
mov... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov eax, [rbp+var_1C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_C], 0
jmp short loc_1246... | _DWORD * func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+24h] [rbp-Ch]
_DWORD *v8; // [rsp+28h] [rbp-8h]
v8 = malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
{
v8[2 * i] = *(_DWORD *)(4LL * i + a1);
v8[2 * i + 1] = *(_DWORD *)(4LL * (i % a4) + a3);
}
return v8;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0xc],0x0
JMP ... | void * func0(long param_1,int param_2,long param_3,int param_4)
{
void *pvVar1;
int local_14;
pvVar1 = malloc((long)param_2 << 3);
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
*(int4 *)((long)pvVar1 + (long)local_14 * 8) =
*(int4 *)(param_1 + (long)local_14 * 4);
*(int4... |
4,217 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} Pair;
| Pair* func0(int *test_tup1, int len1, int *test_tup2, int len2) {
Pair *res = (Pair*)malloc(sizeof(Pair) * len1);
for (int i = 0; i < len1; i++) {
res[i].first = test_tup1[i];
res[i].second = test_tup2[i % len2];
}
return res;
}
| int main() {
int test_tup1_1[] = {7, 8, 4, 5, 9, 10};
int test_tup2_1[] = {1, 5, 6};
Pair *result1 = func0(test_tup1_1, 6, test_tup2_1, 3);
Pair expected1[] = {{7, 1}, {8, 5}, {4, 6}, {5, 1}, {9, 5}, {10, 6}};
for (int i = 0; i < 6; i++) {
assert(result1[i].first == expected1[i].first ... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %esi,%r13d
mov %rdx,%r12
mov %ecx,%ebx
movslq %esi,%rdi
shl $0x3,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rsi
test %r13d,%r13d
jle 1202 <func0+0x59>
lea -0x1(%r13),%edi
mov $0x0,%ecx
mov 0x0(... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r13d, esi
mov r12, rdx
mov ebx, ecx
movsxd rdi, esi
shl rdi, 3
call _malloc
mov rsi, rax
test r13d, r13d
jle short loc_11FE
mov edi, r13d
mov ecx, 0
loc_11DE:
mov eax, [rbp+rcx*4... | long long func0(long long a1, int a2, long long a3, int a4)
{
long long v7; // rsi
long long v8; // rcx
v7 = malloc(8LL * a2);
if ( a2 > 0 )
{
v8 = 0LL;
do
{
*(_DWORD *)(v7 + 8 * v8) = *(_DWORD *)(a1 + 4 * v8);
*(_DWORD *)(v7 + 8 * v8 + 4) = *(_DWORD *)(a3 + 4LL * ((int)v8 % a4));
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R13D,ESI
MOV R12,RDX
MOV EBX,ECX
MOVSXD RDI,ESI
SHL RDI,0x3
CALL 0x001010b0
MOV RSI,RAX
TEST R13D,R13D
JLE 0x001011fe
MOV EDI,R13D
MOV ECX,0x0
LAB_001011de:
MOV EAX,dword ptr [RBP + RCX*0x4]
MOV dword ptr [RSI + RCX*0x8],EAX
MOV EAX,ECX
CDQ
... | void * func0(long param_1,uint param_2,long param_3,int param_4)
{
void *pvVar1;
ulong uVar2;
pvVar1 = malloc((long)(int)param_2 << 3);
if (0 < (int)param_2) {
uVar2 = 0;
do {
*(int4 *)((long)pvVar1 + uVar2 * 8) = *(int4 *)(param_1 + uVar2 * 4);
*(int4 *)((long)pvVar1 + uVar2 * 8 + 4) =
... |
4,218 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} Pair;
| Pair* func0(int *test_tup1, int len1, int *test_tup2, int len2) {
Pair *res = (Pair*)malloc(sizeof(Pair) * len1);
for (int i = 0; i < len1; i++) {
res[i].first = test_tup1[i];
res[i].second = test_tup2[i % len2];
}
return res;
}
| int main() {
int test_tup1_1[] = {7, 8, 4, 5, 9, 10};
int test_tup2_1[] = {1, 5, 6};
Pair *result1 = func0(test_tup1_1, 6, test_tup2_1, 3);
Pair expected1[] = {{7, 1}, {8, 5}, {4, 6}, {5, 1}, {9, 5}, {10, 6}};
for (int i = 0; i < 6; i++) {
assert(result1[i].first == expected1[i].first ... | O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%r13
shl $0x3,%rdi
mov %ecx,%ebx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %rax,%r8
test %r13d,%r13d
jle 15dd <func0+0x5d>
lea -0x1(%r13),%ecx
xor %esi,%esi
nopl 0x0(%r... | func0:
endbr64
push r14
push r13
movsxd r13, esi
push r12
mov r12, rdx
push rbp
mov rbp, rdi
lea rdi, ds:0[r13*8]
push rbx
mov ebx, ecx
call _malloc
mov r8, rax
test r13d, r13d
jle short loc_15D2
xor ecx, ecx
xchg ax, ax
loc_15B0:
mov eax, [rbp+rcx*4+0]
mov [... | long long func0(long long a1, int a2, long long a3, int a4)
{
long long v6; // r8
long long i; // rcx
v6 = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
*(_DWORD *)(v6 + 8 * i) = *(_DWORD *)(a1 + 4 * i);
*(_DWORD *)(v6 + 8 * i + 4) = *(_DWORD *)(a3 + 4LL * ((int)i % a... | func0:
ENDBR64
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
LEA RDI,[R13*0x8]
PUSH RBX
MOV EBX,ECX
CALL 0x001010b0
MOV R8,RAX
TEST R13D,R13D
JLE 0x001015d2
XOR ECX,ECX
NOP
LAB_001015b0:
MOV EAX,dword ptr [RBP + RCX*0x4]
MOV dword ptr [R8 + RCX*0x8],EAX
MOV EAX,ECX
CDQ
IDIV EBX
MOVSXD RDX,E... | void * func0(long param_1,int param_2,long param_3,int param_4)
{
void *pvVar1;
ulong uVar2;
pvVar1 = malloc((long)param_2 * 8);
if (0 < param_2) {
uVar2 = 0;
do {
*(int4 *)((long)pvVar1 + uVar2 * 8) = *(int4 *)(param_1 + uVar2 * 4);
*(int4 *)((long)pvVar1 + uVar2 * 8 + 4) =
*... |
4,219 | func0 | #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int first;
int second;
} Pair;
| Pair* func0(int *test_tup1, int len1, int *test_tup2, int len2) {
Pair *res = (Pair*)malloc(sizeof(Pair) * len1);
for (int i = 0; i < len1; i++) {
res[i].first = test_tup1[i];
res[i].second = test_tup2[i % len2];
}
return res;
}
| int main() {
int test_tup1_1[] = {7, 8, 4, 5, 9, 10};
int test_tup2_1[] = {1, 5, 6};
Pair *result1 = func0(test_tup1_1, 6, test_tup2_1, 3);
Pair expected1[] = {{7, 1}, {8, 5}, {4, 6}, {5, 1}, {9, 5}, {10, 6}};
for (int i = 0; i < 6; i++) {
assert(result1[i].first == expected1[i].first ... | O3 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
movslq %esi,%rdi
push %rbp
mov %rdi,%r13
shl $0x3,%rdi
mov %rdx,%rbp
push %rbx
mov %ecx,%ebx
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %rax,%r8
test %r13d,%r13d
jle 171d <func0+0xed>
lea -0x1(%r13),%ecx
cmp $0x2,%ecx
jbe 172b <... | func0:
endbr64
push r14
push r13
mov r13, rdi
push r12
movsxd r12, esi
push rbp
lea rdi, ds:0[r12*8]; size
mov rbp, rdx
push rbx
mov ebx, ecx
call _malloc
mov rsi, rax
test r12d, r12d
jle loc_1589
lea eax, [r12-1]
mov r14, r12
cmp eax, 2
jbe loc_1595
mov ... | _DWORD * func0(long long a1, int a2, long long a3, int a4)
{
long long v5; // r12
_DWORD *v8; // rsi
long long v9; // rax
_DWORD *v10; // rdx
int v11; // edi
int v12; // r8d
int v13; // r9d
int v14; // r10d
int v15; // eax
long long v16; // rdi
long long v17; // rcx
long long i; // rcx
v5 = a... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
MOVSXD R12,ESI
PUSH RBP
LEA RDI,[R12*0x8]
MOV RBP,RDX
PUSH RBX
MOV EBX,ECX
CALL 0x001010b0
MOV RSI,RAX
TEST R12D,R12D
JLE 0x00101589
LEA EAX,[R12 + -0x1]
MOV R14,R12
CMP EAX,0x2
JBE 0x00101595
MOV ECX,R12D
MOV RAX,R13
MOV RDX,RSI
SHR ECX,0x2
SHL RCX,0x4
ADD RCX,R13
... | int4 * func0(int4 *param_1,uint param_2,long param_3,int param_4)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
uint uVar4;
int4 *puVar5;
int4 *puVar6;
int4 *puVar7;
ulong uVar8;
int4 *puVar9;
long lVar10;
ulong uVar11;
uVar11 = (ulong)(int)param_2;
puVar5 = (int4 *)malloc(uVar11 * 8);
if ((int)... |
4,220 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r) {
double volume = (4.0/3.0) * M_PI * r * r * r;
return volume;
}
| int main() {
assert(func0(10) == 4188.790204786391);
assert(func0(25) == 65449.84694978735);
assert(func0(20) == 33510.32163829113);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf4d(%rip),%xmm0
mulsd %xmm1,%xmm0
mulsd -0x18(%rbp),%xmm0
movsd -0x18(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_2090
mulsd xmm0, xmm1
mulsd xmm0, [rbp+var_18]
movsd xmm1, [rbp+var_18]
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 4.188790204786391 * a1 * a1 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102090]
MULSD XMM0,XMM1
MULSD XMM0,qword ptr [RBP + -0x18]
MOVSD XMM1,qword ptr [RBP + -0x18]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RE... | double func0(double param_1)
{
return DAT_00102090 * param_1 * param_1 * param_1;
} |
4,221 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r) {
double volume = (4.0/3.0) * M_PI * r * r * r;
return volume;
}
| int main() {
assert(func0(10) == 4188.790204786391);
assert(func0(25) == 65449.84694978735);
assert(func0(20) == 33510.32163829113);
return 0;
}
| O1 | c | func0:
endbr64
movapd %xmm0,%xmm1
mulsd 0xecf(%rip),%xmm0
mulsd %xmm1,%xmm0
mulsd %xmm1,%xmm0
retq
| func0:
endbr64
movapd xmm1, xmm0
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm1
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return a1 * 4.188790204786391 * a1 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM1
MULSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102008 * param_1 * param_1;
} |
4,222 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r) {
double volume = (4.0/3.0) * M_PI * r * r * r;
return volume;
}
| int main() {
assert(func0(10) == 4188.790204786391);
assert(func0(25) == 65449.84694978735);
assert(func0(20) == 33510.32163829113);
return 0;
}
| O2 | c | func0:
endbr64
movapd %xmm0,%xmm1
movsd 0xeb8(%rip),%xmm0
mulsd %xmm1,%xmm0
mulsd %xmm1,%xmm0
mulsd %xmm1,%xmm0
retq
nopl (%rax)
| func0:
endbr64
movapd xmm1, xmm0
movsd xmm0, cs:qword_2008
mulsd xmm0, xmm1
mulsd xmm0, xmm1
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return 4.188790204786391 * a1 * a1 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM1
MULSD XMM0,XMM1
MULSD XMM0,XMM1
RET | double func0(double param_1)
{
return DAT_00102008 * param_1 * param_1 * param_1;
} |
4,223 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r) {
double volume = (4.0/3.0) * M_PI * r * r * r;
return volume;
}
| int main() {
assert(func0(10) == 4188.790204786391);
assert(func0(25) == 65449.84694978735);
assert(func0(20) == 33510.32163829113);
return 0;
}
| O3 | c | func0:
endbr64
movapd %xmm0,%xmm1
movsd 0xeb8(%rip),%xmm0
mulsd %xmm1,%xmm0
mulsd %xmm1,%xmm0
mulsd %xmm1,%xmm0
retq
nopl (%rax)
| func0:
endbr64
movapd xmm1, xmm0
movsd xmm0, cs:qword_2008
mulsd xmm0, xmm1
mulsd xmm0, xmm1
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return 4.188790204786391 * a1 * a1 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM1
MULSD XMM0,XMM1
MULSD XMM0,XMM1
RET | double func0(double param_1)
{
return DAT_00102008 * param_1 * param_1 * param_1;
} |
4,224 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(char *strr) {
int summ = 0;
for (int i = 0; strr[i] != '\0'; i++) {
summ += (strr[i] - 'a' + 1);
}
if (summ % 26 == 0) {
return 'z';
} else {
summ = summ % 26;
return ('a' + summ - 1);
}
}
| int main() {
assert(func0("abc") == 'f');
assert(func0("gfg") == 't');
assert(func0("ab") == 'c');
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1182 <func0+0x39>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
sub $0x60,%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
m... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_1182
loc_1165:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
sub eax, 60h ; '`'
add [rbp+var_8]... | long long func0(long long a1)
{
int v2; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v2 = 0;
for ( i = 0; *(_BYTE *)(i + a1); ++i )
v2 += *(char *)(i + a1) - 96;
if ( v2 % 26 )
return (unsigned int)(v2 % 26 + 96);
else
return 122LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101182
LAB_00101165:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
SUB EAX,0x60
ADD dword ptr [RBP +... | int func0(long param_1)
{
int iVar1;
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; *(char *)(param_1 + local_c) != '\0'; local_c = local_c + 1) {
local_10 = local_10 + *(char *)(param_1 + local_c) + -0x60;
}
if (local_10 % 0x1a == 0) {
iVar1 = 0x7a;
}
else {
iVar1 = loca... |
4,225 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(char *strr) {
int summ = 0;
for (int i = 0; strr[i] != '\0'; i++) {
summ += (strr[i] - 'a' + 1);
}
if (summ % 26 == 0) {
return 'z';
} else {
summ = summ % 26;
return ('a' + summ - 1);
}
}
| int main() {
assert(func0("abc") == 'f');
assert(func0("gfg") == 't');
assert(func0("ab") == 'c');
return 0;
}
| O1 | c | func0:
endbr64
movzbl (%rdi),%eax
test %al,%al
je 1196 <func0+0x4d>
add $0x1,%rdi
mov $0x0,%edx
movsbl %al,%eax
lea -0x60(%rdx,%rax,1),%edx
add $0x1,%rdi
movzbl -0x1(%rdi),%eax
test %al,%al
jne 115d <func0+0x14>
movslq %edx,%rcx
imul $0x4ec4ec4f,%rcx,%rcx
sar $0x23,%rcx
mov %edx,%eax
sar ... | func0:
endbr64
movzx eax, byte ptr [rdi]
test al, al
jz short loc_1198
add rdi, 1
mov edx, 0
loc_115D:
movsx eax, al
lea edx, [rdx+rax-60h]
add rdi, 1
movzx eax, byte ptr [rdi-1]
test al, al
jnz short loc_115D
movsxd rcx, edx
imul rcx, 4EC4EC4Fh
sar rcx, 23h
mov eax, edx... | long long func0(char *a1)
{
char v1; // al
char *v2; // rdi
int v3; // edx
long long result; // rax
v1 = *a1;
if ( !*a1 )
return 122LL;
v2 = a1 + 1;
v3 = 0;
do
{
v3 = v3 + v1 - 96;
v1 = *v2++;
}
while ( v1 );
result = (unsigned int)(v3 % 26 + 96);
if ( !(v3 % 26) )
return 1... | func0:
ENDBR64
MOVZX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101198
ADD RDI,0x1
MOV EDX,0x0
LAB_0010115d:
MOVSX EAX,AL
LEA EDX,[RDX + RAX*0x1 + -0x60]
ADD RDI,0x1
MOVZX EAX,byte ptr [RDI + -0x1]
TEST AL,AL
JNZ 0x0010115d
MOVSXD RCX,EDX
IMUL RCX,RCX,0x4ec4ec4f
SAR RCX,0x23
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
IMUL EAX,ECX,... | int func0(char *param_1)
{
char cVar1;
int iVar2;
int iVar3;
char *pcVar4;
cVar1 = *param_1;
if (cVar1 != '\0') {
iVar3 = 0;
pcVar4 = param_1 + 1;
do {
iVar3 = iVar3 + -0x60 + (int)cVar1;
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar1 != '\0');
iVar2 = iVar3 %... |
4,226 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(char *strr) {
int summ = 0;
for (int i = 0; strr[i] != '\0'; i++) {
summ += (strr[i] - 'a' + 1);
}
if (summ % 26 == 0) {
return 'z';
} else {
summ = summ % 26;
return ('a' + summ - 1);
}
}
| int main() {
assert(func0("abc") == 'f');
assert(func0("gfg") == 't');
assert(func0("ab") == 'c');
return 0;
}
| O2 | c | func0:
endbr64
movsbl (%rdi),%eax
test %al,%al
je 12b0 <func0+0x50>
add $0x1,%rdi
xor %edx,%edx
nopl 0x0(%rax)
add $0x1,%rdi
lea -0x60(%rdx,%rax,1),%edx
movsbl -0x1(%rdi),%eax
test %al,%al
jne 1278 <func0+0x18>
movslq %edx,%rcx
mov %edx,%eax
imul $0x4ec4ec4f,%rcx,%rcx
sar $0x1f,%eax
sar... | func0:
endbr64
movsx eax, byte ptr [rdi]
test al, al
jz short loc_1240
add rdi, 1
xor edx, edx
nop dword ptr [rax+00000000h]
loc_1208:
add rdi, 1
lea edx, [rdx+rax-60h]
movsx eax, byte ptr [rdi-1]
test al, al
jnz short loc_1208
movsxd rcx, edx
mov eax, edx
imul rcx, 4EC4EC... | long long func0(_BYTE *a1)
{
int v1; // eax
_BYTE *v2; // rdi
int v3; // edx
long long result; // rax
v1 = (char)*a1;
if ( !*a1 )
return 122LL;
v2 = a1 + 1;
v3 = 0;
do
{
++v2;
v3 = v3 + v1 - 96;
v1 = (char)*(v2 - 1);
}
while ( *(v2 - 1) );
result = (unsigned int)(v3 % 26 + 96... | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x00101240
ADD RDI,0x1
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_00101208:
ADD RDI,0x1
LEA EDX,[RDX + RAX*0x1 + -0x60]
MOVSX EAX,byte ptr [RDI + -0x1]
TEST AL,AL
JNZ 0x00101208
MOVSXD RCX,EDX
MOV EAX,EDX
IMUL RCX,RCX,0x4ec4ec4f
SAR EAX,0x1f
SAR RCX,0x23
SUB ECX,EAX
IMUL E... | int func0(char *param_1)
{
char cVar1;
int iVar2;
int iVar3;
char *pcVar4;
cVar1 = *param_1;
if (cVar1 != '\0') {
iVar3 = 0;
pcVar4 = param_1 + 1;
do {
iVar3 = iVar3 + -0x60 + (int)cVar1;
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar1 != '\0');
iVar2 = iVar3 %... |
4,227 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(char *strr) {
int summ = 0;
for (int i = 0; strr[i] != '\0'; i++) {
summ += (strr[i] - 'a' + 1);
}
if (summ % 26 == 0) {
return 'z';
} else {
summ = summ % 26;
return ('a' + summ - 1);
}
}
| int main() {
assert(func0("abc") == 'f');
assert(func0("gfg") == 't');
assert(func0("ab") == 'c');
return 0;
}
| O3 | c | func0:
endbr64
movsbl (%rdi),%eax
test %al,%al
je 12b0 <func0+0x50>
add $0x1,%rdi
xor %edx,%edx
nopl 0x0(%rax)
add $0x1,%rdi
lea -0x60(%rdx,%rax,1),%edx
movsbl -0x1(%rdi),%eax
test %al,%al
jne 1278 <func0+0x18>
movslq %edx,%rcx
mov %edx,%eax
imul $0x4ec4ec4f,%rcx,%rcx
sar $0x1f,%eax
sar... | func0:
endbr64
movsx eax, byte ptr [rdi]
test al, al
jz short loc_12B0
add rdi, 1
xor edx, edx
nop dword ptr [rax+00000000h]
loc_1278:
add rdi, 1
lea edx, [rdx+rax-60h]
movsx eax, byte ptr [rdi-1]
test al, al
jnz short loc_1278
movsxd rcx, edx
mov eax, edx
imul rcx, 4EC4EC... | long long func0(_BYTE *a1)
{
int v1; // eax
_BYTE *v2; // rdi
int v3; // edx
long long result; // rax
v1 = (char)*a1;
if ( !*a1 )
return 122LL;
v2 = a1 + 1;
v3 = 0;
do
{
++v2;
v3 = v3 + v1 - 96;
v1 = (char)*(v2 - 1);
}
while ( *(v2 - 1) );
result = (unsigned int)(v3 % 26 + 96... | func0:
ENDBR64
MOVSX EAX,byte ptr [RDI]
TEST AL,AL
JZ 0x001012b0
ADD RDI,0x1
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_00101278:
ADD RDI,0x1
LEA EDX,[RDX + RAX*0x1 + -0x60]
MOVSX EAX,byte ptr [RDI + -0x1]
TEST AL,AL
JNZ 0x00101278
MOVSXD RCX,EDX
MOV EAX,EDX
IMUL RCX,RCX,0x4ec4ec4f
SAR EAX,0x1f
SAR RCX,0x23
SUB ECX,EAX
IMUL E... | int func0(char *param_1)
{
char cVar1;
int iVar2;
int iVar3;
char *pcVar4;
cVar1 = *param_1;
if (cVar1 != '\0') {
iVar3 = 0;
pcVar4 = param_1 + 1;
do {
iVar3 = iVar3 + -0x60 + (int)cVar1;
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
} while (cVar1 != '\0');
iVar2 = iVar3 %... |
4,228 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 1 || n == 2) {
return 1;
} else{
return func0(func0(n - 1)) + func0(n - func0(n - 1));
}
}
| int main() {
assert(func0(10) == 6);
assert(func0(2) == 1);
assert(func0(3) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %edi,-0x14(%rbp)
cmpl $0x1,-0x14(%rbp)
je 1165 <func0+0x1c>
cmpl $0x2,-0x14(%rbp)
jne 116c <func0+0x23>
mov $0x1,%eax
jmp 119f <func0+0x56>
mov -0x14(%rbp),%eax
sub $0x1,%eax
mov %eax,%edi
callq 1149 <func0>
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_14], edi
cmp [rbp+var_14], 1
jz short loc_1165
cmp [rbp+var_14], 2
jnz short loc_116C
loc_1165:
mov eax, 1
jmp short loc_119D
loc_116C:
mov eax, [rbp+var_14]
sub eax, 1
mov edi, eax
call fun... | long long func0(int a1)
{
unsigned int v2; // eax
int v3; // ebx
int v4; // eax
if ( a1 == 1 || a1 == 2 )
return 1LL;
v2 = func0((unsigned int)(a1 - 1));
v3 = func0(v2);
v4 = func0((unsigned int)(a1 - 1));
return v3 + (unsigned int)func0((unsigned int)(a1 - v4));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x1
JZ 0x00101165
CMP dword ptr [RBP + -0x14],0x2
JNZ 0x0010116c
LAB_00101165:
MOV EAX,0x1
JMP 0x0010119d
LAB_0010116c:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
MOV EDI,EAX
CALL 0x00101149
MOV EDI,EA... | int func0(int param_1)
{
int4 uVar1;
int iVar2;
int iVar3;
if ((param_1 == 1) || (param_1 == 2)) {
iVar3 = 1;
}
else {
uVar1 = func0(param_1 + -1);
iVar2 = func0(uVar1);
iVar3 = func0(param_1 + -1);
iVar3 = func0(param_1 - iVar3);
iVar3 = iVar3 + iVar2;
}
return iVar3;
} |
4,229 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 1 || n == 2) {
return 1;
} else{
return func0(func0(n - 1)) + func0(n - func0(n - 1));
}
}
| int main() {
assert(func0(10) == 6);
assert(func0(2) == 1);
assert(func0(3) == 2);
return 0;
}
| O1 | c | func0:
endbr64
lea -0x1(%rdi),%edx
mov $0x1,%eax
cmp $0x1,%edx
ja 115b <func0+0x12>
retq
push %r12
push %rbp
push %rbx
mov %edi,%ebx
mov %edx,%edi
callq 1149 <func0>
mov %eax,%r12d
mov %eax,%edi
callq 1149 <func0>
mov %eax,%ebp
sub %r12d,%ebx
mov %ebx,%edi
callq 1149 <func0>
a... | func0:
endbr64
lea edx, [rdi-1]
mov eax, 1
cmp edx, 1
ja short loc_115B
retn
loc_115B:
push r12
push rbp
push rbx
mov ebx, edi
mov edi, edx
call func0
mov r12d, eax
mov edi, eax
call func0
mov ebp, eax
sub ebx, r12d
mov edi, ebx
call func0
add eax, ebp
... | long long func0(int a1)
{
long long result; // rax
long long v2; // r12
int v3; // ebp
result = 1LL;
if ( (unsigned int)(a1 - 1) > 1 )
{
v2 = (unsigned int)func0((unsigned int)(a1 - 1));
v3 = func0(v2);
return v3 + (unsigned int)func0((unsigned int)(a1 - v2));
}
return result;
} | func0:
ENDBR64
LEA EDX,[RDI + -0x1]
MOV EAX,0x1
CMP EDX,0x1
JA 0x0010115b
RET
LAB_0010115b:
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
MOV EDI,EDX
CALL 0x00101149
MOV R12D,EAX
MOV EDI,EAX
CALL 0x00101149
MOV EBP,EAX
SUB EBX,R12D
MOV EDI,EBX
CALL 0x00101149
ADD EAX,EBP
POP RBX
POP RBP
POP R12
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 - 1U < 2) {
return 1;
}
iVar1 = func0(param_1 - 1U);
iVar2 = func0(iVar1);
iVar1 = func0(param_1 - iVar1);
return iVar1 + iVar2;
} |
4,230 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 1 || n == 2) {
return 1;
} else{
return func0(func0(n - 1)) + func0(n - func0(n - 1));
}
}
| int main() {
assert(func0(10) == 6);
assert(func0(2) == 1);
assert(func0(3) == 2);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%eax
push %rbp
mov %edi,%ebp
sub $0x1,%edi
push %rbx
cmp $0x1,%edi
jbe 122a <func0+0x3a>
xor %r12d,%r12d
callq 11f0 <func0>
mov %eax,%ebx
mov %eax,%edi
callq 11f0 <func0>
sub %ebx,%ebp
lea -0x1(%rbp),%edi
add %eax,%r12d
cmp $0x1,%edi
ja 1... | func0:
endbr64
push r15
mov eax, edi
push r14
sub eax, 1
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_44], edi
mov [rsp+68h+var_40], eax
mov [rsp+68h+var_3C], 0
cmp eax, 1
jbe loc_1A0B
loc_1220:
mov eax, [rsp+68h+var_40]
mov esi, [rsp+68h+va... | long long func0(int a1)
{
int v1; // r13d
unsigned int v2; // ebp
unsigned int v3; // ebx
int v4; // r12d
int v5; // eax
long long v6; // rdi
int v7; // r14d
long long v8; // r15
int v9; // r12d
int v10; // r14d
long long v11; // rdi
long long v12; // rbp
int v13; // r14d
unsigned int v14; ... | func0:
ENDBR64
PUSH R15
MOV EAX,EDI
PUSH R14
SUB EAX,0x1
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RSP + 0x24],EDI
MOV dword ptr [RSP + 0x28],EAX
MOV dword ptr [RSP + 0x2c],0x0
CMP EAX,0x1
JBE 0x00101a0b
LAB_00101220:
MOV EAX,dword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0x24]
MOV dword ptr [RSP... | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
uint uVar6;
uint uVar7;
int iVar8;
uint uVar9;
uint uVar10;
uint local_5c;
uint local_58;
uint local_54;
uint local_50;
int local_4c;
uint local_48;
int local_44;
uint local_40;
int local_3c;
loca... |
4,231 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 1 || n == 2) {
return 1;
} else{
return func0(func0(n - 1)) + func0(n - func0(n - 1));
}
}
| int main() {
assert(func0(10) == 6);
assert(func0(2) == 1);
assert(func0(3) == 2);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%eax
push %rbp
mov %edi,%ebp
sub $0x1,%edi
push %rbx
cmp $0x1,%edi
jbe 122a <func0+0x3a>
xor %r12d,%r12d
callq 11f0 <func0>
mov %eax,%ebx
mov %eax,%edi
callq 11f0 <func0>
sub %ebx,%ebp
lea -0x1(%rbp),%edi
add %eax,%r12d
cmp $0x1,%edi
ja 1... | func0:
endbr64
push r15
mov eax, 1
push r14
push r13
push r12
lea r12d, [rdi-1]
push rbp
push rbx
sub rsp, 38h
cmp r12d, 1
jbe loc_19DC
xor ebp, ebp
mov [rsp+68h+var_44], edi
mov r14d, r12d
mov [rsp+68h+var_3C], ebp
loc_1222:
mov eax, [rsp+68h+var_44]
mov [r... | long long func0(int a1)
{
long long result; // rax
int v2; // r14d
int v3; // ebx
int v4; // r14d
unsigned int v5; // r12d
unsigned int v6; // ebx
unsigned int v7; // ebp
int v8; // r13d
int v9; // eax
long long v10; // rdi
int v11; // ebx
long long v12; // r15
int v13; // r13d
int v14; // ... | func0:
ENDBR64
PUSH R15
MOV EAX,0x1
PUSH R14
PUSH R13
PUSH R12
LEA R12D,[RDI + -0x1]
PUSH RBP
PUSH RBX
SUB RSP,0x38
CMP R12D,0x1
JBE 0x001019dc
XOR EBP,EBP
MOV dword ptr [RSP + 0x24],EDI
MOV R14D,R12D
MOV dword ptr [RSP + 0x2c],EBP
LAB_00101222:
MOV EAX,dword ptr [RSP + 0x24]
MOV dword ptr [RSP + 0x18],R14D
CMP EAX,0x3... | int func0(int param_1)
{
uint uVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
uint uVar8;
uint uVar9;
uint uVar10;
int iVar11;
uint uVar12;
uint local_5c;
uint local_58;
uint local_54;
uint local_50;
uint local_4c;
uint local_48;
int local_44;
int local_... |
4,232 | func0 |
#include <math.h>
#include <assert.h>
#include <stdio.h>
| double func0(double r) {
double surfacearea = 4 * M_PI * r * r;
return surfacearea;
}
| int main() {
assert(func0(10) == 1256.6370614359173);
assert(func0(15) == 2827.4333882308138);
assert(func0(20) == 5026.548245743669);
printf("All tests passed successfully!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf4d(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd -0x18(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_20B0
mulsd xmm0, xmm1
movsd xmm1, [rbp+var_18]
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 12.56637061435917 * a1 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x001020b0]
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [RBP + -0x18]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | double func0(double param_1)
{
return DAT_001020b0 * param_1 * param_1;
} |
4,233 | func0 |
#include <math.h>
#include <assert.h>
#include <stdio.h>
| double func0(double r) {
double surfacearea = 4 * M_PI * r * r;
return surfacearea;
}
| int main() {
assert(func0(10) == 1256.6370614359173);
assert(func0(15) == 2827.4333882308138);
assert(func0(20) == 5026.548245743669);
printf("All tests passed successfully!\n");
return 0;
}
| O1 | c | func0:
endbr64
movapd %xmm0,%xmm1
mulsd 0xecf(%rip),%xmm0
mulsd %xmm1,%xmm0
retq
| func0:
endbr64
movapd xmm1, xmm0
mulsd xmm0, cs:qword_2028
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return a1 * 12.56637061435917 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MULSD XMM0,qword ptr [0x00102028]
MULSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1)
{
return param_1 * _DAT_00102028 * param_1;
} |
4,234 | func0 |
#include <math.h>
#include <assert.h>
#include <stdio.h>
| double func0(double r) {
double surfacearea = 4 * M_PI * r * r;
return surfacearea;
}
| int main() {
assert(func0(10) == 1256.6370614359173);
assert(func0(15) == 2827.4333882308138);
assert(func0(20) == 5026.548245743669);
printf("All tests passed successfully!\n");
return 0;
}
| O2 | c | func0:
endbr64
movapd %xmm0,%xmm1
movsd 0xea8(%rip),%xmm0
mulsd %xmm1,%xmm0
mulsd %xmm1,%xmm0
retq
nopl 0x0(%rax)
| func0:
endbr64
movapd xmm1, xmm0
movsd xmm0, cs:qword_2028
mulsd xmm0, xmm1
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return 12.56637061435917 * a1 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102028]
MULSD XMM0,XMM1
MULSD XMM0,XMM1
RET | double func0(double param_1)
{
return DAT_00102028 * param_1 * param_1;
} |
4,235 | func0 |
#include <math.h>
#include <assert.h>
#include <stdio.h>
| double func0(double r) {
double surfacearea = 4 * M_PI * r * r;
return surfacearea;
}
| int main() {
assert(func0(10) == 1256.6370614359173);
assert(func0(15) == 2827.4333882308138);
assert(func0(20) == 5026.548245743669);
printf("All tests passed successfully!\n");
return 0;
}
| O3 | c | func0:
endbr64
movapd %xmm0,%xmm1
movsd 0xea8(%rip),%xmm0
mulsd %xmm1,%xmm0
mulsd %xmm1,%xmm0
retq
nopl 0x0(%rax)
| func0:
endbr64
movapd xmm1, xmm0
movsd xmm0, cs:qword_2028
mulsd xmm0, xmm1
mulsd xmm0, xmm1
retn | double func0(double a1)
{
return 12.56637061435917 * a1 * a1;
} | func0:
ENDBR64
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102028]
MULSD XMM0,XMM1
MULSD XMM0,XMM1
RET | double func0(double param_1)
{
return DAT_00102028 * param_1 * param_1;
} |
4,236 | func0 |
#include <assert.h>
| int func0(int n) {
return 3 * n * (n - 1) + 1;
}
| int main() {
assert(func0(10) == 271);
assert(func0(2) == 7);
assert(func0(9) == 217);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
sub $0x1,%eax
imul -0x4(%rbp),%eax
mov %eax,%edx
mov %edx,%eax
add %eax,%eax
add %edx,%eax
add $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
sub eax, 1
imul eax, [rbp+var_4]
mov edx, eax
mov eax, edx
add eax, eax
add eax, edx
add eax, 1
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(3 * a1 * (a1 - 1) + 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
IMUL EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
ADD EAX,0x1
POP RBP
RET | int func0(int param_1)
{
return (param_1 + -1) * param_1 * 3 + 1;
} |
4,237 | func0 |
#include <assert.h>
| int func0(int n) {
return 3 * n * (n - 1) + 1;
}
| int main() {
assert(func0(10) == 271);
assert(func0(2) == 7);
assert(func0(9) == 217);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
lea -0x1(%rdi),%edi
imul %eax,%edi
lea 0x1(%rdi,%rdi,2),%eax
retq
| func0:
endbr64
lea eax, [rdi-1]
imul eax, edi
lea eax, [rax+rax*2+1]
retn | long long func0(int a1)
{
return (unsigned int)(3 * a1 * (a1 - 1) + 1);
} | func0:
ENDBR64
LEA EAX,[RDI + -0x1]
IMUL EAX,EDI
LEA EAX,[RAX + RAX*0x2 + 0x1]
RET | int func0(int param_1)
{
return (param_1 + -1) * param_1 * 3 + 1;
} |
4,238 | func0 |
#include <assert.h>
| int func0(int n) {
return 3 * n * (n - 1) + 1;
}
| int main() {
assert(func0(10) == 271);
assert(func0(2) == 7);
assert(func0(9) == 217);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%r8d
lea -0x1(%rdi),%edi
imul %r8d,%edi
lea 0x1(%rdi,%rdi,2),%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
lea eax, [rdi-1]
imul eax, edi
lea eax, [rax+rax*2+1]
retn | long long func0(int a1)
{
return (unsigned int)(3 * a1 * (a1 - 1) + 1);
} | func0:
ENDBR64
LEA EAX,[RDI + -0x1]
IMUL EAX,EDI
LEA EAX,[RAX + RAX*0x2 + 0x1]
RET | int func0(int param_1)
{
return (param_1 + -1) * param_1 * 3 + 1;
} |
4,239 | func0 |
#include <assert.h>
| int func0(int n) {
return 3 * n * (n - 1) + 1;
}
| int main() {
assert(func0(10) == 271);
assert(func0(2) == 7);
assert(func0(9) == 217);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%r8d
lea -0x1(%rdi),%edi
imul %r8d,%edi
lea 0x1(%rdi,%rdi,2),%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
lea eax, [rdi-1]
imul eax, edi
lea eax, [rax+rax*2+1]
retn | long long func0(int a1)
{
return (unsigned int)(3 * a1 * (a1 - 1) + 1);
} | func0:
ENDBR64
LEA EAX,[RDI + -0x1]
IMUL EAX,EDI
LEA EAX,[RAX + RAX*0x2 + 0x1]
RET | int func0(int param_1)
{
return (param_1 + -1) * param_1 * 3 + 1;
} |
4,240 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char *key;
char *value;
} KeyValuePair;
typedef struct {
KeyValuePair *pairs;
int size;
} Dictionary;
| Dictionary func0(Dictionary dict1, Dictionary dict2, Dictionary dict3) {
Dictionary result;
result.pairs = malloc(sizeof(KeyValuePair) * (dict1.size + dict2.size + dict3.size));
result.size = 0;
for (int i = 0; i < dict1.size; i++) {
int found = 0;
for (int j = 0; j < result.size... | int main() {
KeyValuePair pairs1[] = {{"R", "Red"}, {"B", "Black"}, {"P", "Pink"}};
KeyValuePair pairs2[] = {{"G", "Green"}, {"W", "White"}};
KeyValuePair pairs3[] = {{"O", "Orange"}, {"W", "White"}, {"B", "Black"}};
Dictionary dict1 = {pairs1, 3};
Dictionary dict2 = {pairs2, 2};
Diction... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rsi,%rax
mov %rdi,%r10
mov %r10,%rsi
mov %r11,%rdi
mov %rax,%rdi
mov %rsi,-0x50(%rbp)
mov %rdi,-0x48(%rbp)
mov %rdx,-0x60(%rbp)
mov %rcx,-0x58(%rbp)
mov %r8,-0x70(%rbp)
mov %r9,-0x68(%rbp)
mov -0x48(%rbp),%edx
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, rdi
mov r10, rsi
mov rsi, rax
mov rdi, rdx
mov rdi, r10
mov [rbp+var_50], rsi
mov [rbp+var_48], rdi
mov [rbp+var_60], rdx
mov [rbp+var_58], rcx
mov [rbp+var_70], r8
mov [rbp+var_68], r9
mov edx, dword p... | const char ** func0(long long a1, int a2, long long a3, int a4, long long a5, int a6)
{
const char **v6; // rsi
int v7; // eax
const char **v8; // rcx
const char *v9; // rdx
const char **v10; // rsi
int v11; // eax
const char **v12; // rcx
const char *v13; // rdx
const char **v14; // rsi
int v15; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,RDI
MOV R10,RSI
MOV RSI,RAX
MOV RDI,RDX
MOV RDI,R10
MOV qword ptr [RBP + -0x50],RSI
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x60],RDX
MOV qword ptr [RBP + -0x58],RCX
MOV qword ptr [RBP + -0x70],R8
MOV qword ptr [RBP + -0x68],R9
MOV EDX,dword ptr [RB... | int [16] func0(long param_1,int param_2,long param_3,int param_4,long param_5,int param_6)
{
int8 *puVar1;
int8 uVar2;
int auVar3 [16];
bool bVar4;
int iVar5;
void *pvVar6;
int8 *puVar7;
int local_3c;
int local_34;
int local_30;
int local_28;
int local_24;
int local_1c;
int local_10;
int... |
4,241 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char *key;
char *value;
} KeyValuePair;
typedef struct {
KeyValuePair *pairs;
int size;
} Dictionary;
| Dictionary func0(Dictionary dict1, Dictionary dict2, Dictionary dict3) {
Dictionary result;
result.pairs = malloc(sizeof(KeyValuePair) * (dict1.size + dict2.size + dict3.size));
result.size = 0;
for (int i = 0; i < dict1.size; i++) {
int found = 0;
for (int j = 0; j < result.size... | int main() {
KeyValuePair pairs1[] = {{"R", "Red"}, {"B", "Black"}, {"P", "Pink"}};
KeyValuePair pairs2[] = {{"G", "Green"}, {"W", "White"}};
KeyValuePair pairs3[] = {{"O", "Orange"}, {"W", "White"}, {"B", "Black"}};
Dictionary dict1 = {pairs1, 3};
Dictionary dict2 = {pairs2, 2};
Diction... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov %rdx,0x20(%rsp)
mov %rcx,0x10(%rsp)
mov %r8,0x28(%rsp)
mov %r9,0x18(%rsp)
lea (%rcx,%rsi,1),%edi
add %r9d,%edi
movslq %edi,%rdi
shl $0x4,%rdi
callq 10b0 <m... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov rbp, rdi
mov rbx, rsi
mov [rsp+68h+var_48], rdx
mov [rsp+68h+var_58], rcx
mov [rsp+68h+var_40], r8
mov [rsp+68h+var_50], r9
lea edi, [rcx+rsi]
add edi, r9d
movsxd rdi, edi
shl ... | long long func0(const __m128i *a1, int a2, const __m128i *a3, int a4, const __m128i *a5, int a6)
{
long long v6; // r14
const __m128i *v7; // r15
int v8; // r12d
const __m128i *v9; // r15
const __m128i *v10; // r15
long long v11; // r13
_QWORD *v12; // rbx
long long v13; // r13
_QWORD *v14; // rbx
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RBP,RDI
MOV RBX,RSI
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x28],R8
MOV qword ptr [RSP + 0x18],R9
LEA EDI,[RCX + RSI*0x1]
ADD EDI,R9D
MOVSXD RDI,EDI
SHL RDI,0x4
CALL 0x001010b0
MOV R14,RAX
T... | int1 [16]
func0(int8 *param_1,int param_2,int8 *param_3,int param_4,int8 *param_5,
int param_6)
{
int8 *puVar1;
char *pcVar2;
int8 uVar3;
int iVar4;
int8 *puVar5;
int iVar6;
int1 auVar7 [16];
auVar7._0_8_ = (int8 *)malloc((long)(param_4 + param_2 + param_6) << 4);
if (param_2 < 1) {
iVar... |
4,242 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char *key;
char *value;
} KeyValuePair;
typedef struct {
KeyValuePair *pairs;
int size;
} Dictionary;
| Dictionary func0(Dictionary dict1, Dictionary dict2, Dictionary dict3) {
Dictionary result;
result.pairs = malloc(sizeof(KeyValuePair) * (dict1.size + dict2.size + dict3.size));
result.size = 0;
for (int i = 0; i < dict1.size; i++) {
int found = 0;
for (int j = 0; j < result.size... | int main() {
KeyValuePair pairs1[] = {{"R", "Red"}, {"B", "Black"}, {"P", "Pink"}};
KeyValuePair pairs2[] = {{"G", "Green"}, {"W", "White"}};
KeyValuePair pairs3[] = {{"O", "Orange"}, {"W", "White"}, {"B", "Black"}};
Dictionary dict1 = {pairs1, 3};
Dictionary dict2 = {pairs2, 2};
Diction... | O2 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
lea (%rcx,%rsi,1),%edi
push %r13
add %r9d,%edi
push %r12
movslq %edi,%rdi
push %rbp
shl $0x4,%rdi
push %rbx
mov %rsi,%rbx
sub $0x38,%rsp
mov %rdx,0x20(%rsp)
mov %rcx,0x10(%rsp)
mov %r8,0x28(%rsp)
mov %r9,0x18(%rsp)
callq 10b0 <m... | func0:
endbr64
push r15
push r14
mov r14, rdi
lea edi, [rcx+rsi]
push r13
add edi, r9d
push r12
movsxd rdi, edi
push rbp
shl rdi, 4
push rbx
mov rbx, rsi
sub rsp, 38h
mov [rsp+68h+var_48], rdx
mov [rsp+68h+var_58], rcx
mov [rsp+68h+var_40], r8
mov [rsp+68h+var_... | long long func0(const __m128i *a1, int a2, const __m128i *a3, int a4, const __m128i *a5, int a6)
{
const __m128i *v6; // r14
long long v7; // r13
int v8; // ebp
long long v9; // r12
_QWORD *v10; // r15
const __m128i *v11; // r14
long long v12; // r12
_QWORD *v13; // r15
const __m128i *v14; // r14
l... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
LEA EDI,[RCX + RSI*0x1]
PUSH R13
ADD EDI,R9D
PUSH R12
MOVSXD RDI,EDI
PUSH RBP
SHL RDI,0x4
PUSH RBX
MOV RBX,RSI
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x28],R8
MOV qword ptr [RSP + 0x18],R9
CALL 0x001010b0
MOV R13,RAX
T... | int1 [16]
func0(int8 *param_1,int param_2,int8 *param_3,int param_4,int8 *param_5,
int param_6)
{
int8 *puVar1;
char *pcVar2;
int8 uVar3;
int iVar4;
long lVar5;
int iVar6;
int8 *puVar7;
int1 auVar8 [16];
auVar8._0_8_ = (int8 *)malloc((long)(param_4 + param_2 + param_6) << 4);
if (param_2 <... |
4,243 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char *key;
char *value;
} KeyValuePair;
typedef struct {
KeyValuePair *pairs;
int size;
} Dictionary;
| Dictionary func0(Dictionary dict1, Dictionary dict2, Dictionary dict3) {
Dictionary result;
result.pairs = malloc(sizeof(KeyValuePair) * (dict1.size + dict2.size + dict3.size));
result.size = 0;
for (int i = 0; i < dict1.size; i++) {
int found = 0;
for (int j = 0; j < result.size... | int main() {
KeyValuePair pairs1[] = {{"R", "Red"}, {"B", "Black"}, {"P", "Pink"}};
KeyValuePair pairs2[] = {{"G", "Green"}, {"W", "White"}};
KeyValuePair pairs3[] = {{"O", "Orange"}, {"W", "White"}, {"B", "Black"}};
Dictionary dict1 = {pairs1, 3};
Dictionary dict2 = {pairs2, 2};
Diction... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rdi,%r14
lea (%rcx,%rsi,1),%edi
push %r13
add %r9d,%edi
push %r12
movslq %edi,%rdi
push %rbp
shl $0x4,%rdi
push %rbx
mov %rsi,%rbx
sub $0x38,%rsp
mov %rdx,0x20(%rsp)
mov %rcx,0x10(%rsp)
mov %r8,0x28(%rsp)
mov %r9,0x18(%rsp)
callq 10b0 <m... | func0:
endbr64
push r15
push r14
mov r14, rdi
lea edi, [rcx+rsi]
push r13
add edi, r9d
push r12
movsxd rdi, edi
push rbp
shl rdi, 4; size
push rbx
mov rbx, rsi
sub rsp, 38h
mov [rsp+68h+var_48], rdx
mov [rsp+68h+var_58], rcx
mov [rsp+68h+var_40], r8
mov [rsp+68... | __m128i * func0(const __m128i *a1, int a2, const __m128i *a3, int a4, const __m128i *a5, int a6)
{
const __m128i *v6; // r14
__m128i *v7; // r13
int v8; // r12d
const char *v9; // rbp
const char **v10; // r15
const __m128i *v11; // r14
const char *v12; // rbp
const char **v13; // r15
const __m128i *v1... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
LEA EDI,[RCX + RSI*0x1]
PUSH R13
ADD EDI,R9D
PUSH R12
MOVSXD RDI,EDI
PUSH RBP
SHL RDI,0x4
PUSH RBX
MOV RBX,RSI
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x28],R8
MOV qword ptr [RSP + 0x18],R9
CALL 0x001010b0
MOV R13,RAX
T... | int [16]
func0(int8 *param_1,int param_2,int8 *param_3,int param_4,int8 *param_5,
int param_6)
{
char *pcVar1;
int8 uVar2;
int8 uVar3;
int iVar4;
long lVar5;
int8 *puVar6;
int iVar7;
int8 *puVar8;
int auVar9 [16];
auVar9._0_8_ = (int8 *)malloc((long)(param_4 + param_2 + param_6) << 4);
i... |
4,244 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
int cmpfunc(const void *a, const void *b) {
return ((Pair *)a)->key - ((Pair *)b)->key;
}
| Pair* func0(int arr[], int size, int *count) {
qsort(arr, size, sizeof(int), cmpfunc);
Pair *frequency = malloc(sizeof(Pair) * size);
int current = arr[0];
int freq = 1;
int index = 0;
for (int i = 1; i < size; i++) {
if (arr[i] == current) {
freq++;
... | int main() {
int count1, count2, count3;
int arr1[] = {10,10,10,10,20,20,20,20,40,40,50,50,30};
Pair *result1 = func0(arr1, 13, &count1);
assert(count1 == 5);
assert(result1[0].key == 10 && result1[0].value == 4);
assert(result1[1].key == 20 && result1[1].value == 4);
assert(res... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %rdx,-0x38(%rbp)
mov -0x2c(%rbp),%eax
movslq %eax,%rsi
mov -0x28(%rbp),%rax
lea -0x4a(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 10a0 <qsort@plt>
mov -0x2c(%rbp),%eax
cltq
shl $0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+base], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov eax, [rbp+var_2C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, cmpfunc
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax; base
call _qsort
mov ... | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int v5; // [rsp+28h] [rbp-18h]
int v6; // [rsp+2Ch] [rbp-14h]
int v7; // [rsp+30h] [rbp-10h]
int i; // [rsp+34h] [rbp-Ch]
_DWORD *v9; // [rsp+38h] [rbp-8h]
qsort(a1, a2, 4uLL, cmpfunc);
v9 = malloc(8LL * a2);
v5 = *a1;
v6 = 1;
v7 = 0;
for ( i = 1; i <... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV EAX,dword ptr [RBP + -0x2c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RDX,[0x1011c9]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x001010a0
MOV EAX,dword ptr [RBP + ... | void * func0(int *param_1,int param_2,int *param_3)
{
void *pvVar1;
int local_20;
int local_1c;
int local_18;
int local_14;
qsort(param_1,(long)param_2,4,cmpfunc);
pvVar1 = malloc((long)param_2 << 3);
local_20 = *param_1;
local_1c = 1;
local_18 = 0;
for (local_14 = 1; local_14 < param_2; local... |
4,245 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
int cmpfunc(const void *a, const void *b) {
return ((Pair *)a)->key - ((Pair *)b)->key;
}
| Pair* func0(int arr[], int size, int *count) {
qsort(arr, size, sizeof(int), cmpfunc);
Pair *frequency = malloc(sizeof(Pair) * size);
int current = arr[0];
int freq = 1;
int index = 0;
for (int i = 1; i < size; i++) {
if (arr[i] == current) {
freq++;
... | int main() {
int count1, count2, count3;
int arr1[] = {10,10,10,10,20,20,20,20,40,40,50,50,30};
Pair *result1 = func0(arr1, 13, &count1);
assert(count1 == 5);
assert(result1[0].key == 10 && result1[0].value == 4);
assert(result1[1].key == 20 && result1[1].value == 4);
assert(res... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %esi,%r12d
mov %rdx,%rbx
movslq %esi,%r13
lea -0x2a(%rip),%rcx
mov $0x4,%edx
mov %r13,%rsi
callq 10a0 <qsort@plt>
lea 0x0(,%r13,8),%rdi
callq 10d0 <malloc@plt>
mov 0x0(%rbp),%edi
cmp $0x1,%r12d... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r12d, esi
mov rbx, rdx
movsxd r13, esi
lea rcx, cmpfunc
mov edx, 4
mov rsi, r13
call _qsort
lea rdi, ds:0[r13*8]
call _malloc
mov r9, rax
mov esi, [rbp+0]
cmp r12d, 1
jle sho... | long long func0(int *a1, int a2, _DWORD *a3)
{
long long v6; // r9
int v7; // esi
int *v8; // rax
int v9; // ecx
int v10; // edi
int v11; // edx
_DWORD *v12; // r8
_DWORD *v13; // rax
qsort(a1, a2, 4LL, cmpfunc);
v6 = malloc(8LL * a2);
v7 = *a1;
if ( a2 <= 1 )
{
v9 = 0;
v10 = 1;
}
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R12D,ESI
MOV RBX,RDX
MOVSXD R13,ESI
LEA RCX,[0x1011c9]
MOV EDX,0x4
MOV RSI,R13
CALL 0x001010a0
LEA RDI,[R13*0x8]
CALL 0x001010d0
MOV R9,RAX
MOV ESI,dword ptr [RBP]
CMP R12D,0x1
JLE 0x0010125f
LEA RAX,[RBP + 0x4]
LEA EDX,[R12 + -0x2]
LEA R10,... | void * func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
void *pvVar3;
int *piVar4;
int iVar5;
int iVar6;
int iVar7;
qsort(param_1,(long)param_2,4,cmpfunc);
pvVar3 = malloc((long)param_2 * 8);
iVar6 = *param_1;
if (param_2 < 2) {
iVar5 = 0;
iVar7 = 1;
}
else {
... |
4,246 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
int cmpfunc(const void *a, const void *b) {
return ((Pair *)a)->key - ((Pair *)b)->key;
}
| Pair* func0(int arr[], int size, int *count) {
qsort(arr, size, sizeof(int), cmpfunc);
Pair *frequency = malloc(sizeof(Pair) * size);
int current = arr[0];
int freq = 1;
int index = 0;
for (int i = 1; i < size; i++) {
if (arr[i] == current) {
freq++;
... | int main() {
int count1, count2, count3;
int arr1[] = {10,10,10,10,20,20,20,20,40,40,50,50,30};
Pair *result1 = func0(arr1, 13, &count1);
assert(count1 == 5);
assert(result1[0].key == 10 && result1[0].value == 4);
assert(result1[1].key == 20 && result1[1].value == 4);
assert(res... | O2 | c | func0:
endbr64
push %r13
lea -0x1d(%rip),%rcx
mov %rdi,%r13
push %r12
movslq %esi,%r12
push %rbp
mov %r12,%rsi
push %rbx
mov %rdx,%rbx
mov $0x4,%edx
sub $0x8,%rsp
callq 10a0 <qsort@plt>
lea 0x0(,%r12,8),%rdi
callq 10d0 <malloc@plt>
mov 0x0(%r13),%r9d
cmp $0x1,%r12d
jle 17b0 <func... | func0:
endbr64
push r13
lea rcx, cmpfunc
push r12
mov r12, rdi
push rbp
movsxd rbp, esi
push rbx
mov rsi, rbp
mov rbx, rdx
mov edx, 4
sub rsp, 8
call _qsort
lea rdi, ds:0[rbp*8]
call _malloc
mov ecx, [r12]
mov r9, rax
cmp ebp, 1
jle short loc_17A8
lea e... | _DWORD * func0(int *a1, int a2, int *a3)
{
_DWORD *v6; // rax
int v7; // ecx
_DWORD *v8; // r9
int *v9; // rax
int v10; // esi
int v11; // edi
long long v12; // r10
long long v13; // r8
_DWORD *v14; // r8
int v15; // edx
long long v16; // rax
int v17; // esi
_DWORD *result; // rax
qsort(a1,... | func0:
ENDBR64
PUSH R13
LEA RCX,[0x1016e0]
PUSH R12
MOV R12,RDI
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV RSI,RBP
MOV RBX,RDX
MOV EDX,0x4
SUB RSP,0x8
CALL 0x001010a0
LEA RDI,[RBP*0x8]
CALL 0x001010d0
MOV ECX,dword ptr [R12]
MOV R9,RAX
CMP EBP,0x1
JLE 0x001017a8
LEA EDX,[RBP + -0x2]
LEA RAX,[R12 + 0x4]
XOR ESI,ESI
MOV EDI,0x... | int * func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
long lVar7;
qsort(param_1,(long)param_2,4,cmpfunc);
piVar1 = (int *)malloc((long)param_2 * 8);
iVar3 = *param_1;
if (param_2 < 2) {
iVar5 = 1;
iVar6 = 1;
piVar... |
4,247 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
int cmpfunc(const void *a, const void *b) {
return ((Pair *)a)->key - ((Pair *)b)->key;
}
| Pair* func0(int arr[], int size, int *count) {
qsort(arr, size, sizeof(int), cmpfunc);
Pair *frequency = malloc(sizeof(Pair) * size);
int current = arr[0];
int freq = 1;
int index = 0;
for (int i = 1; i < size; i++) {
if (arr[i] == current) {
freq++;
... | int main() {
int count1, count2, count3;
int arr1[] = {10,10,10,10,20,20,20,20,40,40,50,50,30};
Pair *result1 = func0(arr1, 13, &count1);
assert(count1 == 5);
assert(result1[0].key == 10 && result1[0].value == 4);
assert(result1[1].key == 20 && result1[1].value == 4);
assert(res... | O3 | c | func0:
endbr64
push %r13
lea -0x1d(%rip),%rcx
mov %rdi,%r13
push %r12
movslq %esi,%r12
push %rbp
mov %r12,%rsi
push %rbx
mov %rdx,%rbx
mov $0x4,%edx
sub $0x8,%rsp
callq 10a0 <qsort@plt>
lea 0x0(,%r12,8),%rdi
callq 10d0 <malloc@plt>
mov 0x0(%r13),%r9d
cmp $0x1,%r12d
jle 1738 <func... | func0:
endbr64
push r13
lea rcx, cmpfunc; compar
push r12
mov r12, rdi
push rbp
movsxd rbp, esi
push rbx
mov rsi, rbp; nmemb
mov rbx, rdx
mov edx, 4; size
sub rsp, 8
call _qsort
lea rdi, ds:0[rbp*8]; size
call _malloc
mov edx, [r12]
mov r9, rax
cmp ebp, 1
jle ... | _DWORD * func0(int *a1, int a2, int *a3)
{
_DWORD *v6; // rax
int v7; // edx
_DWORD *v8; // r9
int *v9; // rax
int v10; // esi
int v11; // edi
long long v12; // r10
long long v13; // r8
_DWORD *v14; // r8
int v15; // ecx
long long v16; // rax
int v17; // esi
_DWORD *result; // rax
qsort(a1,... | func0:
ENDBR64
PUSH R13
LEA RCX,[0x101660]
PUSH R12
MOV R12,RDI
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV RSI,RBP
MOV RBX,RDX
MOV EDX,0x4
SUB RSP,0x8
CALL 0x001010a0
LEA RDI,[RBP*0x8]
CALL 0x001010d0
MOV EDX,dword ptr [R12]
MOV R9,RAX
CMP EBP,0x1
JLE 0x00101728
LEA ECX,[RBP + -0x2]
LEA RAX,[R12 + 0x4]
XOR ESI,ESI
MOV EDI,0x... | int * func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
long lVar7;
qsort(param_1,(long)param_2,4,cmpfunc);
piVar1 = (int *)malloc((long)param_2 * 8);
iVar3 = *param_1;
if (param_2 < 2) {
iVar5 = 1;
iVar6 = 1;
piVar... |
4,248 | func0 |
#include <assert.h>
| int func0(int N) {
return N - 1;
}
| int main() {
assert(func0(11) == 10);
assert(func0(7) == 6);
assert(func0(12) == 11);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
sub $0x1,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
sub eax, 1
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(a1 - 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
POP RBP
RET | int func0(int param_1)
{
return param_1 + -1;
} |
4,249 | func0 |
#include <assert.h>
| int func0(int N) {
return N - 1;
}
| int main() {
assert(func0(11) == 10);
assert(func0(7) == 6);
assert(func0(12) == 11);
return 0;
}
| O1 | c | func0:
endbr64
lea -0x1(%rdi),%eax
retq
| func0:
endbr64
lea eax, [rdi-1]
retn | long long func0(int a1)
{
return (unsigned int)(a1 - 1);
} | func0:
ENDBR64
LEA EAX,[RDI + -0x1]
RET | int func0(int param_1)
{
return param_1 + -1;
} |
4,250 | func0 |
#include <assert.h>
| int func0(int N) {
return N - 1;
}
| int main() {
assert(func0(11) == 10);
assert(func0(7) == 6);
assert(func0(12) == 11);
return 0;
}
| O2 | c | func0:
endbr64
lea -0x1(%rdi),%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi-1]
retn | long long func0(int a1)
{
return (unsigned int)(a1 - 1);
} | func0:
ENDBR64
LEA EAX,[RDI + -0x1]
RET | int func0(int param_1)
{
return param_1 + -1;
} |
4,251 | func0 |
#include <assert.h>
| int func0(int N) {
return N - 1;
}
| int main() {
assert(func0(11) == 10);
assert(func0(7) == 6);
assert(func0(12) == 11);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rdi),%eax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
lea eax, [rdi-1]
retn | long long func0(int a1)
{
return (unsigned int)(a1 - 1);
} | func0:
ENDBR64
LEA EAX,[RDI + -0x1]
RET | int func0(int param_1)
{
return param_1 + -1;
} |
4,252 | func0 | #include <assert.h>
#include <string.h>
| int func0(char *list1[], int num_elements) {
int max = strlen(list1[0]);
for (int i = 0; i < num_elements; i++) {
if (strlen(list1[i]) > max) {
max = strlen(list1[i]);
}
}
return max;
}
| int main() {
char *list1[] = {"python", "PHP", "bigdata"};
char *list2[] = {"a", "ab", "abc"};
char *list3[] = {"small", "big", "tall"};
assert(func0(list1, 3) == 7);
assert(func0(list2, 3) == 3);
assert(func0(list3, 3) == 5);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 1207 <func0+0x7e>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+var_18]
mov rax, [rax]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov [rbp+var_4], 0
jmp short loc_1207
loc_11B7:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds... | long long func0(const char **a1, int a2)
{
unsigned int v3; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v3 = strlen(*a1);
for ( i = 0; i < a2; ++i )
{
if ( (int)v3 < strlen(a1[i]) )
v3 = strlen(a1[i]);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101207
LAB_001011b7:
MOV EAX,dword ptr [RBP + -0x4]
C... | int func0(int8 *param_1,int param_2)
{
size_t sVar1;
int local_10;
int local_c;
sVar1 = strlen((char *)*param_1);
local_10 = (int)sVar1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
sVar1 = strlen((char *)param_1[local_c]);
if ((ulong)(long)local_10 < sVar1) {
sVar1 = strl... |
4,253 | func0 | #include <assert.h>
#include <string.h>
| int func0(char *list1[], int num_elements) {
int max = strlen(list1[0]);
for (int i = 0; i < num_elements; i++) {
if (strlen(list1[i]) > max) {
max = strlen(list1[i]);
}
}
return max;
}
| int main() {
char *list1[] = {"python", "PHP", "bigdata"};
char *list2[] = {"a", "ab", "abc"};
char *list3[] = {"small", "big", "tall"};
assert(func0(list1, 3) == 7);
assert(func0(list2, 3) == 3);
assert(func0(list3, 3) == 5);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r9
mov (%rdi),%rdi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r8d
test %esi,%esi
jle 11c5 <func0+0x5c>
mov %r9,%rdx
lea -0x1(%rsi),%eax
lea 0x8(%r9,%rax,8),%r10
mov $0xffffffffffffffff,%r9
mov $0x0,%eax
mov... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
mov r13d, esi
mov rdi, [rdi]
call _strlen
mov ebp, eax
test r13d, r13d
jle short loc_11D2
mov rbx, r12
lea eax, [r13-1]
lea r12, [r12+rax*8+8]
loc_11B8:
mov rdi, [rbx]
call _strlen
mov... | long long func0(_QWORD *a1, int a2)
{
unsigned int v2; // ebp
_QWORD *v3; // rbx
unsigned long long v4; // rax
v2 = strlen(*a1);
if ( a2 > 0 )
{
v3 = a1;
do
{
v4 = strlen(*v3);
if ( v4 > (int)v2 )
v2 = v4;
++v3;
}
while ( v3 != &a1[(unsigned int)(a2 - 1) + 1] ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV R13D,ESI
MOV RDI,qword ptr [RDI]
CALL 0x00101070
MOV EBP,EAX
TEST R13D,R13D
JLE 0x001011d2
MOV RBX,R12
LEA EAX,[R13 + -0x1]
LEA R12,[R12 + RAX*0x8 + 0x8]
LAB_001011b8:
MOV RDI,qword ptr [RBX]
CALL 0x00101070
MOVSXD RDX,EBP
CMP RAX,RDX
CMOVA ... | ulong func0(int8 *param_1,int param_2)
{
int8 *puVar1;
size_t sVar2;
ulong uVar3;
sVar2 = strlen((char *)*param_1);
uVar3 = sVar2 & 0xffffffff;
if (0 < param_2) {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
sVar2 = strlen((char *)*param_1);
if ((ulong)(long)(int)uVar3 < sVar2) ... |
4,254 | func0 | #include <assert.h>
#include <string.h>
| int func0(char *list1[], int num_elements) {
int max = strlen(list1[0]);
for (int i = 0; i < num_elements; i++) {
if (strlen(list1[i]) > max) {
max = strlen(list1[i]);
}
}
return max;
}
| int main() {
char *list1[] = {"python", "PHP", "bigdata"};
char *list2[] = {"a", "ab", "abc"};
char *list3[] = {"small", "big", "tall"};
assert(func0(list1, 3) == 7);
assert(func0(list2, 3) == 3);
assert(func0(list3, 3) == 5);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
mov (%rdi),%rdi
callq 1070 <strlen@plt>
mov %eax,%r12d
test %ebp,%ebp
jle 131b <func0+0x4b>
add $0x8,%rbx
lea -0x1(%rbp),%edx
lea (%rbx,%rdx,8),%rbp
jmp 130c <func0+0x3c>
nopl 0x0(%rax)
mov (%rbx),%rdi
add ... | func0:
endbr64
push r12
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
mov rdi, [rdi]
call _strlen
mov r12d, eax
test ebp, ebp
jle short loc_131B
add rbx, 8
lea edx, [rbp-1]
lea rbp, [rbx+rdx*8]
jmp short loc_130C
loc_1300:
mov rdi, [rbx]
add rbx, 8
call _strle... | long long func0(_QWORD *a1, int a2)
{
unsigned long long v2; // rax
unsigned int v3; // r12d
long long *v4; // rbx
long long v5; // rbp
long long v6; // rdi
v2 = strlen(*a1);
v3 = v2;
if ( a2 > 0 )
{
v4 = a1 + 1;
v5 = (long long)&a1[(unsigned int)(a2 - 1) + 1];
while ( 1 )
{
if... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
CALL 0x00101070
MOV R12D,EAX
TEST EBP,EBP
JLE 0x0010131b
ADD RBX,0x8
LEA EDX,[RBP + -0x1]
LEA RBP,[RBX + RDX*0x8]
JMP 0x0010130c
LAB_00101300:
MOV RDI,qword ptr [RBX]
ADD RBX,0x8
CALL 0x00101070
LAB_0010130c:
MOVSXD RDX,R12D
CMP R... | ulong func0(int8 *param_1,int param_2)
{
int8 *puVar1;
char *__s;
ulong uVar2;
ulong uVar3;
uVar2 = strlen((char *)*param_1);
uVar3 = uVar2 & 0xffffffff;
if (0 < param_2) {
param_1 = param_1 + 1;
puVar1 = param_1 + (param_2 - 1);
while( true ) {
if ((ulong)(long)(int)uVar3 < uVar2) {... |
4,255 | func0 | #include <assert.h>
#include <string.h>
| int func0(char *list1[], int num_elements) {
int max = strlen(list1[0]);
for (int i = 0; i < num_elements; i++) {
if (strlen(list1[i]) > max) {
max = strlen(list1[i]);
}
}
return max;
}
| int main() {
char *list1[] = {"python", "PHP", "bigdata"};
char *list2[] = {"a", "ab", "abc"};
char *list3[] = {"small", "big", "tall"};
assert(func0(list1, 3) == 7);
assert(func0(list2, 3) == 3);
assert(func0(list3, 3) == 5);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
mov (%rdi),%rdi
callq 1070 <strlen@plt>
mov %eax,%r12d
test %ebp,%ebp
jle 133b <func0+0x4b>
add $0x8,%rbx
lea -0x1(%rbp),%edx
lea (%rbx,%rdx,8),%rbp
jmp 132c <func0+0x3c>
nopl 0x0(%rax)
mov (%rbx),%rdi
add ... | func0:
endbr64
push r12
movsxd r12, esi
push rbp
push rbx
mov rbx, rdi
mov rdi, [rdi]; s
call _strlen
mov ebp, eax
test r12d, r12d
jle short loc_1322
lea r12, [rbx+r12*8]
jmp short loc_1310
loc_1308:
mov rdi, [rbx]; s
call _strlen
loc_1310:
movsxd rdx, ebp
cmp rdx, ra... | long long func0(const char **a1, int a2)
{
const char **v2; // rbx
size_t v3; // rax
unsigned int v4; // ebp
v2 = a1;
v3 = strlen(*a1);
v4 = v3;
if ( a2 > 0 )
{
while ( 1 )
{
if ( (int)v4 < v3 )
v4 = v3;
if ( ++v2 == &a1[a2] )
break;
v3 = strlen(*v2);
}
... | func0:
ENDBR64
PUSH R12
MOVSXD R12,ESI
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
CALL 0x00101070
MOV EBP,EAX
TEST R12D,R12D
JLE 0x00101322
LEA R12,[RBX + R12*0x8]
JMP 0x00101310
LAB_00101308:
MOV RDI,qword ptr [RBX]
CALL 0x00101070
LAB_00101310:
MOVSXD RDX,EBP
CMP RDX,RAX
CMOVC EBP,EAX
ADD RBX,0x8
CMP RBX,R... | ulong func0(int8 *param_1,int param_2)
{
int8 *puVar1;
ulong uVar2;
ulong uVar3;
uVar2 = strlen((char *)*param_1);
uVar3 = uVar2 & 0xffffffff;
if (0 < param_2) {
puVar1 = param_1 + param_2;
while( true ) {
if ((ulong)(long)(int)uVar3 < uVar2) {
uVar3 = uVar2 & 0xffffffff;
}
... |
4,256 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(char *str1[], char *sub_str, int size) {
for (int i = 0; i < size; i++) {
if (strstr(str1[i], sub_str) != NULL) {
return true;
}
}
return false;
}
| int main() {
char *array[] = {"red", "black", "white", "green", "orange"};
int size = sizeof(array) / sizeof(array[0]);
assert(func0(array, "ack", size) == true);
assert(func0(array, "abc", size) == false);
assert(func0(array, "ange", size) == true);
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)
movl $0x0,-0x4(%rbp)
jmp 11df <func0+0x56>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x20(%rbp),%rdx
m... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+needle], rsi
mov [rbp+var_24], edx
mov [rbp+var_4], 0
jmp short loc_11DF
loc_11A9:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov ... | long long func0(long long a1, const char *a2, int a3)
{
int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a3; ++i )
{
if ( strstr(*(const char **)(8LL * i + a1), a2) )
return 1LL;
}
return 0LL;
} | 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 + -0x4],0x0
JMP 0x001011df
LAB_001011a9:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr... | int8 func0(long param_1,char *param_2,int param_3)
{
char *pcVar1;
int local_c;
local_c = 0;
while( true ) {
if (param_3 <= local_c) {
return 0;
}
pcVar1 = strstr(*(char **)(param_1 + (long)local_c * 8),param_2);
if (pcVar1 != (char *)0x0) break;
local_c = local_c + 1;
}
return... |
4,257 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(char *str1[], char *sub_str, int size) {
for (int i = 0; i < size; i++) {
if (strstr(str1[i], sub_str) != NULL) {
return true;
}
}
return false;
}
| int main() {
char *array[] = {"red", "black", "white", "green", "orange"};
int size = sizeof(array) / sizeof(array[0]);
assert(func0(array, "ack", size) == true);
assert(func0(array, "abc", size) == false);
assert(func0(array, "ange", size) == true);
return 0;
}
| O1 | c | func0:
endbr64
test %edx,%edx
jle 11be <func0+0x35>
push %r12
push %rbp
push %rbx
mov %rsi,%rbp
mov %rdi,%rbx
lea -0x1(%rdx),%eax
lea 0x8(%rdi,%rax,8),%r12
mov %rbp,%rsi
mov (%rbx),%rdi
callq 1090 <strstr@plt>
test %rax,%rax
jne 11c4 <func0+0x3b>
add $0x8,%rbx
cmp %r12,%rbx
jne ... | func0:
endbr64
test edx, edx
jle short loc_11BE
push r12
push rbp
push rbx
mov rbp, rsi
mov rbx, rdi
lea eax, [rdx-1]
lea r12, [rdi+rax*8+8]
loc_11A3:
mov rsi, rbp
mov rdi, [rbx]
call _strstr
test rax, rax
jnz short loc_11C4
add rbx, 8
cmp rbx, r12
jnz short... | long long func0(_QWORD *a1, long long a2, int a3)
{
_QWORD *v3; // rbx
long long v4; // r12
long long result; // rax
if ( a3 <= 0 )
return 0LL;
v3 = a1;
v4 = (long long)&a1[(unsigned int)(a3 - 1) + 1];
while ( 1 )
{
result = strstr(*v3, a2);
if ( result )
break;
if ( ++v3 == (_QW... | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001011be
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RSI
MOV RBX,RDI
LEA EAX,[RDX + -0x1]
LEA R12,[RDI + RAX*0x8 + 0x8]
LAB_001011a3:
MOV RSI,RBP
MOV RDI,qword ptr [RBX]
CALL 0x00101090
TEST RAX,RAX
JNZ 0x001011c4
ADD RBX,0x8
CMP RBX,R12
JNZ 0x001011a3
JMP 0x001011c9
LAB_001011be:
MOV EAX,0x0
R... | int8 func0(int8 *param_1,char *param_2,int param_3)
{
int8 *puVar1;
char *pcVar2;
if (param_3 < 1) {
return 0;
}
puVar1 = param_1 + (ulong)(param_3 - 1) + 1;
do {
pcVar2 = strstr((char *)*param_1,param_2);
if (pcVar2 != (char *)0x0) {
return 1;
}
param_1 = param_1 + 1;
} whil... |
4,258 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(char *str1[], char *sub_str, int size) {
for (int i = 0; i < size; i++) {
if (strstr(str1[i], sub_str) != NULL) {
return true;
}
}
return false;
}
| int main() {
char *array[] = {"red", "black", "white", "green", "orange"};
int size = sizeof(array) / sizeof(array[0]);
assert(func0(array, "ack", size) == true);
assert(func0(array, "abc", size) == false);
assert(func0(array, "ange", size) == true);
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
jle 1333 <func0+0x43>
lea -0x1(%rdx),%eax
push %r12
lea 0x8(%rdi,%rax,8),%r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
jmp 1319 <func0+0x29>
nopl 0x0(%rax)
add $0x8,%rbx
cmp %r12,%rbx
je 132e <func0+0x3e>
mov (%rbx),%rdi
mov %rbp,%rsi
call... | func0:
endbr64
test edx, edx
jle short loc_12F3
lea eax, [rdx-1]
push r12
lea r12, [rdi+rax*8+8]
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
jmp short loc_12D9
loc_12D0:
add rbx, 8
cmp rbx, r12
jz short loc_12EE
loc_12D9:
mov rdi, [rbx]
mov rsi, rbp
call _strs... | long long func0(_QWORD *a1, long long a2, int a3)
{
long long v3; // r12
_QWORD *v4; // rbx
long long result; // rax
if ( a3 <= 0 )
return 0LL;
v3 = (long long)&a1[(unsigned int)(a3 - 1) + 1];
v4 = a1;
while ( 1 )
{
result = strstr(*v4, a2);
if ( result )
break;
if ( ++v4 == (_QW... | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001012f3
LEA EAX,[RDX + -0x1]
PUSH R12
LEA R12,[RDI + RAX*0x8 + 0x8]
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
JMP 0x001012d9
LAB_001012d0:
ADD RBX,0x8
CMP RBX,R12
JZ 0x001012ee
LAB_001012d9:
MOV RDI,qword ptr [RBX]
MOV RSI,RBP
CALL 0x00101090
TEST RAX,RAX
JZ 0x001012d0
MOV EAX,0x1
LAB... | int8 func0(int8 *param_1,char *param_2,int param_3)
{
int8 *puVar1;
char *pcVar2;
if (param_3 < 1) {
return 0;
}
puVar1 = param_1 + (ulong)(param_3 - 1) + 1;
do {
pcVar2 = strstr((char *)*param_1,param_2);
if (pcVar2 != (char *)0x0) {
return 1;
}
param_1 = param_1 + 1;
} whil... |
4,259 | func0 |
#include <stdbool.h>
#include <assert.h>
#include <string.h>
| bool func0(char *str1[], char *sub_str, int size) {
for (int i = 0; i < size; i++) {
if (strstr(str1[i], sub_str) != NULL) {
return true;
}
}
return false;
}
| int main() {
char *array[] = {"red", "black", "white", "green", "orange"};
int size = sizeof(array) / sizeof(array[0]);
assert(func0(array, "ack", size) == true);
assert(func0(array, "abc", size) == false);
assert(func0(array, "ange", size) == true);
return 0;
}
| O3 | c | func0:
endbr64
test %edx,%edx
jle 1323 <func0+0x43>
lea -0x1(%rdx),%eax
push %r12
lea 0x8(%rdi,%rax,8),%r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
jmp 1309 <func0+0x29>
nopl 0x0(%rax)
add $0x8,%rbx
cmp %r12,%rbx
je 131e <func0+0x3e>
mov (%rbx),%rdi
mov %rbp,%rsi
call... | func0:
endbr64
test edx, edx
jle short loc_11A3
movsxd rdx, edx
push r12
lea r12, [rdi+rdx*8]
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
jmp short loc_1189
loc_1180:
add rbx, 8
cmp rbx, r12
jz short loc_119E
loc_1189:
mov rdi, [rbx]; haystack
mov rsi, rbp; needle
c... | char * func0(const char **a1, const char *a2, int a3)
{
const char **v3; // r12
const char **v4; // rbx
char *result; // rax
if ( a3 <= 0 )
return 0LL;
v3 = &a1[a3];
v4 = a1;
while ( 1 )
{
result = strstr(*v4, a2);
if ( result )
break;
if ( ++v4 == v3 )
return result;
}
... | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001011a3
MOVSXD RDX,EDX
PUSH R12
LEA R12,[RDI + RDX*0x8]
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
JMP 0x00101189
LAB_00101180:
ADD RBX,0x8
CMP RBX,R12
JZ 0x0010119e
LAB_00101189:
MOV RDI,qword ptr [RBX]
MOV RSI,RBP
CALL 0x00101050
TEST RAX,RAX
JZ 0x00101180
MOV EAX,0x1
LAB_0010119e:
P... | int8 func0(int8 *param_1,char *param_2,int param_3)
{
int8 *puVar1;
char *pcVar2;
if (param_3 < 1) {
return 0;
}
puVar1 = param_1 + param_3;
do {
pcVar2 = strstr((char *)*param_1,param_2);
if (pcVar2 != (char *)0x0) {
return 1;
}
param_1 = param_1 + 1;
} while (param_1 != puV... |
4,260 | func0 |
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(const char *n) {
int length = strlen(n);
if (length <= 2) {
return false;
}
for (int i = 2; i < length; i++) {
if (n[i - 2] != n[i]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("1212121") == true);
assert(func0("1991") == false);
assert(func0("121") == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
mov %eax,-0x4(%rbp)
cmpl $0x2,-0x4(%rbp)
jg 1195 <func0+0x2c>
mov $0x0,%eax
jmp 11dd <func0+0x74>
movl $0x2,-0x8(%rbp)
jmp 11d0 <func0+0x67>
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
cmp [rbp+var_4], 2
jg short loc_1195
mov eax, 0
jmp short locret_11DD
loc_1195:
mov [rbp+var_8], 2
jmp short loc_11D0
loc_119E:
mov... | long long func0(const char *a1)
{
int i; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
v3 = strlen(a1);
if ( v3 <= 2 )
return 0LL;
for ( i = 2; i < v3; ++i )
{
if ( a1[i - 2] != a1[i] )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101060
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x2
JG 0x00101195
MOV EAX,0x0
JMP 0x001011dd
LAB_00101195:
MOV dword ptr [RBP + -0x8],0x2
JMP 0x001011d0
LAB_0010119e:
MO... | int8 func0(char *param_1)
{
size_t sVar1;
int8 uVar2;
int local_10;
sVar1 = strlen(param_1);
if ((int)sVar1 < 3) {
uVar2 = 0;
}
else {
for (local_10 = 2; local_10 < (int)sVar1; local_10 = local_10 + 1) {
if (param_1[(long)local_10 + -2] != param_1[local_10]) {
return 0;
}
... |
4,261 | func0 |
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(const char *n) {
int length = strlen(n);
if (length <= 2) {
return false;
}
for (int i = 2; i < length; i++) {
if (n[i - 2] != n[i]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("1212121") == true);
assert(func0("1991") == false);
assert(func0("121") == true);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rdx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
cmp $0x2,%ecx
jle 1192 <func0+0x49>
mov %rdx,%rax
lea -0x3(%rcx),%ecx
lea 0x1(%rdx,%rcx,1),%rdx
movzbl 0x2(%rax),%esi
cmp %sil,(%rax)
jne 118d <func0+0x44>
add ... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov edx, 0
cmp eax, 2
jle short loc_11A8
mov rdx, rbx
lea eax, [rax-3]
lea rax, [rbx+rax+1]
loc_118B:
movzx ecx, byte ptr [rdx+2]
cmp [rdx], cl
jnz short loc_11A3
add rdx, 1
cmp rdx, rax
jnz short loc_118B
mov ... | long long func0(_BYTE *a1)
{
int v1; // eax
unsigned int v2; // edx
_BYTE *v3; // rdx
long long v4; // rax
v1 = strlen();
v2 = 0;
if ( v1 > 2 )
{
v3 = a1;
v4 = (long long)&a1[v1 - 3 + 1];
while ( *v3 == v3[2] )
{
if ( ++v3 == (_BYTE *)v4 )
return 1;
}
return 0;
... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV EDX,0x0
CMP EAX,0x2
JLE 0x001011a8
MOV RDX,RBX
LEA EAX,[RAX + -0x3]
LEA RAX,[RBX + RAX*0x1 + 0x1]
LAB_0010118b:
MOVZX ECX,byte ptr [RDX + 0x2]
CMP byte ptr [RDX],CL
JNZ 0x001011a3
ADD RDX,0x1
CMP RDX,RAX
JNZ 0x0010118b
MOV EDX,0x1
JMP 0x001011a8
LAB_001011a3:
MOV ... | int8 func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
int8 uVar3;
sVar2 = strlen(param_1);
uVar3 = 0;
if (2 < (int)sVar2) {
pcVar1 = param_1 + (ulong)((int)sVar2 - 3) + 1;
do {
if (*param_1 != param_1[2]) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != pc... |
4,262 | func0 |
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(const char *n) {
int length = strlen(n);
if (length <= 2) {
return false;
}
for (int i = 2; i < length; i++) {
if (n[i - 2] != n[i]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("1212121") == true);
assert(func0("1991") == false);
assert(func0("121") == true);
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
xor %r8d,%r8d
cmp $0x2,%eax
jle 1247 <func0+0x37>
sub $0x3,%eax
mov %rbx,%rdi
lea 0x1(%rbx,%rax,1),%rax
movzbl 0x2(%rdi),%edx
cmp %dl,(%rdi)
jne 1250 <func0+0x40>
add $0x1,%rdi
cmp %rax,%rdi
jne 1230 <func0+0x20>
mov ... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
xor r8d, r8d
cmp eax, 2
jle short loc_1247
sub eax, 3
mov rdi, rbx
lea rax, [rbx+rax+1]
loc_1230:
movzx edx, byte ptr [rdi+2]
cmp [rdi], dl
jnz short loc_1250
add rdi, 1
cmp rdi, rax
jnz short loc_1230
mov r8d,... | long long func0(_BYTE *a1)
{
int v1; // eax
unsigned int v2; // r8d
long long v3; // rax
v1 = strlen();
v2 = 0;
if ( v1 <= 2 )
return v2;
v3 = (long long)&a1[v1 - 3 + 1];
while ( *a1 == a1[2] )
{
if ( ++a1 == (_BYTE *)v3 )
return 1;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
XOR R8D,R8D
CMP EAX,0x2
JLE 0x00101247
SUB EAX,0x3
MOV RDI,RBX
LEA RAX,[RBX + RAX*0x1 + 0x1]
LAB_00101230:
MOVZX EDX,byte ptr [RDI + 0x2]
CMP byte ptr [RDI],DL
JNZ 0x00101250
ADD RDI,0x1
CMP RDI,RAX
JNZ 0x00101230
MOV R8D,0x1
LAB_00101247:
MOV EAX,R8D
POP RBX
RET
LAB_... | int8 func0(char *param_1)
{
char *pcVar1;
size_t sVar2;
int8 uVar3;
sVar2 = strlen(param_1);
uVar3 = 0;
if (2 < (int)sVar2) {
pcVar1 = param_1 + (ulong)((int)sVar2 - 3) + 1;
do {
if (*param_1 != param_1[2]) {
return 0;
}
param_1 = param_1 + 1;
} while (param_1 != pc... |
4,263 | func0 |
#include <stdbool.h>
#include <string.h>
#include <assert.h>
| bool func0(const char *n) {
int length = strlen(n);
if (length <= 2) {
return false;
}
for (int i = 2; i < length; i++) {
if (n[i - 2] != n[i]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("1212121") == true);
assert(func0("1991") == false);
assert(func0("121") == true);
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
xor %r8d,%r8d
cmp $0x2,%eax
jle 1259 <func0+0x49>
sub $0x3,%eax
movzbl (%rbx),%ecx
movzbl 0x1(%rbx),%esi
lea 0x2(%rbx),%rdx
lea 0x3(%rbx,%rax,1),%rdi
jmp 1242 <func0+0x32>
nopw 0x0(%rax,%rax,1)
mov %eax,%ecx
cmp %cl,(%rdx)... | func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
xor edx, edx
cmp eax, 2
jle short loc_1257
sub eax, 3
movzx esi, byte ptr [rbx]
movzx ecx, byte ptr [rbx+1]
lea rdx, [rbx+2]
lea rdi, [rbx+rax+3]
jmp short loc_124B
loc_1240:
add rdx, 1
mov esi, eax
cmp rdx, rdi
jz ... | long long func0(long long a1)
{
int v1; // eax
char v2; // si
char v3; // cl
char *v4; // rdx
long long v5; // rdi
char v6; // al
v1 = strlen((const char *)a1);
if ( v1 > 2 )
{
v2 = *(_BYTE *)a1;
v3 = *(_BYTE *)(a1 + 1);
v4 = (char *)(a1 + 2);
v5 = a1 + (unsigned int)(v1 - 3) + 3;
... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
XOR EDX,EDX
CMP EAX,0x2
JLE 0x00101257
SUB EAX,0x3
MOVZX ESI,byte ptr [RBX]
MOVZX ECX,byte ptr [RBX + 0x1]
LEA RDX,[RBX + 0x2]
LEA RDI,[RBX + RAX*0x1 + 0x3]
JMP 0x0010124b
LAB_00101240:
ADD RDX,0x1
MOV ESI,EAX
CMP RDX,RDI
JZ 0x00101260
LAB_0010124b:
MOV EAX,ECX
MOVZX ... | int8 func0(char *param_1)
{
char cVar1;
size_t sVar2;
char cVar3;
char *pcVar4;
char cVar5;
sVar2 = strlen(param_1);
if (2 < (int)sVar2) {
pcVar4 = param_1 + 2;
cVar5 = *param_1;
cVar3 = param_1[1];
while (cVar1 = *pcVar4, cVar1 == cVar5) {
pcVar4 = pcVar4 + 1;
cVar5 = cVar... |
4,264 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (b == 0)
return 1;
else if (a == 0)
return 0;
else if (b == 1)
return a;
else
return a * func0(a, b - 1);
}
| int main() {
assert(func0(3, 4) == 81);
assert(func0(2, 3) == 8);
assert(func0(5, 5) == 3125);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jne 1168 <func0+0x1f>
mov $0x1,%eax
jmp 1196 <func0+0x4d>
cmpl $0x0,-0x4(%rbp)
jne 1175 <func0+0x2c>
mov $0x0,%eax
jmp 1196 <func0+0x4d>
cmpl $0x1,-0x8(%rbp)
jne 11... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov [rbp+var_8], esi
cmp [rbp+var_8], 0
jnz short loc_1168
mov eax, 1
jmp short locret_1196
loc_1168:
cmp [rbp+var_4], 0
jnz short loc_1175
mov eax, 0
jmp short locret_1196
loc_1175:
cmp [rbp+va... | long long func0(unsigned int a1, int a2)
{
if ( !a2 )
return 1LL;
if ( !a1 )
return 0LL;
if ( a2 == 1 )
return a1;
return a1 * (unsigned int)func0(a1, (unsigned int)(a2 - 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
CMP dword ptr [RBP + -0x8],0x0
JNZ 0x00101168
MOV EAX,0x1
JMP 0x00101196
LAB_00101168:
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x00101175
MOV EAX,0x0
JMP 0x00101196
LAB_00101175:
CMP dword ptr [RBP + -0x8],0x1
JNZ ... | int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 == 0) {
param_1 = 1;
}
else if (param_1 == 0) {
param_1 = 0;
}
else if (param_2 != 1) {
iVar1 = func0(param_1,param_2 + -1);
param_1 = iVar1 * param_1;
}
return param_1;
} |
4,265 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (b == 0)
return 1;
else if (a == 0)
return 0;
else if (b == 1)
return a;
else
return a * func0(a, b - 1);
}
| int main() {
assert(func0(3, 4) == 81);
assert(func0(2, 3) == 8);
assert(func0(5, 5) == 3125);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%eax
test %esi,%esi
je 1173 <func0+0x2a>
push %rbx
mov %edi,%ebx
mov %edi,%eax
test %edi,%edi
je 1164 <func0+0x1b>
cmp $0x1,%esi
jne 1166 <func0+0x1d>
pop %rbx
retq
sub $0x1,%esi
callq 1149 <func0>
imul %ebx,%eax
jmp 1164 <func0+0x1b>
retq
| func0:
endbr64
mov eax, 1
test esi, esi
jz short locret_1173
push rbx
mov ebx, edi
mov eax, edi
test edi, edi
jz short loc_1164
cmp esi, 1
jnz short loc_1166
loc_1164:
pop rbx
retn
loc_1166:
sub esi, 1
call func0
imul eax, ebx
jmp short loc_1164
locret_1173:
retn | long long func0(long long a1, int a2)
{
long long result; // rax
result = 1LL;
if ( a2 )
{
result = (unsigned int)a1;
if ( (_DWORD)a1 )
{
if ( a2 != 1 )
return (unsigned int)a1 * (unsigned int)func0(a1, (unsigned int)(a2 - 1));
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
TEST ESI,ESI
JZ 0x00101173
PUSH RBX
MOV EBX,EDI
MOV EAX,EDI
TEST EDI,EDI
JZ 0x00101164
CMP ESI,0x1
JNZ 0x00101166
LAB_00101164:
POP RBX
RET
LAB_00101166:
SUB ESI,0x1
CALL 0x00101149
IMUL EAX,EBX
JMP 0x00101164
LAB_00101173:
RET | int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 != 0) {
if ((param_1 != 0) && (param_2 != 1)) {
iVar1 = func0(param_1,param_2 + -1);
param_1 = iVar1 * param_1;
}
return param_1;
}
return 1;
} |
4,266 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (b == 0)
return 1;
else if (a == 0)
return 0;
else if (b == 1)
return a;
else
return a * func0(a, b - 1);
}
| int main() {
assert(func0(3, 4) == 81);
assert(func0(2, 3) == 8);
assert(func0(5, 5) == 3125);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
je 1174 <func0+0x34>
test %edi,%edi
je 117a <func0+0x3a>
cmp $0x1,%esi
je 117d <func0+0x3d>
mov $0x1,%eax
jmp 1165 <func0+0x25>
nopl 0x0(%rax,%rax,1)
cmp $0x1,%esi
je 1170 <func0+0x30>
imul %edi,%eax
sub $0x1,%esi
jne 1160 <func0+0x20>
retq
xchg ... | func0:
endbr64
test esi, esi
jz short loc_1174
test edi, edi
jz short loc_117A
cmp esi, 1
jz short loc_117D
mov eax, 1
jmp short loc_1165
loc_1160:
cmp esi, 1
jz short loc_1170
loc_1165:
imul eax, edi
sub esi, 1
jnz short loc_1160
retn
loc_1170:
imul eax, edi
retn... | long long func0(unsigned int a1, int a2)
{
long long result; // rax
if ( !a2 )
return 1LL;
if ( !a1 )
return 0LL;
if ( a2 == 1 )
return a1;
LODWORD(result) = 1;
while ( 1 )
{
result = a1 * (unsigned int)result;
if ( !--a2 )
break;
if ( a2 == 1 )
return a1 * (unsigned ... | func0:
ENDBR64
TEST ESI,ESI
JZ 0x00101174
TEST EDI,EDI
JZ 0x0010117a
CMP ESI,0x1
JZ 0x0010117d
MOV EAX,0x1
JMP 0x00101165
LAB_00101160:
CMP ESI,0x1
JZ 0x00101170
LAB_00101165:
IMUL EAX,EDI
SUB ESI,0x1
JNZ 0x00101160
RET
LAB_00101170:
IMUL EAX,EDI
RET
LAB_00101174:
MOV EAX,0x1
RET
LAB_0010117a:
XOR EAX,EAX
RET
LAB_00101... | int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 == 0) {
return 1;
}
if (param_1 != 0) {
if (param_2 == 1) {
return param_1;
}
iVar1 = 1;
do {
iVar1 = iVar1 * param_1;
param_2 = param_2 + -1;
if (param_2 == 0) {
return iVar1;
}
} while... |
4,267 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (b == 0)
return 1;
else if (a == 0)
return 0;
else if (b == 1)
return a;
else
return a * func0(a, b - 1);
}
| int main() {
assert(func0(3, 4) == 81);
assert(func0(2, 3) == 8);
assert(func0(5, 5) == 3125);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
je 1174 <func0+0x34>
test %edi,%edi
je 117a <func0+0x3a>
cmp $0x1,%esi
je 117d <func0+0x3d>
mov $0x1,%eax
jmp 1165 <func0+0x25>
nopl 0x0(%rax,%rax,1)
cmp $0x1,%esi
je 1170 <func0+0x30>
imul %edi,%eax
sub $0x1,%esi
jne 1160 <func0+0x20>
retq
xchg ... | func0:
endbr64
test esi, esi
jz short loc_1184
test edi, edi
jz short loc_118A
cmp esi, 1
jz short loc_118D
mov edx, 1
lea eax, [rsi-1]
test sil, 1
jnz short loc_1170
mov esi, eax
mov edx, edi
cmp eax, 1
jz short loc_117E
nop dword ptr [rax+rax+00000000h]
loc... | long long func0(unsigned int a1, int a2)
{
int v2; // edx
int v3; // eax
if ( !a2 )
return 1LL;
if ( !a1 )
return 0LL;
if ( a2 == 1 )
return a1;
v2 = 1;
v3 = a2 - 1;
if ( (a2 & 1) != 0 || (--a2, v2 = a1, v3 != 1) )
{
do
{
a2 -= 2;
v2 *= a1 * a1;
}
while ( a2 !... | func0:
ENDBR64
TEST ESI,ESI
JZ 0x00101184
TEST EDI,EDI
JZ 0x0010118a
CMP ESI,0x1
JZ 0x0010118d
MOV EDX,0x1
LEA EAX,[RSI + -0x1]
TEST SIL,0x1
JNZ 0x00101170
MOV ESI,EAX
MOV EDX,EDI
CMP EAX,0x1
JZ 0x0010117e
NOP dword ptr [RAX + RAX*0x1]
LAB_00101170:
IMUL EDX,EDI
SUB ESI,0x2
IMUL EDX,EDI
CMP ESI,0x1
JNZ 0x00101170
LAB_0... | int func0(int param_1,uint param_2)
{
int iVar1;
uint uVar2;
int iVar3;
if (param_2 == 0) {
return 1;
}
if (param_1 != 0) {
if (param_2 != 1) {
iVar3 = 1;
iVar1 = param_1;
uVar2 = param_2 - 1;
if ((param_2 & 1) != 0) goto LAB_00101170;
while (param_2 = uVar2, iVar3 ... |
4,268 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char test_list[][2][50], int size){
int min_index = 0;
int min_value = atoi(test_list[0][1]);
for (int i = 1; i < size; i++) {
int current_value = atoi(test_list[i][1]);
if (current_value < min_value) {
min_value = current_value;
min_index = i;
... | int main() {
char list1[3][2][50] = {{"Rash", "143"}, {"Manjeet", "200"}, {"Varsha", "100"}};
char list2[3][2][50] = {{"Yash", "185"}, {"Dawood", "125"}, {"Sanya", "175"}};
char list3[3][2][50] = {{"Sai", "345"}, {"Salman", "145"}, {"Ayesha", "96"}};
assert(strcmp(func0(list1, 3), "Varsha") ==... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
mov -0x18(%rbp),%rax
add $0x32,%rax
mov %rax,%rdi
callq 10b0 <atoi@plt>
mov %eax,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
jmp 122f <func0+0x86>
mov -0x8(%rbp),%eax
movslq %ea... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0
mov rax, [rbp+var_18]
add rax, 32h ; '2'
mov rdi, rax; nptr
call _atoi
mov [rbp+var_C], eax
mov [rbp+var_8], 1
jmp short loc_122F
loc_11DF:
mov eax, [rb... | long long func0(long long a1, int a2)
{
long long v3; // [rsp+10h] [rbp-10h]
long long v4; // [rsp+18h] [rbp-8h]
LODWORD(v3) = 0;
HIDWORD(v3) = atoi((const char *)(a1 + 50));
LODWORD(v4) = 1;
while ( (int)v4 < a2 )
{
HIDWORD(v4) = atoi((const char *)(100LL * (int)v4 + a1 + 50));
if ( SHIDWORD(v4... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x32
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0x1
JMP 0x0010122f
LAB_001011df:
MOV EAX,dwo... | long func0(long param_1,int param_2)
{
int iVar1;
int4 local_18;
int4 local_14;
int4 local_10;
local_18 = 0;
local_14 = atoi((char *)(param_1 + 0x32));
for (local_10 = 1; local_10 < param_2; local_10 = local_10 + 1) {
iVar1 = atoi((char *)(param_1 + (long)local_10 * 100 + 0x32));
if (iVar1 < l... |
4,269 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char test_list[][2][50], int size){
int min_index = 0;
int min_value = atoi(test_list[0][1]);
for (int i = 1; i < size; i++) {
int current_value = atoi(test_list[i][1]);
if (current_value < min_value) {
min_value = current_value;
min_index = i;
... | int main() {
char list1[3][2][50] = {{"Rash", "143"}, {"Manjeet", "200"}, {"Varsha", "100"}};
char list2[3][2][50] = {{"Yash", "185"}, {"Dawood", "125"}, {"Sanya", "175"}};
char list3[3][2][50] = {{"Sai", "345"}, {"Salman", "145"}, {"Ayesha", "96"}};
assert(strcmp(func0(list1, 3), "Varsha") ==... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r15
mov %esi,%r13d
lea 0x32(%rdi),%rdi
mov $0xa,%edx
mov $0x0,%esi
callq 1090 <strtol@plt>
cmp $0x1,%r13d
jle 11fc <func0+0x73>
mov %eax,%r12d
lea 0x96(%r15),%rbp
mov $0x1,%eb... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r15, rdi
mov r13d, esi
lea rdi, [rdi+32h]
mov edx, 0Ah
mov esi, 0
call _strtol
cmp r13d, 1
jle short loc_121C
mov r12d, eax
lea rbp, [r15+96h]
mov ebx, 1
mov r14d, 0
j... | long long func0(long long a1, int a2)
{
int v2; // eax
int v3; // r12d
long long v4; // rbp
int v5; // ebx
int v6; // r14d
int v7; // eax
v2 = strtol(a1 + 50, 0LL, 10LL);
if ( a2 <= 1 )
{
v6 = 0;
}
else
{
v3 = v2;
v4 = a1 + 150;
v5 = 1;
v6 = 0;
do
{
v7 = strto... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R15,RDI
MOV R13D,ESI
LEA RDI,[RDI + 0x32]
MOV EDX,0xa
MOV ESI,0x0
CALL 0x001010b0
CMP R13D,0x1
JLE 0x0010121c
MOV R12D,EAX
LEA RBP,[R15 + 0x96]
MOV EBX,0x1
MOV R14D,0x0
JMP 0x001011fd
LAB_001011f1:
ADD EBX,0x1
ADD RBP,0x64
CMP R13D,EBX... | long func0(long param_1,int param_2)
{
ulong uVar1;
ulong uVar2;
int iVar3;
char *__nptr;
int iVar4;
uVar1 = strtol((char *)(param_1 + 0x32),(char **)0x0,10);
if (param_2 < 2) {
iVar4 = 0;
}
else {
uVar1 = uVar1 & 0xffffffff;
__nptr = (char *)(param_1 + 0x96);
iVar3 = 1;
iVar4 ... |
4,270 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char test_list[][2][50], int size){
int min_index = 0;
int min_value = atoi(test_list[0][1]);
for (int i = 1; i < size; i++) {
int current_value = atoi(test_list[i][1]);
if (current_value < min_value) {
min_value = current_value;
min_index = i;
... | int main() {
char list1[3][2][50] = {{"Rash", "143"}, {"Manjeet", "200"}, {"Varsha", "100"}};
char list2[3][2][50] = {{"Yash", "185"}, {"Dawood", "125"}, {"Sanya", "175"}};
char list3[3][2][50] = {{"Sai", "345"}, {"Salman", "145"}, {"Ayesha", "96"}};
assert(strcmp(func0(list1, 3), "Varsha") ==... | O2 | c | func0:
endbr64
push %r15
mov $0xa,%edx
push %r14
push %r13
mov %rdi,%r13
add $0x32,%rdi
push %r12
push %rbp
mov %esi,%ebp
xor %esi,%esi
push %rbx
sub $0x8,%rsp
callq 1090 <strtol@plt>
cmp $0x1,%ebp
jle 1372 <func0+0x72>
mov %eax,%ebx
lea 0x96(%r13),%r15
mov $0x1,%r14d
xor ... | func0:
endbr64
push r15
mov edx, 0Ah
push r14
push r13
mov r13, rdi
add rdi, 32h ; '2'
push r12
push rbp
mov ebp, esi
xor esi, esi
push rbx
sub rsp, 8
call _strtol
cmp ebp, 1
jle short loc_1382
mov ebx, eax
lea r15, [r13+96h]
mov r14d, 1
xor r12d, r12... | long long func0(long long a1, int a2)
{
long long v2; // r13
int v3; // eax
int v4; // ebx
long long v5; // r15
int v6; // r14d
long long v7; // r12
int v8; // eax
v2 = a1;
v3 = strtol(a1 + 50, 0LL, 10LL);
if ( a2 > 1 )
{
v4 = v3;
v5 = a1 + 150;
v6 = 1;
v7 = 0LL;
do
{
... | func0:
ENDBR64
PUSH R15
MOV EDX,0xa
PUSH R14
PUSH R13
MOV R13,RDI
ADD RDI,0x32
PUSH R12
PUSH RBP
MOV EBP,ESI
XOR ESI,ESI
PUSH RBX
SUB RSP,0x8
CALL 0x001010b0
CMP EBP,0x1
JLE 0x00101382
MOV EBX,EAX
LEA R15,[R13 + 0x96]
MOV R14D,0x1
XOR R12D,R12D
NOP
LAB_00101350:
XOR ESI,ESI
MOV EDX,0xa
MOV RDI,R15
CALL 0x001010b0
CMP E... | long func0(long param_1,int param_2)
{
ulong uVar1;
ulong uVar2;
long lVar3;
int iVar4;
char *__nptr;
uVar1 = strtol((char *)(param_1 + 0x32),(char **)0x0,10);
if (1 < param_2) {
uVar1 = uVar1 & 0xffffffff;
__nptr = (char *)(param_1 + 0x96);
iVar4 = 1;
lVar3 = 0;
do {
uVar2 =... |
4,271 | func0 |
#include <assert.h>
#include <string.h>
#include <stdlib.h>
| char* func0(char test_list[][2][50], int size){
int min_index = 0;
int min_value = atoi(test_list[0][1]);
for (int i = 1; i < size; i++) {
int current_value = atoi(test_list[i][1]);
if (current_value < min_value) {
min_value = current_value;
min_index = i;
... | int main() {
char list1[3][2][50] = {{"Rash", "143"}, {"Manjeet", "200"}, {"Varsha", "100"}};
char list2[3][2][50] = {{"Yash", "185"}, {"Dawood", "125"}, {"Sanya", "175"}};
char list3[3][2][50] = {{"Sai", "345"}, {"Salman", "145"}, {"Ayesha", "96"}};
assert(strcmp(func0(list1, 3), "Varsha") ==... | O3 | c | func0:
endbr64
push %r15
mov $0xa,%edx
push %r14
push %r13
mov %rdi,%r13
add $0x32,%rdi
push %r12
push %rbp
mov %esi,%ebp
xor %esi,%esi
push %rbx
sub $0x8,%rsp
callq 1090 <strtol@plt>
cmp $0x1,%ebp
jle 1372 <func0+0x72>
mov %eax,%ebx
lea 0x96(%r13),%r15
mov $0x1,%r14d
xor ... | func0:
endbr64
push r15
mov edx, 0Ah; base
push r14
push r13
mov r13, rdi
add rdi, 32h ; '2'; nptr
push r12
mov r12d, esi
xor esi, esi; endptr
push rbp
push rbx
sub rsp, 8
call _strtol
cmp r12d, 1
jle short loc_1384
mov ebp, eax
lea r14, [r13+96h]
mov ebx... | long long func0(long long a1, int a2)
{
long long v2; // r13
int v3; // eax
int v4; // ebp
const char *v5; // r14
int v6; // ebx
int v7; // r15d
int v8; // eax
v2 = a1;
v3 = strtol((const char *)(a1 + 50), 0LL, 10);
if ( a2 > 1 )
{
v4 = v3;
v5 = (const char *)(a1 + 150);
v6 = 1;
... | func0:
ENDBR64
PUSH R15
MOV EDX,0xa
PUSH R14
PUSH R13
MOV R13,RDI
ADD RDI,0x32
PUSH R12
MOV R12D,ESI
XOR ESI,ESI
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x001010b0
CMP R12D,0x1
JLE 0x00101384
MOV EBP,EAX
LEA R14,[R13 + 0x96]
MOV EBX,0x1
XOR R15D,R15D
NOP
LAB_00101350:
XOR ESI,ESI
MOV RDI,R14
MOV EDX,0xa
CALL 0x001010b0
CMP ... | long func0(long param_1,int param_2)
{
ulong uVar1;
ulong uVar2;
int iVar3;
char *__nptr;
int iVar4;
uVar1 = strtol((char *)(param_1 + 0x32),(char **)0x0,10);
if (1 < param_2) {
uVar1 = uVar1 & 0xffffffff;
__nptr = (char *)(param_1 + 0x96);
iVar3 = 1;
iVar4 = 0;
do {
uVar2 = ... |
4,272 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char lst[][50], int size) {
int minLength = strlen(lst[0]);
for (int i = 1; i < size; i++) {
int length = strlen(lst[i]);
if (length < minLength) {
minLength = length;
}
}
return minLength;
}
| int main() {
char list1[][50] = {"1", "12"};
char list2[][50] = {"12", "123", "1234"};
char list3[][50] = {"333", "4444"};
assert(func0(list1, 2) == 1);
assert(func0(list2, 3) == 2);
assert(func0(list3, 2) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
jmp 11f9 <func0+0x70>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
shl $0x2,%rax... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov [rbp+var_1C], esi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_C], eax
mov [rbp+var_8], 1
jmp short loc_11F9
loc_11B4:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, rdx
shl rax, 2
... | long long func0(const char *a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v3 = strlen(a1);
for ( i = 1; i < a2; ++i )
{
v5 = strlen(&a1[50 * i]);
if ( v5 < (int)v3 )
v3 = v5;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0x1
JMP 0x001011f9
LAB_001011b4:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,RD... | int func0(char *param_1,int param_2)
{
size_t sVar1;
int local_14;
int local_10;
sVar1 = strlen(param_1);
local_14 = (int)sVar1;
for (local_10 = 1; local_10 < param_2; local_10 = local_10 + 1) {
sVar1 = strlen(param_1 + (long)local_10 * 0x32);
if ((int)sVar1 < local_14) {
local_14 = (int)s... |
4,273 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char lst[][50], int size) {
int minLength = strlen(lst[0]);
for (int i = 1; i < size; i++) {
int length = strlen(lst[i]);
if (length < minLength) {
minLength = length;
}
}
return minLength;
}
| int main() {
char list1[][50] = {"1", "12"};
char list2[][50] = {"12", "123", "1234"};
char list3[][50] = {"333", "4444"};
assert(func0(list1, 2) == 1);
assert(func0(list2, 3) == 2);
assert(func0(list3, 2) == 3);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%r9
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r8d
cmp $0x1,%esi
jle 11c9 <func0+0x60>
lea 0x32(%r9),%rdx
lea -0x2(%rsi),%eax
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
lea 0x64(%r9,%rax,2),%r9
mov $0xff... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
mov r13d, esi
call _strlen
mov ebp, eax
cmp r13d, 1
jle short loc_11D6
lea rbx, [r12+32h]
lea eax, [r13-2]
lea rax, [rax+rax*4]
lea rax, [rax+rax*4]
lea r12, [r12+rax*2+64h]
loc_11C0:
mo... | long long func0(long long a1, int a2)
{
unsigned int v2; // ebp
long long v3; // rbx
int v4; // eax
v2 = ((long long (*)(void))strlen)();
if ( a2 > 1 )
{
v3 = a1 + 50;
do
{
v4 = strlen(v3);
if ( (int)v2 > v4 )
v2 = v4;
v3 += 50LL;
}
while ( v3 != a1 + 50LL * (... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV R13D,ESI
CALL 0x00101070
MOV EBP,EAX
CMP R13D,0x1
JLE 0x001011d6
LEA RBX,[R12 + 0x32]
LEA EAX,[R13 + -0x2]
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA R12,[R12 + RAX*0x2 + 0x64]
LAB_001011c0:
MOV RDI,RBX
CALL 0x00101070
CMP EBP,EAX
C... | ulong func0(char *param_1,int param_2)
{
size_t sVar1;
char *__s;
ulong uVar2;
sVar1 = strlen(param_1);
uVar2 = sVar1 & 0xffffffff;
if (1 < param_2) {
__s = param_1 + 0x32;
do {
sVar1 = strlen(__s);
if ((int)sVar1 < (int)uVar2) {
uVar2 = sVar1 & 0xffffffff;
}
__s ... |
4,274 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char lst[][50], int size) {
int minLength = strlen(lst[0]);
for (int i = 1; i < size; i++) {
int length = strlen(lst[i]);
if (length < minLength) {
minLength = length;
}
}
return minLength;
}
| int main() {
char list1[][50] = {"1", "12"};
char list2[][50] = {"12", "123", "1234"};
char list3[][50] = {"333", "4444"};
assert(func0(list1, 2) == 1);
assert(func0(list2, 3) == 2);
assert(func0(list3, 2) == 3);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %esi,%r13d
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %eax,%r12d
cmp $0x1,%r13d
jle 1408 <func0+0x58>
lea -0x2(%r13),%eax
lea 0x32(%rbp),%rbx
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
lea 0x64(%rbp,%rax... | func0:
endbr64
push r13
mov r13d, esi
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
mov r12d, eax
cmp r13d, 1
jle short loc_1408
lea eax, [r13-2]
lea rbx, [rbp+32h]
lea rax, [rax+rax*4]
lea rax, [rax+rax*4]
lea rbp, [rbp+rax*2+64h]
nop wor... | long long func0(long long a1, int a2)
{
unsigned int v2; // r12d
long long v3; // rbx
int v4; // eax
v2 = ((long long (*)(void))strlen)();
if ( a2 > 1 )
{
v3 = a1 + 50;
do
{
v4 = strlen(v3);
if ( (int)v2 > v4 )
v2 = v4;
v3 += 50LL;
}
while ( v3 != a1 + 50LL * ... | func0:
ENDBR64
PUSH R13
MOV R13D,ESI
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
MOV R12D,EAX
CMP R13D,0x1
JLE 0x00101408
LEA EAX,[R13 + -0x2]
LEA RBX,[RBP + 0x32]
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA RBP,[RBP + RAX*0x2 + 0x64]
NOP word ptr [RAX + RAX*0x1]
LAB_001013f0:
MOV RDI,RBX... | ulong func0(char *param_1,int param_2)
{
size_t sVar1;
char *__s;
ulong uVar2;
sVar1 = strlen(param_1);
uVar2 = sVar1 & 0xffffffff;
if (1 < param_2) {
__s = param_1 + 0x32;
do {
sVar1 = strlen(__s);
if ((int)sVar1 < (int)uVar2) {
uVar2 = sVar1 & 0xffffffff;
}
__s ... |
4,275 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char lst[][50], int size) {
int minLength = strlen(lst[0]);
for (int i = 1; i < size; i++) {
int length = strlen(lst[i]);
if (length < minLength) {
minLength = length;
}
}
return minLength;
}
| int main() {
char list1[][50] = {"1", "12"};
char list2[][50] = {"12", "123", "1234"};
char list3[][50] = {"333", "4444"};
assert(func0(list1, 2) == 1);
assert(func0(list2, 3) == 2);
assert(func0(list3, 2) == 3);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
mov %esi,%r13d
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %eax,%r12d
cmp $0x1,%r13d
jle 1408 <func0+0x58>
lea -0x2(%r13),%eax
lea 0x32(%rbp),%rbx
lea (%rax,%rax,4),%rax
lea (%rax,%rax,4),%rax
lea 0x64(%rbp,%rax... | func0:
endbr64
push r13
mov r13d, esi
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 8
call _strlen
mov ebp, eax
cmp r13d, 1
jle short loc_13F6
lea eax, [r13-2]
lea rbx, [r12+32h]
lea rax, [rax+rax*4]
lea rax, [rax+rax*4]
lea r12, [r12+rax*2+64h]
nop word... | long long func0(const char *a1, int a2)
{
unsigned int v2; // ebp
const char *v3; // rbx
int v4; // eax
v2 = strlen(a1);
if ( a2 > 1 )
{
v3 = a1 + 50;
do
{
v4 = strlen(v3);
if ( (int)v2 > v4 )
v2 = v4;
v3 += 50;
}
while ( &a1[50 * (a2 - 2) + 100] != v3 );
}
... | func0:
ENDBR64
PUSH R13
MOV R13D,ESI
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
MOV EBP,EAX
CMP R13D,0x1
JLE 0x001013f6
LEA EAX,[R13 + -0x2]
LEA RBX,[R12 + 0x32]
LEA RAX,[RAX + RAX*0x4]
LEA RAX,[RAX + RAX*0x4]
LEA R12,[R12 + RAX*0x2 + 0x64]
NOP word ptr [RAX + RAX*0x1]
LAB_001013e0:
MOV RDI,RBX
... | ulong func0(char *param_1,int param_2)
{
size_t sVar1;
char *__s;
ulong uVar2;
sVar1 = strlen(param_1);
uVar2 = sVar1 & 0xffffffff;
if (1 < param_2) {
__s = param_1 + 0x32;
do {
sVar1 = strlen(__s);
if ((int)sVar1 < (int)uVar2) {
uVar2 = sVar1 & 0xffffffff;
}
__s ... |
4,276 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
int count = 0;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0(15) == 4);
assert(func0(12) == 6);
assert(func0(9) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 1179 <func0+0x30>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1175 <func0+0x2c>
addl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_1179
loc_1164:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1175
add [rbp+var_8], 1
loc_1175:
add [rbp+var_4], 1
loc_1179... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
{
if ( !(a1 % i) )
++v2;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101179
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101175
ADD dword ptr [RBP + -0x8],0x1
LAB_00101175:
ADD dword pt... | int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 1; local_c <= param_1; local_c = local_c + 1) {
if (param_1 % local_c == 0) {
local_10 = local_10 + 1;
}
}
return local_10;
} |
4,277 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
int count = 0;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0(15) == 4);
assert(func0(12) == 6);
assert(func0(9) == 3);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1175 <func0+0x2c>
lea 0x1(%rdi),%r8d
mov $0x1,%ecx
mov $0x0,%esi
mov %edi,%eax
cltd
idiv %ecx
cmp $0x1,%edx
adc $0x0,%esi
add $0x1,%ecx
cmp %r8d,%ecx
jne 115f <func0+0x16>
mov %esi,%eax
retq
mov $0x0,%esi
jmp 1172 <func0+0x29>
| func0:
endbr64
test edi, edi
jle short loc_1175
lea r8d, [rdi+1]
mov ecx, 1
mov esi, 0
loc_115F:
mov eax, edi
cdq
idiv ecx
cmp edx, 1
adc esi, 0
add ecx, 1
cmp ecx, r8d
jnz short loc_115F
loc_1172:
mov eax, esi
retn
loc_1175:
mov esi, 0
jmp short loc_1172 | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = 1;
v2 = 0;
do
v2 += a1 % v1++ == 0;
while ( v1 != a1 + 1 );
}
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101175
LEA R8D,[RDI + 0x1]
MOV ECX,0x1
MOV ESI,0x0
LAB_0010115f:
MOV EAX,EDI
CDQ
IDIV ECX
CMP EDX,0x1
ADC ESI,0x0
ADD ECX,0x1
CMP ECX,R8D
JNZ 0x0010115f
LAB_00101172:
MOV EAX,ESI
RET
LAB_00101175:
MOV ESI,0x0
JMP 0x00101172 | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(param_1 % iVar1 == 0);
iVar1 = iVar1 + 1;
} while (iVar1 != param_1 + 1);
}
return iVar2;
} |
4,278 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
int count = 0;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0(15) == 4);
assert(func0(12) == 6);
assert(func0(9) == 3);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1270 <func0+0x30>
lea 0x1(%rdi),%esi
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
cmp $0x1,%edx
adc $0x0,%r8d
add $0x1,%ecx
cmp %esi,%ecx
jne 1258 <func0+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
... | func0:
endbr64
test edi, edi
jle short loc_1270
lea esi, [rdi+1]
mov ecx, 1
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_1258:
mov eax, edi
cdq
idiv ecx
cmp edx, 1
adc r8d, 0
add ecx, 1
cmp ecx, esi
jnz short loc_1258
mov eax, r8d
retn
loc_1270:
xor r8d, r8d
mov... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // r8d
if ( a1 <= 0 )
return 0LL;
v1 = 1;
v2 = 0;
do
v2 += a1 % v1++ == 0;
while ( v1 != a1 + 1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101270
LEA ESI,[RDI + 0x1]
MOV ECX,0x1
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_00101258:
MOV EAX,EDI
CDQ
IDIV ECX
CMP EDX,0x1
ADC R8D,0x0
ADD ECX,0x1
CMP ECX,ESI
JNZ 0x00101258
MOV EAX,R8D
RET
LAB_00101270:
XOR R8D,R8D
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
if (0 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(param_1 % iVar1 == 0);
iVar1 = iVar1 + 1;
} while (iVar1 != param_1 + 1);
return iVar2;
}
return 0;
} |
4,279 | func0 |
#include <assert.h>
#include <stdio.h>
| int func0(int n) {
int count = 0;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0(15) == 4);
assert(func0(12) == 6);
assert(func0(9) == 3);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
lea 0x1(%rdi),%esi
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
cmp $0x1,%edx
adc $0x0,%r8d
add $0x1,%ecx
cmp %ecx,%esi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
... | func0:
endbr64
test edi, edi
jle short loc_1170
lea r8d, [rdi+1]
mov ecx, 1
xor esi, esi
nop dword ptr [rax+rax+00h]
loc_1158:
mov eax, edi
cdq
idiv ecx
cmp edx, 1
adc esi, 0
add ecx, 1
cmp r8d, ecx
jnz short loc_1158
mov eax, esi
retn
loc_1170:
xor esi, esi
mov... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 0 )
return 0LL;
v1 = 1;
v2 = 0;
do
v2 += a1 % v1++ == 0;
while ( a1 + 1 != v1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
LEA R8D,[RDI + 0x1]
MOV ECX,0x1
XOR ESI,ESI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EAX,EDI
CDQ
IDIV ECX
CMP EDX,0x1
ADC ESI,0x0
ADD ECX,0x1
CMP R8D,ECX
JNZ 0x00101158
MOV EAX,ESI
RET
LAB_00101170:
XOR ESI,ESI
MOV EAX,ESI
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
if (0 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(param_1 % iVar1 == 0);
iVar1 = iVar1 + 1;
} while (param_1 + 1 != iVar1);
return iVar2;
}
return 0;
} |
4,280 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
typedef struct {
Pair *pairs;
int size;
int capacity;
} Dictionary;
void init_dictionary(Dictionary *dict) {
dict->capacity = 10;
dict->size = 0;
dict->pairs = (... | Dictionary func0(int list1[][4], int numLists) {
Dictionary dict;
init_dictionary(&dict);
for (int i = 0; i < numLists; i++) {
for (int j = 0; j < 4; j++) {
dictionary_add(&dict, list1[i][j]);
}
}
return dict;
}
| int main() {
int list1[3][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 8, 9, 5}};
Dictionary result1 = func0(list1, 3);
assert(result1.size == 9);
assert(result1.pairs[1].value == 3);
assert(result1.pairs[4].value == 2);
int list2[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
Dict... | 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 11c9 <init_dictionary>
movl $0x0,-0x28(%rbp)
jmp 13c1 <func0+0x77>
movl $0x0,-0x24(%rbp)
jmp ... | 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 init_dictionary
mov [rbp+var_28], 0
jmp short loc_13C1
loc_1381:
mov [rbp+var_24],... | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-28h]
int j; // [rsp+1Ch] [rbp-24h]
_QWORD v5[4]; // [rsp+20h] [rbp-20h] BYREF
v5[3] = __readfsqword(0x28u);
init_dictionary(v5);
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j <= 3; ++j )
dictionary_add(v5, *(unsigned int *)(a1 + 16... | 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 0x001011c9
MOV dword ptr [RBP + -0x28],0x0
JMP 0x001013c1
LAB_00101381:
MOV dword ptr [RBP + -0x2... | int8 func0(long param_1,int param_2)
{
long in_FS_OFFSET;
int local_30;
int local_2c;
int8 local_28 [3];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
init_dictionary(local_28);
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
for (local_2c = 0; local_2c < 4; local_2... |
4,281 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} Pair;
typedef struct {
Pair *pairs;
int size;
int capacity;
} Dictionary;
void init_dictionary(Dictionary *dict) {
dict->capacity = 10;
dict->size = 0;
dict->pairs = (... | Dictionary func0(int list1[][4], int numLists) {
Dictionary dict;
init_dictionary(&dict);
for (int i = 0; i < numLists; i++) {
for (int j = 0; j < 4; j++) {
dictionary_add(&dict, list1[i][j]);
}
}
return dict;
}
| int main() {
int list1[3][4] = {{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 8, 9, 5}};
Dictionary result1 = func0(list1, 3);
assert(result1.size == 9);
assert(result1.pairs[1].value == 3);
assert(result1.pairs[4].value == 2);
int list2[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
Dict... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r12
mov %esi,%ebx
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %rsp,%rdi
callq 11c9 <init_dictionary>
test %ebx,%ebx
jle 12e9 <func0+0x67>
lea 0x10(%r12),%rbp
lea -0x1(%rbx),%eax
shl $0... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r12, rdi
mov ebx, esi
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov rdi, rsp
call init_dictionary
test ebx, ebx
jle short loc_12E9
lea rbp, [r12+10h]
lea eax, [rbx-1]
shl rax, 4... | long long func0(long long a1, int a2)
{
unsigned int *v2; // rbp
unsigned int *v3; // rbx
_QWORD v5[9]; // [rsp+0h] [rbp-48h] BYREF
v5[3] = __readfsqword(0x28u);
init_dictionary(v5);
if ( a2 > 0 )
{
v2 = (unsigned int *)(a1 + 16);
do
{
v3 = v2 - 4;
do
dictionary_add(v5, *... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R12,RDI
MOV EBX,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV RDI,RSP
CALL 0x001011c9
TEST EBX,EBX
JLE 0x001012e9
LEA RBP,[R12 + 0x10]
LEA EAX,[RBX + -0x1]
SHL RAX,0x4
LEA R13,[R12 + RAX*0x1 + 0x20]
MOV R12,RSP
JMP 0x00... | int8 func0(long param_1,int param_2)
{
int4 *puVar1;
int4 *puVar2;
long in_FS_OFFSET;
int8 local_48 [3];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
init_dictionary(local_48);
if (0 < param_2) {
puVar2 = (int4 *)(param_1 + 0x10);
do {
puVar1 = puVar2 + -4;
do {
... |
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.