index int64 0 66.5k | func_name stringlengths 2 5.36k | func_dep stringlengths 16 2.19k | func stringlengths 8 55.3k | test stringlengths 0 7.07k | opt stringclasses 4
values | language stringclasses 2
values | asm stringlengths 0 45.4k | ida_asm stringlengths 0 44.7k | ida_pseudo stringlengths 0 44.3k | ghidra_asm stringlengths 0 49.1k | ghidra_pseudo stringlengths 0 64.7k |
|---|---|---|---|---|---|---|---|---|---|---|---|
7,782 | func0 | #include <stdio.h>
#include <assert.h>
typedef struct {
int a;
int b;
int c;
int d;
} Tuple;
| Tuple func0(Tuple test_tup1, Tuple test_tup2) {
Tuple res;
res.a = test_tup1.a;
res.b = test_tup1.b;
res = (Tuple){res.a, res.b, test_tup2.a, test_tup2.b};
return res;
}
| int main() {
Tuple t1 = {3, 4};
Tuple t2 = {5, 6};
Tuple result = func0(t1, t2);
assert(result.a == 3 && result.b == 4 && result.c == 5 && result.d == 6);
Tuple t3 = {1, 2};
Tuple t4 = {3, 4};
result = func0(t3, t4);
assert(result.a == 1 && result.b == 2 && result.c == 3 &&... | O2 | c | func0:
endbr64
mov %rdi,%rax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov rax, rdi
retn | long long func0(long long a1)
{
return a1;
} | func0:
ENDBR64
MOV RAX,RDI
RET | int8 func0(int8 param_1)
{
return param_1;
} |
7,783 | func0 | #include <stdio.h>
#include <assert.h>
typedef struct {
int a;
int b;
int c;
int d;
} Tuple;
| Tuple func0(Tuple test_tup1, Tuple test_tup2) {
Tuple res;
res.a = test_tup1.a;
res.b = test_tup1.b;
res = (Tuple){res.a, res.b, test_tup2.a, test_tup2.b};
return res;
}
| int main() {
Tuple t1 = {3, 4};
Tuple t2 = {5, 6};
Tuple result = func0(t1, t2);
assert(result.a == 3 && result.b == 4 && result.c == 5 && result.d == 6);
Tuple t3 = {1, 2};
Tuple t4 = {3, 4};
result = func0(t3, t4);
assert(result.a == 1 && result.b == 2 && result.c == 3 &&... | O3 | c | func0:
endbr64
mov %rdi,%rax
retq
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
mov rax, rdi
retn | long long func0(long long a1)
{
return a1;
} | func0:
ENDBR64
MOV RAX,RDI
RET | int8 func0(int8 param_1)
{
return param_1;
} |
7,784 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(char* s, int d) {
int len = strlen(s);
char* tmp = (char*)malloc(len + 1);
for (int i = 0; i < len; i++) {
tmp[i] = s[(i + d) % len];
}
tmp[len] = '\0';
return tmp;
}
| int main() {
assert(strcmp(func0("python", 2), "thonpy") == 0);
assert(strcmp(func0("bigdata", 3), "databig") == 0);
assert(strcmp(func0("hadoop", 1), "adooph") == 0);
printf("All test cases passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 10a0 <strlen@plt>
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0... | 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 eax, [rbp+var_C]
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_10],... | _BYTE * func0(const char *a1, int a2)
{
int i; // [rsp+10h] [rbp-10h]
int v4; // [rsp+14h] [rbp-Ch]
_BYTE *v5; // [rsp+18h] [rbp-8h]
v4 = strlen(a1);
v5 = malloc(v4 + 1);
for ( i = 0; i < v4; ++i )
v5[i] = a1[(i + a2) % v4];
v5[v4] = 0;
return v5;
} | 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 0x001010a0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV dword... | void * func0(char *param_1,int param_2)
{
int iVar1;
size_t sVar2;
void *pvVar3;
int local_18;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
pvVar3 = malloc((long)(iVar1 + 1));
for (local_18 = 0; local_18 < iVar1; local_18 = local_18 + 1) {
*(char *)((long)pvVar3 + (long)local_18) = param_1[(para... |
7,785 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(char* s, int d) {
int len = strlen(s);
char* tmp = (char*)malloc(len + 1);
for (int i = 0; i < len; i++) {
tmp[i] = s[(i + d) % len];
}
tmp[len] = '\0';
return tmp;
}
| int main() {
assert(strcmp(func0("python", 2), "thonpy") == 0);
assert(strcmp(func0("bigdata", 3), "databig") == 0);
assert(strcmp(func0("hadoop", 1), "adooph") == 0);
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r12
mov %esi,%r13d
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
lea 0x1(%rbp),%edi
movslq %edi,%rdi
callq 1090 <malloc@plt>
mov %rax,%r8
test %ebp,%eb... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r13d, esi
call _strlen
mov r12, rax
mov ebx, eax
lea edi, [rax+1]
movsxd rdi, edi
call _malloc
mov r8, rax
test r12d, r12d
jle short loc_1226
lea eax, [r12-1]
lea rdi, [r8+rax+1]
... | long long func0(long long a1, int a2)
{
int v2; // r12d
long long v3; // r8
_BYTE *v4; // rcx
v2 = strlen();
v3 = malloc(v2 + 1);
if ( v2 > 0 )
{
v4 = (_BYTE *)v3;
do
{
*v4 = *(_BYTE *)(a1 + (a2 - (int)v3 + (int)v4) % v2);
++v4;
}
while ( v4 != (_BYTE *)(v3 + (unsigned in... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R13D,ESI
CALL 0x001010a0
MOV R12,RAX
MOV EBX,EAX
LEA EDI,[RAX + 0x1]
MOVSXD RDI,EDI
CALL 0x001010d0
MOV R8,RAX
TEST R12D,R12D
JLE 0x00101226
LEA EAX,[R12 + -0x1]
LEA RDI,[R8 + RAX*0x1 + 0x1]
MOV RCX,R8
MOV ESI,R13D
SUB ESI,R8D
LAB_0010120d:
... | char * func0(char *param_1,int param_2)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
pcVar3 = (char *)malloc((long)(iVar1 + 1));
if (0 < iVar1) {
pcVar4 = pcVar3;
do {
*pcVar4 = param_1[((param_2 - (int)pcVar3) + (int)pcVar4) % iVa... |
7,786 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(char* s, int d) {
int len = strlen(s);
char* tmp = (char*)malloc(len + 1);
for (int i = 0; i < len; i++) {
tmp[i] = s[(i + d) % len];
}
tmp[len] = '\0';
return tmp;
}
| int main() {
assert(strcmp(func0("python", 2), "thonpy") == 0);
assert(strcmp(func0("bigdata", 3), "databig") == 0);
assert(strcmp(func0("hadoop", 1), "adooph") == 0);
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %esi,%ebp
push %rbx
sub $0x8,%rsp
callq 1090 <strlen@plt>
lea 0x1(%rax),%edi
mov %rax,%r13
mov %eax,%ebx
movslq %edi,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r8
test %r13d,%r13d
jle 1312 <func0+0x62>
lea -0x1(%r13),%eax
... | func0:
endbr64
push r13
push r12
mov r12, rdi
push rbp
mov ebp, esi
push rbx
sub rsp, 8
call _strlen
lea edi, [rax+1]
mov r13, rax
mov ebx, eax
movsxd rdi, edi
call _malloc
mov r8, rax
test r13d, r13d
jle short loc_1322
lea eax, [r13-1]
mov esi, ebp
mov ... | long long func0(long long a1, int a2)
{
int v2; // r13d
long long v3; // r8
long long v4; // rcx
int v5; // eax
long long result; // rax
v2 = strlen();
v3 = malloc(v2 + 1);
if ( v2 > 0 )
{
v4 = v3;
do
{
v5 = a2 - v3 + v4++;
*(_BYTE *)(v4 - 1) = *(_BYTE *)(a1 + v5 % v2);
}... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOV EBP,ESI
PUSH RBX
SUB RSP,0x8
CALL 0x001010a0
LEA EDI,[RAX + 0x1]
MOV R13,RAX
MOV EBX,EAX
MOVSXD RDI,EDI
CALL 0x001010d0
MOV R8,RAX
TEST R13D,R13D
JLE 0x00101322
LEA EAX,[R13 + -0x1]
MOV ESI,EBP
MOV RCX,R8
LEA RDI,[R8 + RAX*0x1 + 0x1]
SUB ESI,R8D
NOP dword ptr [R... | char * func0(char *param_1,int param_2)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
char *pcVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
pcVar3 = (char *)malloc((long)(iVar1 + 1));
if (0 < iVar1) {
pcVar4 = pcVar3;
do {
pcVar5 = pcVar4 + 1;
*pcVar4 = param_1[((... |
7,787 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(char* s, int d) {
int len = strlen(s);
char* tmp = (char*)malloc(len + 1);
for (int i = 0; i < len; i++) {
tmp[i] = s[(i + d) % len];
}
tmp[len] = '\0';
return tmp;
}
| int main() {
assert(strcmp(func0("python", 2), "thonpy") == 0);
assert(strcmp(func0("bigdata", 3), "databig") == 0);
assert(strcmp(func0("hadoop", 1), "adooph") == 0);
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %esi,%ebp
push %rbx
sub $0x8,%rsp
callq 1090 <strlen@plt>
lea 0x1(%rax),%edi
mov %rax,%r13
mov %eax,%ebx
movslq %edi,%rdi
callq 10b0 <malloc@plt>
mov %rax,%r8
test %r13d,%r13d
jle 1312 <func0+0x62>
lea -0x1(%r13),%eax
... | func0:
endbr64
push r13
push r12
mov r12, rdi
push rbp
mov ebp, esi
push rbx
sub rsp, 8
call _strlen
lea edi, [rax+1]
mov r13, rax
mov ebx, eax
movsxd rdi, edi; size
call _malloc
mov r8, rax
test r13d, r13d
jle short loc_1322
lea eax, [r13-1]
mov esi, ebp
mo... | char * func0(const char *a1, int a2)
{
int v2; // r13d
char *v3; // r8
char *v4; // rcx
int v5; // eax
char *result; // rax
v2 = strlen(a1);
v3 = (char *)malloc(v2 + 1);
if ( v2 > 0 )
{
v4 = v3;
do
{
v5 = a2 - (_DWORD)v3 + (_DWORD)v4++;
*(v4 - 1) = a1[v5 % v2];
}
while... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOV EBP,ESI
PUSH RBX
SUB RSP,0x8
CALL 0x001010a0
LEA EDI,[RAX + 0x1]
MOV R13,RAX
MOV EBX,EAX
MOVSXD RDI,EDI
CALL 0x001010d0
MOV R8,RAX
TEST R13D,R13D
JLE 0x00101322
LEA EAX,[R13 + -0x1]
MOV ESI,EBP
MOV RCX,R8
LEA RDI,[R8 + RAX*0x1 + 0x1]
SUB ESI,R8D
NOP dword ptr [R... | char * func0(char *param_1,int param_2)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char *pcVar4;
char *pcVar5;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
pcVar3 = (char *)malloc((long)(iVar1 + 1));
if (0 < iVar1) {
pcVar4 = pcVar3;
do {
pcVar5 = pcVar4 + 1;
*pcVar4 = param_1[((... |
7,788 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int func0(int** A, int rows) {
int* memo = (int*)malloc(rows * sizeof(int));
int n = rows - 1;
for (int i = 0; i < rows; i++) {
memo[i] = A[n][i];
}
for (int i = rows - 2; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
int minValue = memo[j] < memo[j + 1] ? memo[j]... | int main() {
int a1[3][3] = {{2}, {3, 9}, {1, 6, 7}};
int a2[3][3] = {{2}, {3, 7}, {8, 5, 6}};
int a3[3][3] = {{3}, {6, 4}, {5, 2, 7}};
int* pa1[3] = {a1[0], a1[1], a1[2]};
int* pa2[3] = {a2[0], a2[1], a2[2]};
int* pa3[3] = {a3[0], a3[1], a3[2]};
assert(func0(pa1, 3) == 6);
a... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov -0x2c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x14(%rbp)
movl $0x0,-0x20(%rbp)
jmp 124... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov eax, [rbp+var_2C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov eax, [rbp+var_2C]
sub eax, 1
mov [rbp+var_14], eax
mov [rbp+var_20], 0
jmp ... | long long func0(long long a1, int a2)
{
int v2; // eax
int i; // [rsp+10h] [rbp-20h]
int j; // [rsp+14h] [rbp-1Ch]
int k; // [rsp+18h] [rbp-18h]
unsigned int v7; // [rsp+20h] [rbp-10h]
unsigned int *ptr; // [rsp+28h] [rbp-8h]
ptr = (unsigned int *)malloc(4LL * a2);
for ( i = 0; i < a2; ++i )
ptr[i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x8],RAX
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0... | int4 func0(long param_1,int param_2)
{
int4 uVar1;
int iVar2;
int4 *__ptr;
int local_28;
int local_24;
int local_20;
__ptr = (int4 *)malloc((long)param_2 << 2);
for (local_28 = 0; local_28 < param_2; local_28 = local_28 + 1) {
__ptr[local_28] =
*(int4 *)(*(long *)(param_1 + (long)(param... |
7,789 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int func0(int** A, int rows) {
int* memo = (int*)malloc(rows * sizeof(int));
int n = rows - 1;
for (int i = 0; i < rows; i++) {
memo[i] = A[n][i];
}
for (int i = rows - 2; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
int minValue = memo[j] < memo[j + 1] ? memo[j]... | int main() {
int a1[3][3] = {{2}, {3, 9}, {1, 6, 7}};
int a2[3][3] = {{2}, {3, 7}, {8, 5, 6}};
int a3[3][3] = {{3}, {6, 4}, {5, 2, 7}};
int* pa1[3] = {a1[0], a1[1], a1[2]};
int* pa2[3] = {a2[0], a2[1], a2[2]};
int* pa3[3] = {a3[0], a3[1], a3[2]};
assert(func0(pa1, 3) == 6);
a... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rdi
test %ebp,%ebp
jle 120e <func0+0x45>
lea -0x1(%rbp),%eax
cltq
mov (%rbx,%rax,8),%rsi
lea -0x1(%rbp),%ecx
mov $0x0,%eax
mov (%rsi,%rax,... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov ebp, esi
movsxd rdi, esi
shl rdi, 2
call _malloc
mov rdi, rax
test ebp, ebp
jle short loc_120A
lea eax, [rbp-1]
cdqe
mov rsi, [rbx+rax*8]
mov ecx, ebp
mov eax, 0
loc_11FB:
mov edx, [rsi+rax*4]
mov [... | long long func0(long long a1, int a2)
{
unsigned int *v4; // rdi
long long v5; // rsi
long long v6; // rax
int v7; // ebp
long long v8; // r9
long long v9; // r8
unsigned long long v10; // rax
int v11; // edx
unsigned int v12; // ebx
v4 = (unsigned int *)malloc(4LL * a2);
if ( a2 > 0 )
{
v... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV EBP,ESI
MOVSXD RDI,ESI
SHL RDI,0x2
CALL 0x001010d0
MOV RDI,RAX
TEST EBP,EBP
JLE 0x0010120a
LEA EAX,[RBP + -0x1]
CDQE
MOV RSI,qword ptr [RBX + RAX*0x8]
MOV ECX,EBP
MOV EAX,0x0
LAB_001011fb:
MOV EDX,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],EDX
AD... | int4 func0(long param_1,uint param_2)
{
int4 uVar1;
long lVar2;
int4 *__ptr;
ulong uVar3;
long lVar4;
int iVar5;
__ptr = (int4 *)malloc((long)(int)param_2 << 2);
if (0 < (int)param_2) {
lVar2 = *(long *)(param_1 + (long)(int)(param_2 - 1) * 8);
uVar3 = 0;
do {
__ptr[uVar3] = *(int4... |
7,790 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int func0(int** A, int rows) {
int* memo = (int*)malloc(rows * sizeof(int));
int n = rows - 1;
for (int i = 0; i < rows; i++) {
memo[i] = A[n][i];
}
for (int i = rows - 2; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
int minValue = memo[j] < memo[j + 1] ? memo[j]... | int main() {
int a1[3][3] = {{2}, {3, 9}, {1, 6, 7}};
int a2[3][3] = {{2}, {3, 7}, {8, 5, 6}};
int a3[3][3] = {{3}, {6, 4}, {5, 2, 7}};
int* pa1[3] = {a1[0], a1[1], a1[2]};
int* pa2[3] = {a2[0], a2[1], a2[2]};
int* pa3[3] = {a3[0], a3[1], a3[2]};
assert(func0(pa1, 3) == 6);
a... | O2 | c | func0:
endbr64
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rdi
test %ebx,%ebx
jle 1452 <func0+0x42>
lea -0x1(%rbx),%ecx
movslq %ecx,%rax
mov %ecx,%ecx
mov 0x0(%rbp,%rax,8),%rsi
xor %eax,%eax
mov (%rsi,%... | func0:
endbr64
push r12
movsxd r12, esi
push rbp
mov rbp, rdi
push rbx
mov rbx, r12
shl r12, 2
mov rdi, r12
call _malloc
mov rdi, rax
test ebx, ebx
jle short loc_1449
lea eax, [rbx-1]
mov rdx, r12
cdqe
mov rsi, [rbp+rax*8+0]
call _memcpy
mov rdi, rax
loc_1449:
... | long long func0(long long a1, int a2)
{
unsigned int *v3; // rdi
long long v4; // rsi
long long v5; // r8
long long v6; // rax
int v7; // edx
unsigned int v8; // r12d
v3 = (unsigned int *)malloc(4LL * a2);
if ( a2 > 0 )
v3 = (unsigned int *)memcpy(v3, *(_QWORD *)(a1 + 8LL * (a2 - 1)), 4LL * a2);
... | func0:
ENDBR64
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,R12
SHL R12,0x2
MOV RDI,R12
CALL 0x001010f0
MOV RDI,RAX
TEST EBX,EBX
JLE 0x00101449
LEA EAX,[RBX + -0x1]
MOV RDX,R12
CDQE
MOV RSI,qword ptr [RBP + RAX*0x8]
CALL 0x001010e0
MOV RDI,RAX
LAB_00101449:
SUB EBX,0x2
JS 0x00101483
MOVSXD RSI,EBX
NOP ... | int4 func0(long param_1,int param_2)
{
int4 uVar1;
long lVar2;
int4 *__dest;
long lVar3;
int iVar4;
long lVar5;
__dest = (int4 *)malloc((long)param_2 << 2);
if (0 < param_2) {
__dest = (int4 *)
memcpy(__dest,*(void **)(param_1 + (long)(param_2 + -1) * 8),(long)param_2 << 2);
}
i... |
7,791 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int func0(int** A, int rows) {
int* memo = (int*)malloc(rows * sizeof(int));
int n = rows - 1;
for (int i = 0; i < rows; i++) {
memo[i] = A[n][i];
}
for (int i = rows - 2; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
int minValue = memo[j] < memo[j + 1] ? memo[j]... | int main() {
int a1[3][3] = {{2}, {3, 9}, {1, 6, 7}};
int a2[3][3] = {{2}, {3, 7}, {8, 5, 6}};
int a3[3][3] = {{3}, {6, 4}, {5, 2, 7}};
int* pa1[3] = {a1[0], a1[1], a1[2]};
int* pa2[3] = {a2[0], a2[1], a2[2]};
int* pa3[3] = {a3[0], a3[1], a3[2]};
assert(func0(pa1, 3) == 6);
a... | O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x2,%rdi
callq 10f0 <malloc@plt>
mov %rax,%rdi
test %ebp,%ebp
jle 147c <func0+0x3c>
lea -0x1(%rbp),%eax
mov %eax,%edx
cltq
mov (%rbx,%rax,8),%rsi
lea 0x4(,%rdx,4),%rdx
callq 10e0 <memcpy@p... | func0:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
mov r12, rdi
shl rdi, 2; size
call _malloc
mov rdi, rax; dest
test r12d, r12d
jle loc_15D9
lea ebx, [r12-1]
mov edx, r12d
movsxd rax, ebx
shl rdx, 2; n
mov rsi, [rbp+rax*8+... | long long func0(long long a1, int a2)
{
_DWORD *v4; // rdi
unsigned int v5; // ebx
_DWORD *v6; // rax
long long v7; // rsi
long long v8; // rcx
long long v9; // rax
__m128i v10; // xmm2
__m128i v11; // xmm0
signed int v12; // eax
int v13; // edx
long long v14; // r8
unsigned int *v15; // r11
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
MOV R12,RDI
SHL RDI,0x2
CALL 0x001010f0
MOV RDI,RAX
TEST R12D,R12D
JLE 0x001015d9
LEA EBX,[R12 + -0x1]
MOV EDX,R12D
MOVSXD RAX,EBX
SHL RDX,0x2
MOV RSI,qword ptr [RBP + RAX*0x8]
CALL 0x001010e0
LEA ESI,[R12 + -0x2]
MOV RDI,RAX
CMP R12... | int4 func0(long param_1,uint param_2)
{
int *piVar1;
uint *puVar2;
int *piVar3;
uint *puVar4;
int8 uVar5;
int iVar6;
int4 uVar7;
long lVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
int4 *__dest;
long lVar15;
int iVar16;
int iVar17;
uint uVar18;... |
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.