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,582 | func0 | #include <assert.h>
// Function to find max product pairs in an array
| void func0(int arr[], int arr_len, int *x, int *y) {
if (arr_len < 2) {
*x = 0;
*y = 0;
return;
}
*x = arr[0];
*y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > (*x) * (*y))... | int main() {
int x, y;
// Test Case 1
int arr1[] = {1, 2, 3, 4, 7, 0, 8, 4};
func0(arr1, 8, &x, &y);
assert(x == 7 && y == 8);
// Test Case 2
int arr2[] = {0, -1, -2, -4, 5, 0, -6};
func0(arr2, 7, &x, &y);
assert(x == -4 && y == -6);
// Test Case 3
int arr3[]... | O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 13d0 <func0+0x20>
mov (%rdi),%eax
mov %eax,(%rdx)
mov 0x4(%rdi),%eax
mov %eax,(%rcx)
jmpq 1340 <func0.part.0>
nopw 0x0(%rax,%rax,1)
movl $0x0,(%rdx)
movl $0x0,(%rcx)
retq
nopl (%rax)
| func0_part_0:
test esi, esi
jle short locret_13CF
push r12
mov r11d, 1
mov r8, rdx
mov r9, rcx
push rbp
lea r10, [rdi+4]
lea r12d, [rsi-1]
push rbx
mov ebx, esi
lea rbp, [rdi+8]
cmp r11, rbx
jz short loc_13CA
nop word ptr [rax+rax+00000000h]
loc_1380:
mov eax... | void func0_part_0(long long a1, int a2, _DWORD *a3, _DWORD *a4)
{
long long v4; // r11
_DWORD *i; // r10
_DWORD *v7; // rax
int v8; // ecx
if ( a2 > 0 )
{
v4 = 1LL;
for ( i = (_DWORD *)(a1 + 4); v4 != a2; ++i )
{
v7 = i;
do
{
v8 = *(i - 1);
if ( v8 * *v7 > *a4... | func0.part.0:
TEST ESI,ESI
JLE 0x001013cf
PUSH R12
MOV R11D,0x1
MOV R8,RDX
MOV R9,RCX
PUSH RBP
LEA R10,[RDI + 0x4]
LEA R12D,[RSI + -0x1]
PUSH RBX
MOV EBX,ESI
LEA RBP,[RDI + 0x8]
CMP R11,RBX
JZ 0x001013ca
NOP word ptr [RAX + RAX*0x1]
LAB_00101380:
MOV EAX,R12D
SUB EAX,R11D
LEA RAX,[R11 + RAX*0x1 + -0x1]
LEA RDI,[RBP + R... | void func0_part_0(long param_1,uint param_2,int *param_3,int *param_4)
{
int *piVar1;
int *piVar2;
ulong uVar3;
if ((int)param_2 < 1) {
return;
}
uVar3 = 1;
piVar2 = (int *)(param_1 + 4);
if ((ulong)param_2 != 1) {
do {
piVar1 = piVar2;
do {
if (*param_3 * *param_4 < *piV... |
7,583 | func0 | #include <assert.h>
// Function to find max product pairs in an array
| void func0(int arr[], int arr_len, int *x, int *y) {
if (arr_len < 2) {
*x = 0;
*y = 0;
return;
}
*x = arr[0];
*y = arr[1];
for (int i = 0; i < arr_len; i++) {
for (int j = i + 1; j < arr_len; j++) {
if (arr[i] * arr[j] > (*x) * (*y))... | int main() {
int x, y;
// Test Case 1
int arr1[] = {1, 2, 3, 4, 7, 0, 8, 4};
func0(arr1, 8, &x, &y);
assert(x == 7 && y == 8);
// Test Case 2
int arr2[] = {0, -1, -2, -4, 5, 0, -6};
func0(arr2, 7, &x, &y);
assert(x == -4 && y == -6);
// Test Case 3
int arr3[]... | O3 | c | func0:
endbr64
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
mov %esi,%ebx
mov %rdx,%rsi
cmp $0x1,%ebx
jle 13f0 <func0+0x70>
mov (%rdi),%eax
mov $0x1,%r12d
mov %eax,(%rdx)
mov 0x4(%rdi),%r10d
mov $0x1,%eax
mov %r10d,(%rcx)
xor %ecx,%ecx
nopl (%rax)
movslq %eax,%r8
mov (%rdi,... | func0_part_0:
test esi, esi
jle short locret_1361
push r12
mov r10, rdi
mov r11, rdi
mov r12d, esi
push rbp
mov ebp, 1
push rbx
mov ebx, esi
cmp esi, 1
jz short loc_135C
nop dword ptr [rax]
loc_1320:
mov edi, [rcx]
mov rax, rbp
nop dword ptr [rax]
loc_1328:
m... | void func0_part_0(_DWORD *a1, int a2, _DWORD *a3, int *a4)
{
_DWORD *v5; // r11
long long v6; // rbp
int v7; // edi
long long v8; // rax
if ( a2 > 0 )
{
v5 = a1;
v6 = 1LL;
if ( a2 != 1 )
{
do
{
v7 = *a4;
v8 = v6;
do
{
if ( *v5 * a1[v8] ... | func0.part.0:
TEST ESI,ESI
JLE 0x00101361
PUSH R12
MOV R10,RDI
MOV R11,RDI
MOV R12D,ESI
PUSH RBP
MOV EBP,0x1
PUSH RBX
MOV EBX,ESI
CMP ESI,0x1
JZ 0x0010135c
NOP dword ptr [RAX]
LAB_00101320:
MOV EDI,dword ptr [RCX]
MOV RAX,RBP
NOP dword ptr [RAX]
LAB_00101328:
MOV ESI,dword ptr [R11]
MOV R9D,dword ptr [R10 + RAX*0x4]
MO... | void func0_part_0(int *param_1,uint param_2,int *param_3,int *param_4)
{
ulong uVar1;
ulong uVar2;
int iVar3;
int *piVar4;
if (0 < (int)param_2) {
uVar2 = 1;
piVar4 = param_1;
if (param_2 != 1) {
do {
iVar3 = *param_4;
uVar1 = uVar2;
do {
if (*param_3 * ... |
7,584 | func0 |
#include <string.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (!m)
return n;
if (!n)
return m;
if (X[m - 1] == Y[n - 1])
return 1 + func0(X, Y, m - 1, n - 1);
int left = func0(X, Y, m - 1, n);
int right = func0(X, Y, m, n - 1);
return 1 + (left < right ? left : righ... | int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 9);
assert(func0("feek", "eke", 4, 3) == 5);
assert(func0("PARRT", "RTA", 5, 3) == 6);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %ecx,-0x28(%rbp)
cmpl $0x0,-0x24(%rbp)
jne 1171 <func0+0x28>
mov -0x28(%rbp),%eax
jmpq 1213 <func0+0xca>
cmpl $0x0,-0x28(%rbp)
jne 117f <func0+0x36>
mov -0x24(%r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_28], ecx
cmp [rbp+var_24], 0
jnz short loc_1171
mov eax, [rbp+var_28]
jmp locret_1214
loc_1171:
cmp [rbp+var_28], 0
jnz short loc_117F
mov ... | long long func0(long long a1, long long a2, unsigned int a3, unsigned int a4)
{
int v5; // edx
int v6; // eax
int v9; // [rsp+28h] [rbp-8h]
if ( !a3 )
return a4;
if ( !a4 )
return a3;
if ( *(_BYTE *)((int)a3 - 1LL + a1) == *(_BYTE *)((int)a4 - 1LL + a2) )
return (unsigned int)func0(a1, a2, a3 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0x28],ECX
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x00101171
MOV EAX,dword ptr [RBP + -0x28]
JMP 0x00101214
LAB_00101171:
CMP dword ptr [RBP + -0x28],0x0
JNZ... | int func0(long param_1,long param_2,int param_3,int param_4)
{
int iVar1;
int iVar2;
iVar1 = param_4;
if ((param_3 != 0) && (iVar1 = param_3, param_4 != 0)) {
if (*(char *)(param_1 + (long)param_3 + -1) == *(char *)(param_2 + (long)param_4 + -1)) {
iVar1 = func0(param_1,param_2,param_3 + -1,param_... |
7,585 | func0 |
#include <string.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (!m)
return n;
if (!n)
return m;
if (X[m - 1] == Y[n - 1])
return 1 + func0(X, Y, m - 1, n - 1);
int left = func0(X, Y, m - 1, n);
int right = func0(X, Y, m, n - 1);
return 1 + (left < right ? left : righ... | int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 9);
assert(func0("feek", "eke", 4, 3) == 5);
assert(func0("PARRT", "RTA", 5, 3) == 6);
return 0;
}
| O1 | c | func0:
endbr64
mov %ecx,%eax
test %edx,%edx
je 11c1 <func0+0x78>
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r13
mov %rsi,%r14
mov %edx,%ebp
mov %ecx,%ebx
mov %edx,%eax
test %ecx,%ecx
je 11a5 <func0+0x5c>
movslq %edx,%rax
movslq %ecx,%rdx
movzbl -0x1(%rsi,%rdx,1),... | func0:
endbr64
mov eax, ecx
test edx, edx
jz short locret_11C1
push r14
push r13
push r12
push rbp
push rbx
mov r13, rdi
mov r14, rsi
mov ebp, edx
mov ebx, ecx
mov eax, edx
test ecx, ecx
jz short loc_11A5
movsxd rax, edx
movsxd rdx, ecx
movzx esi, byte ptr [rsi... | long long func0(long long a1, long long a2, unsigned int a3, long long a4)
{
long long result; // rax
int v6; // ebx
int v7; // r12d
int v8; // eax
result = (unsigned int)a4;
if ( a3 )
{
v6 = a4;
result = a3;
if ( (_DWORD)a4 )
{
if ( *(_BYTE *)(a1 + (int)a3 - 1) == *(_BYTE *)(a2 + ... | func0:
ENDBR64
MOV EAX,ECX
TEST EDX,EDX
JZ 0x001011c1
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13,RDI
MOV R14,RSI
MOV EBP,EDX
MOV EBX,ECX
MOV EAX,EDX
TEST ECX,ECX
JZ 0x001011a5
MOVSXD RAX,EDX
MOVSXD RDX,ECX
MOVZX ESI,byte ptr [RSI + RDX*0x1 + -0x1]
CMP byte ptr [RDI + RAX*0x1 + -0x1],SIL
JZ 0x001011ae
LEA EDX,... | int func0(long param_1,long param_2,int param_3,int param_4)
{
int iVar1;
if (param_3 != 0) {
if (param_4 != 0) {
if (*(char *)(param_1 + -1 + (long)param_3) == *(char *)(param_2 + -1 + (long)param_4)) {
param_3 = func0(param_1,param_2,param_3 + -1,param_4 + -1);
param_3 = param_3 + 1;... |
7,586 | func0 |
#include <string.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (!m)
return n;
if (!n)
return m;
if (X[m - 1] == Y[n - 1])
return 1 + func0(X, Y, m - 1, n - 1);
int left = func0(X, Y, m - 1, n);
int right = func0(X, Y, m, n - 1);
return 1 + (left < right ? left : righ... | int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 9);
assert(func0("feek", "eke", 4, 3) == 5);
assert(func0("PARRT", "RTA", 5, 3) == 6);
return 0;
}
| O2 | c | func0:
endbr64
test %edx,%edx
je 12fa <func0+0xca>
test %ecx,%ecx
je 12fd <func0+0xcd>
push %r15
movslq %ecx,%rcx
movslq %edx,%rax
push %r14
sub %rcx,%rax
push %r13
add %rdi,%rax
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
jmp 127f <... | func0:
endbr64
test edx, edx
jz loc_12FA
test ecx, ecx
jz loc_12FD
push r15
movsxd rcx, ecx
movsxd rax, edx
push r14
sub rax, rcx
push r13
add rax, rdi
push r12
mov r12, rdi
push rbp
mov rbp, rsi
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_127F
loc_1270... | long long func0(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
int v5; // ebx
unsigned int v6; // r14d
int v7; // r15d
int v8; // eax
if ( !(_DWORD)a3 )
return (unsigned int)a4;
if ( !(_DWORD)a4 )
return (unsigned int)a3;
a4 = (int)a4;
v4 = a1 + (int)a3 - (lon... | func0:
ENDBR64
TEST EDX,EDX
JZ 0x001012fa
TEST ECX,ECX
JZ 0x001012fd
PUSH R15
MOVSXD RCX,ECX
MOVSXD RAX,EDX
PUSH R14
SUB RAX,RCX
PUSH R13
ADD RAX,RDI
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x0010127f
LAB_00101270:
ADD EBX,0x1
TEST EDX,EDX
JZ 0x001012d0
SUB RCX,0x1
TEST ECX,ECX
JZ... | int func0(long param_1,long param_2,int param_3,int param_4)
{
long lVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_3 == 0) {
return param_4;
}
if (param_4 != 0) {
lVar2 = (long)param_4;
lVar1 = param_3 - lVar2;
iVar4 = 0;
while( true ) {
iVar5 = (int)lVar2 + ... |
7,587 | func0 |
#include <string.h>
#include <assert.h>
| int func0(const char *X, const char *Y, int m, int n) {
if (!m)
return n;
if (!n)
return m;
if (X[m - 1] == Y[n - 1])
return 1 + func0(X, Y, m - 1, n - 1);
int left = func0(X, Y, m - 1, n);
int right = func0(X, Y, m, n - 1);
return 1 + (left < right ? left : righ... | int main() {
assert(func0("AGGTAB", "GXTXAYB", 6, 7) == 9);
assert(func0("feek", "eke", 4, 3) == 5);
assert(func0("PARRT", "RTA", 5, 3) == 6);
return 0;
}
| O3 | c | func0:
endbr64
test %edx,%edx
je 12fa <func0+0xca>
test %ecx,%ecx
je 12fd <func0+0xcd>
push %r15
movslq %ecx,%rcx
movslq %edx,%rax
push %r14
sub %rcx,%rax
push %r13
add %rdi,%rax
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
jmp 127f <... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
movsxd rbx, ecx
sub rsp, 38h
test edx, edx
jz loc_16D5
mov ebp, edx
test ebx, ebx
jz loc_16D9
movsxd rdx, edx
xor r13d, r13d
sub rdx, rbx
add rdx, rdi
jmp short loc_12E0
loc_12C8:
add r13... | long long func0(long long a1, long long a2, unsigned int a3, unsigned int a4)
{
long long v4; // rbx
long long v5; // rbp
int v6; // r13d
long long v7; // rdx
char v8; // r12
char v9; // al
long long v10; // r15
int v11; // r14d
int v12; // r9d
int v13; // r8d
long long v14; // rdx
long long v1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOVSXD RBX,ECX
SUB RSP,0x38
TEST EDX,EDX
JZ 0x001016d5
MOV EBP,EDX
TEST EBX,EBX
JZ 0x001016d9
MOVSXD RDX,EDX
XOR R13D,R13D
SUB RDX,RBX
ADD RDX,RDI
JMP 0x001012e0
LAB_001012c8:
ADD R13D,0x1
TEST EBP,EBP
JZ 0x00101680
SUB RBX,0x1
TEST EBX,EBX
JZ 0x00101... | int func0(long param_1,long param_2,int param_3,int param_4)
{
char cVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
uint uVar7;
long lVar8;
ulong uVar9;
int iVar10;
ulong uVar11;
int iVar12;
uint uVar13;
uint uVar14;
char cVar15;
int iVar16;
int iVar17;
uVar11 = (u... |
7,588 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x > y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 20);
assert(func0(19, 15) == 19);
assert(func0(-10, -20) == -10);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jle 1164 <func0+0x1b>
mov -0x4(%rbp),%eax
jmp 1167 <func0+0x1e>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jle short loc_1164
mov eax, [rbp+var_4]
jmp short loc_1167
loc_1164:
mov eax, [rbp+var_8]
loc_1167:
pop rbp
retn | long long func0(unsigned int a1, unsigned int a2)
{
if ( (int)a1 <= (int)a2 )
return a2;
else
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JLE 0x00101164
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x00101167
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
LAB_00101167:
POP RBP
RET | int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
param_2 = param_1;
}
return param_2;
} |
7,589 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x > y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 20);
assert(func0(19, 15) == 19);
assert(func0(-10, -20) == -10);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovge %edi,%eax
retq
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovge eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 >= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVGE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_2 = param_1;
}
return param_2;
} |
7,590 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x > y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 20);
assert(func0(19, 15) == 19);
assert(func0(-10, -20) == -10);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovge %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovge eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 >= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVGE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_2 = param_1;
}
return param_2;
} |
7,591 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x > y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 20);
assert(func0(19, 15) == 19);
assert(func0(-10, -20) == -10);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovge %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovge eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 >= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVGE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_2 = param_1;
}
return param_2;
} |
7,592 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int product = 1;
for (int i = 0; i < size; i++) {
product *= nums[i];
}
return product;
}
| int main() {
int nums1[] = {4, 3, 2, 2, -1, 18};
assert(func0(nums1, 6) == -864);
int nums2[] = {1, 2, 3};
assert(func0(nums2, 3) == 6);
int nums3[] = {-2, -4, -6};
assert(func0(nums3, 3) == -48);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ab <func0+0x42>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov -0x8(%rbp),%edx
imul %edx,%eax
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_11AB
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, [rbp+var_8]
imu... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 1;
for ( i = 0; i < a2; ++i )
v3 *= *(_DWORD *)(4LL * i + a1);
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ab
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV EDX... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = *(int *)(param_1 + (long)local_c * 4) * local_10;
}
return local_10;
} |
7,593 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int product = 1;
for (int i = 0; i < size; i++) {
product *= nums[i];
}
return product;
}
| int main() {
int nums1[] = {4, 3, 2, 2, -1, 18};
assert(func0(nums1, 6) == -864);
int nums2[] = {1, 2, 3};
assert(func0(nums2, 3) == 6);
int nums3[] = {-2, -4, -6};
assert(func0(nums3, 3) == -48);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1190 <func0+0x27>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x1,%edx
imul (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x1,%edx
jmp 118d <func0+0x24>
| func0:
endbr64
test esi, esi
jle short loc_1190
mov rax, rdi
lea edx, [rsi-1]
lea rcx, [rdi+rdx*4+4]
mov edx, 1
loc_1181:
imul edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1181
loc_118D:
mov eax, edx
retn
loc_1190:
mov edx, 1
jmp short loc_118D | long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return 1;
}
else
{
v2 = a1;
v3 = 1;
do
v3 *= *v2++;
while ( v2 != &a1[a2 - 1 + 1] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101190
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RCX,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x1
LAB_00101181:
IMUL EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101181
LAB_0010118d:
MOV EAX,EDX
RET
LAB_00101190:
MOV EDX,0x1
JMP 0x0010118d | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 1;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 1;
do {
iVar2 = iVar2 * *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
} |
7,594 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int product = 1;
for (int i = 0; i < size; i++) {
product *= nums[i];
}
return product;
}
| int main() {
int nums1[] = {4, 3, 2, 2, -1, 18};
assert(func0(nums1, 6) == -864);
int nums2[] = {1, 2, 3};
assert(func0(nums2, 3) == 6);
int nums3[] = {-2, -4, -6};
assert(func0(nums3, 3) == -48);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1168 <func0+0x28>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
mov $0x1,%eax
nopl (%rax)
imul (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1158 <func0+0x18>
retq
nopl (%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| func0:
endbr64
test esi, esi
jle short loc_1258
lea eax, [rsi-1]
lea rdx, [rdi+rax*4+4]
mov eax, 1
nop dword ptr [rax]
loc_1248:
imul eax, [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_1248
retn
loc_1258:
mov eax, 1
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rdx
long long result; // rax
if ( a2 <= 0 )
return 1LL;
v2 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 1;
do
result = (unsigned int)(*a1++ * result);
while ( a1 != (_DWORD *)v2 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101258
LEA EAX,[RSI + -0x1]
LEA RDX,[RDI + RAX*0x4 + 0x4]
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101248:
IMUL EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x00101248
RET
LAB_00101258:
MOV EAX,0x1
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 1;
do {
iVar2 = iVar2 * *param_1;
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
}
return 1;
} |
7,595 | func0 |
#include <assert.h>
| int func0(int nums[], int size) {
int product = 1;
for (int i = 0; i < size; i++) {
product *= nums[i];
}
return product;
}
| int main() {
int nums1[] = {4, 3, 2, 2, -1, 18};
assert(func0(nums1, 6) == -864);
int nums2[] = {1, 2, 3};
assert(func0(nums2, 3) == 6);
int nums3[] = {-2, -4, -6};
assert(func0(nums3, 3) == -48);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 1208 <func0+0xc8>
lea -0x1(%rsi),%eax
cmp $0x1c,%eax
jbe 1212 <func0+0xd2>
mov %esi,%edx
movdqa 0xeae(%rip),%xmm1
mov %rdi,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm2
movdqu (%rax),%xmm0
add $0x10,%rax
pmuludq %xmm1,%xmm2
psrlq $0... | func0:
endbr64
mov rcx, rdi
test esi, esi
jle loc_1238
lea eax, [rsi-1]
cmp eax, 1Ah
jbe loc_1240
mov edx, esi
movdqa xmm1, cs:xmmword_2010
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop word ptr [rax+rax+00h]
loc_1178:
movdqu xmm2, xmmword ptr [rax]
movdqu xmm0, x... | long long func0(const __m128i *a1, int a2)
{
__m128i si128; // xmm1
const __m128i *v4; // rax
__m128i v5; // xmm2
int v6; // eax
__m128i v7; // xmm2
__m128i v8; // xmm1
unsigned int v9; // edx
char v10; // di
long long v11; // rax
int v12; // edi
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1)... | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x00101238
LEA EAX,[RSI + -0x1]
CMP EAX,0x1a
JBE 0x00101240
MOV EDX,ESI
MOVDQA XMM1,xmmword ptr [0x00102010]
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101178:
MOVDQU XMM2,xmmword ptr [RAX]
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PMU... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong func0(ulong *param_1,uint param_2)
{
ulong *puVar1;
ulong *puVar2;
uint uVar3;
ulong *puVar4;
long lVar5;
long lVar6;
int iVar7;
uint uVar8;
ulong uVar9;
ulong uVar10;
int auVar11 [16];
int4 uVar13;
ul... |
7,596 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeffi(int n, int k) {
if (k == 0 || k == n)
return 1;
return binomial_coeffi(n - 1, k - 1) + binomial_coeffi(n - 1, k);
}
| int func0(int n, int m) {
if (n == 0 && m == 0)
return 1;
if (n == 1 && m == 0)
return 0;
if (m == 0)
return (n - 1) * (func0(n - 1, 0) + func0(n - 2, 0));
return binomial_coeffi(n, m) * func0(n - m, 0);
}
| int main() {
assert(func0(7, 2) == 924);
assert(func0(3, 0) == 2);
assert(func0(3, 1) == 3);
printf("All test cases passed!\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
cmpl $0x0,-0x14(%rbp)
jne 11eb <func0+0x28>
cmpl $0x0,-0x18(%rbp)
jne 11eb <func0+0x28>
mov $0x1,%eax
jmp 125f <func0+0x9c>
cmpl $0x1,-0x14(%rbp)
jne 11fe <func0+0x3... | func0:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 10h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
cmp [rbp+var_14], 0
jnz short loc_11EA
cmp [rbp+var_18], 0
jnz short loc_11EA
mov eax, 1
jmp short loc_125E
loc_11EA:
cmp [rbp+var_14], 1
jnz short loc... | long long func0(unsigned int a1, unsigned int a2)
{
int v3; // ebx
int v4; // ebx
if ( !a1 && !a2 )
return 1LL;
if ( a1 == 1 && !a2 )
return 0LL;
if ( a2 )
{
v4 = binomial_coeffi(a1, a2);
return v4 * (unsigned int)func0(a1 - a2, 0LL);
}
else
{
v3 = func0(a1 - 1, 0LL);
return ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001011ea
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x001011ea
MOV EAX,0x1
JMP 0x0010125e
LAB_001011ea:
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x001011fd
CMP dwo... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if ((param_1 == 0) && (param_2 == 0)) {
iVar2 = 1;
}
else if ((param_1 == 1) && (param_2 == 0)) {
iVar2 = 0;
}
else if (param_2 == 0) {
iVar1 = func0(param_1 + -1,0);
iVar2 = func0(param_1 + -2,0);
iVar2 = (iVar2 + iVar1) *... |
7,597 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeffi(int n, int k) {
if (k == 0 || k == n)
return 1;
return binomial_coeffi(n - 1, k - 1) + binomial_coeffi(n - 1, k);
}
| int func0(int n, int m) {
if (n == 0 && m == 0)
return 1;
if (n == 1 && m == 0)
return 0;
if (m == 0)
return (n - 1) * (func0(n - 1, 0) + func0(n - 2, 0));
return binomial_coeffi(n, m) * func0(n - m, 0);
}
| int main() {
assert(func0(7, 2) == 924);
assert(func0(3, 0) == 2);
assert(func0(3, 1) == 3);
printf("All test cases passed!\n");
return 0;
}
| O1 | c | func0:
endbr64
mov $0x1,%eax
mov %edi,%edx
or %esi,%edx
je 121b <func0+0x74>
push %r12
push %rbp
push %rbx
mov %edi,%ebx
mov %esi,%ebp
cmp $0x1,%edi
jne 11cc <func0+0x25>
mov $0x0,%eax
test %esi,%esi
je 11ee <func0+0x47>
test %ebp,%ebp
je 11f3 <func0+0x4c>
mov %ebp,%esi... | func0:
endbr64
mov eax, 1
mov edx, edi
or edx, esi
jz short locret_121B
push r12
push rbp
push rbx
mov ebx, edi
mov ebp, esi
cmp edi, 1
jnz short loc_11CC
mov eax, 0
test esi, esi
jz short loc_11EE
loc_11CC:
test ebp, ebp
jz short loc_11F3
mov esi, ebp
... | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
int v3; // r12d
int v4; // ebp
result = 1LL;
if ( a2 | a1 )
{
if ( a1 != 1 || (result = 0LL, a2) )
{
if ( a2 )
{
v3 = binomial_coeffi(a1, a2);
return v3 * (unsigned int)func0(a1 - a2, 0LL);
... | func0:
ENDBR64
MOV EAX,0x1
MOV EDX,EDI
OR EDX,ESI
JZ 0x0010121b
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
MOV EBP,ESI
CMP EDI,0x1
JNZ 0x001011cc
MOV EAX,0x0
TEST ESI,ESI
JZ 0x001011ee
LAB_001011cc:
TEST EBP,EBP
JZ 0x001011f3
MOV ESI,EBP
MOV EDI,EBX
CALL 0x00101169
MOV R12D,EAX
SUB EBX,EBP
MOV EDI,EBX
MOV ESI,0x0
CALL 0x00... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_1 != 0 || param_2 != 0) {
if ((param_1 != 1) || (iVar2 = 0, param_2 != 0)) {
if (param_2 == 0) {
iVar2 = func0(param_1 + -1,0);
iVar1 = func0(param_1 + -2,0);
iVar2 = (iVar1 + iVar2) * (param_1 + -1);
... |
7,598 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeffi(int n, int k) {
if (k == 0 || k == n)
return 1;
return binomial_coeffi(n - 1, k - 1) + binomial_coeffi(n - 1, k);
}
| int func0(int n, int m) {
if (n == 0 && m == 0)
return 1;
if (n == 1 && m == 0)
return 0;
if (m == 0)
return (n - 1) * (func0(n - 1, 0) + func0(n - 2, 0));
return binomial_coeffi(n, m) * func0(n - m, 0);
}
| int main() {
assert(func0(7, 2) == 924);
assert(func0(3, 0) == 2);
assert(func0(3, 1) == 3);
printf("All test cases passed!\n");
return 0;
}
| O2 | c | func0:
endbr64
push %r13
mov %edi,%eax
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
or %esi,%eax
je 1320 <func0+0x80>
mov %edi,%ebx
mov %esi,%edx
cmp $0x1,%edi
jne 1310 <func0+0x70>
test %esi,%esi
je 1338 <func0+0x98>
mov %ebx,%edi
mov %edx,%esi
xor %r12d,%r12d
callq 123... | func0:
endbr64
push r15
mov eax, edi
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
or eax, esi
jz loc_1670
test esi, esi
mov ebp, edi
mov r14d, esi
setz cl
mov eax, ecx
cmp edi, 1
jnz short loc_15D5
test cl, cl
jnz loc_1660
loc_15D5:
mov ... | long long func0(int a1, int a2)
{
int v2; // ebp
int v3; // r13d
int v4; // ebx
int v5; // r12d
unsigned int v6; // ebx
unsigned int v8; // [rsp+Ch] [rbp-3Ch]
if ( a2 | a1 )
{
v2 = a1;
if ( a1 == 1 && !a2 )
{
return 0;
}
else
{
v8 = 0;
v3 = 1;
if ( !a2 )... | func0:
ENDBR64
PUSH R15
MOV EAX,EDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
OR EAX,ESI
JZ 0x00101670
TEST ESI,ESI
MOV EBP,EDI
MOV R14D,ESI
SETZ CL
MOV EAX,ECX
CMP EDI,0x1
JNZ 0x001015d5
TEST CL,CL
JNZ 0x00101660
LAB_001015d5:
MOV dword ptr [RSP + 0xc],0x0
MOV R13D,0x1
TEST R14D,R14D
JZ 0x00101623
CMP ... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int local_3c;
if (param_1 == 0 && param_2 == 0) {
local_3c = 1;
}
else if ((param_1 != 1) || (param_2 != 0)) {
local_3c = 0;
iVar1 = 1;
if (param_2 == 0) goto LAB_00101623;
if (param_1 != param_2) {
iVar3 =... |
7,599 | func0 |
#include <stdio.h>
#include <assert.h>
int binomial_coeffi(int n, int k) {
if (k == 0 || k == n)
return 1;
return binomial_coeffi(n - 1, k - 1) + binomial_coeffi(n - 1, k);
}
| int func0(int n, int m) {
if (n == 0 && m == 0)
return 1;
if (n == 1 && m == 0)
return 0;
if (m == 0)
return (n - 1) * (func0(n - 1, 0) + func0(n - 2, 0));
return binomial_coeffi(n, m) * func0(n - m, 0);
}
| int main() {
assert(func0(7, 2) == 924);
assert(func0(3, 0) == 2);
assert(func0(3, 1) == 3);
printf("All test cases passed!\n");
return 0;
}
| O3 | c | func0:
endbr64
push %r13
mov %edi,%eax
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
or %esi,%eax
je 1350 <func0+0xb0>
test %esi,%esi
mov %edi,%ebx
mov %esi,%ecx
sete %dl
mov %edx,%eax
cmp $0x1,%edi
jne 12cc <func0+0x2c>
test %dl,%dl
jne 1348 <func0+0xa8>
mov $0x1,%ebp
xor... | func0:
endbr64
mov eax, edi
push r14
or eax, esi
push r13
push r12
push rbp
push rbx
jz loc_16B8
mov r12d, edi
mov r13d, esi
cmp edi, 1
jnz short loc_1698
test esi, esi
jz loc_16D0
loc_1629:
cmp r12d, r13d
jz short loc_16A8
lea r14d, [r13-1]
mov ebx,... | long long func0(int a1, int a2)
{
int v2; // r12d
int v3; // ebx
int v4; // ebp
int v5; // ebp
unsigned int v6; // ebx
unsigned int v7; // r13d
int v8; // eax
if ( a2 | a1 )
{
v2 = a1;
if ( a1 == 1 )
{
if ( !a2 )
return 0;
}
else if ( !a2 )
{
v6 = 0;
... | func0:
ENDBR64
MOV EAX,EDI
PUSH R14
OR EAX,ESI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
JZ 0x001016b8
MOV R12D,EDI
MOV R13D,ESI
CMP EDI,0x1
JNZ 0x00101698
TEST ESI,ESI
JZ 0x001016d0
LAB_00101629:
CMP R12D,R13D
JZ 0x001016a8
LEA R14D,[R13 + -0x1]
MOV EBX,R12D
XOR EBP,EBP
LAB_00101637:
SUB EBX,0x1
MOV ESI,R14D
MOV EDI,EBX
CAL... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_1 == 0 && param_2 == 0) {
return 1;
}
if (param_1 == 1) {
if (param_2 == 0) {
return 0;
}
}
else if (param_2 == 0) {
iVar2 = 0;
iVar3 = 1;
goto LAB_0010165e;
}
if (param_1 =... |
7,600 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
// Node structure
typedef struct Node {
int data;
struct Node* left;
struct Node* right;
} Node;
// Function to create a new node
Node* newNode(int data) {
Node* node = (Node*) malloc(sizeof(Node));
node->data = data;
... | int func0(Node* node) {
if (node == NULL) {
return 0;
} else {
int left_height = func0(node->left);
int right_height = func0(node->right);
if (left_height > right_height) {
return left_height + 1;
} else {
return right_height + 1;
... | int main() {
// Constructing trees as per the given Python code
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right =... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
cmpq $0x0,-0x18(%rbp)
jne 11eb <func0+0x1e>
mov $0x0,%eax
jmp 1227 <func0+0x5a>
mov -0x18(%rbp),%rax
mov 0x8(%rax),%rax
mov %rax,%rdi
callq 11cd <func0>
mov %eax,-0x8(%rbp)
mov -0x18(%rbp),%rax
mov 0x10(%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
cmp [rbp+var_18], 0
jnz short loc_11EB
mov eax, 0
jmp short locret_1227
loc_11EB:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rdi, rax
call func0
mov [rbp+var_8], eax
mov rax, [rbp+var_18]
mov ... | long long func0(long long a1)
{
int v2; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
if ( !a1 )
return 0LL;
v2 = func0(*(_QWORD *)(a1 + 8));
v3 = func0(*(_QWORD *)(a1 + 16));
if ( v2 <= v3 )
return (unsigned int)(v3 + 1);
else
return (unsigned int)(v2 + 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x001011eb
MOV EAX,0x0
JMP 0x00101227
LAB_001011eb:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,RAX
CALL 0x001011cd
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x18... | int func0(long param_1)
{
int iVar1;
int iVar2;
if (param_1 == 0) {
iVar1 = 0;
}
else {
iVar1 = func0(*(int8 *)(param_1 + 8));
iVar2 = func0(*(int8 *)(param_1 + 0x10));
if (iVar2 < iVar1) {
iVar1 = iVar1 + 1;
}
else {
iVar1 = iVar2 + 1;
}
}
return iVar1;
} |
7,601 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
// Node structure
typedef struct Node {
int data;
struct Node* left;
struct Node* right;
} Node;
// Function to create a new node
Node* newNode(int data) {
Node* node = (Node*) malloc(sizeof(Node));
node->data = data;
... | int func0(Node* node) {
if (node == NULL) {
return 0;
} else {
int left_height = func0(node->left);
int right_height = func0(node->right);
if (left_height > right_height) {
return left_height + 1;
} else {
return right_height + 1;
... | int main() {
// Constructing trees as per the given Python code
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right =... | O1 | c | func0:
endbr64
mov $0x0,%eax
test %rdi,%rdi
je 11ed <func0+0x3f>
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov 0x8(%rdi),%rdi
callq 11ae <func0>
mov %eax,%ebp
mov 0x10(%rbx),%rdi
callq 11ae <func0>
mov %eax,%edx
lea 0x1(%rbp),%ecx
lea 0x1(%rax),%eax
cmp %edx,%ebp
cmovg %... | func0:
endbr64
mov eax, 0
test rdi, rdi
jz short locret_11ED
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov rdi, [rdi+8]
call func0
mov ebp, eax
mov rdi, [rbx+10h]
call func0
lea ecx, [rbp+1]
lea edx, [rax+1]
cmp ebp, eax
mov eax, ecx
cmovle eax, edx
add r... | long long func0(long long a1)
{
long long result; // rax
int v2; // ebp
int v3; // eax
unsigned int v4; // edx
bool v5; // cc
result = 0LL;
if ( a1 )
{
v2 = func0(*(_QWORD *)(a1 + 8));
v3 = func0(*(_QWORD *)(a1 + 16));
v4 = v3 + 1;
v5 = v2 <= v3;
result = (unsigned int)(v2 + 1);
... | func0:
ENDBR64
MOV EAX,0x0
TEST RDI,RDI
JZ 0x001011ed
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
CALL 0x001011ae
MOV EBP,EAX
MOV RDI,qword ptr [RBX + 0x10]
CALL 0x001011ae
LEA ECX,[RBP + 0x1]
LEA EDX,[RAX + 0x1]
CMP EBP,EAX
MOV EAX,ECX
CMOVLE EAX,EDX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0010... | int func0(long param_1)
{
int iVar1;
int iVar2;
if (param_1 != 0) {
iVar1 = func0(*(int8 *)(param_1 + 8));
iVar2 = func0(*(int8 *)(param_1 + 0x10));
if (iVar1 <= iVar2) {
iVar1 = iVar2;
}
return iVar1 + 1;
}
return 0;
} |
7,602 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
// Node structure
typedef struct Node {
int data;
struct Node* left;
struct Node* right;
} Node;
// Function to create a new node
Node* newNode(int data) {
Node* node = (Node*) malloc(sizeof(Node));
node->data = data;
... | int func0(Node* node) {
if (node == NULL) {
return 0;
} else {
int left_height = func0(node->left);
int right_height = func0(node->right);
if (left_height > right_height) {
return left_height + 1;
} else {
return right_height + 1;
... | int main() {
// Constructing trees as per the given Python code
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right =... | O2 | c | func0:
endbr64
test %rdi,%rdi
je 14e0 <func0+0x10>
jmp 14f0 <func0.part.0>
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0_part_0:
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
mov rbp, [rdi+8]
test rbp, rbp
jz loc_1A38
mov r12, [rbp+8]
test r12, r12
jz loc_19D8
mov r13, [r12+8]
test r13, r13
jz loc_1B40
mov r14, [r13+8]
test r14, r14... | long long func0_part_0(long long a1, long long a2, long long a3)
{
long long v4; // rbp
long long v5; // r12
long long v6; // r13
long long v7; // r14
int v8; // r15d
int v9; // eax
int v10; // r14d
long long v11; // r15
int v12; // eax
int v13; // r13d
int v14; // eax
int v15; // edx
bool v1... | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV RBP,qword ptr [RDI + 0x8]
TEST RBP,RBP
JZ 0x00101a38
MOV R12,qword ptr [RBP + 0x8]
TEST R12,R12
JZ 0x001019d8
MOV R13,qword ptr [R12 + 0x8]
TEST R13,R13
JZ 0x00101b40
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JZ 0x00101c00
... | int func0_part_0(long param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
long lVar9;
long lVar10;
long lVar11;
lVar9 = *(long *)(param_1 + 8);
if (lVar9 == 0) {
lVar9 = *(long *)(param_1 + 0x10);
iVar2 = 0;
if (lVar9 == 0) {
... |
7,603 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
// Node structure
typedef struct Node {
int data;
struct Node* left;
struct Node* right;
} Node;
// Function to create a new node
Node* newNode(int data) {
Node* node = (Node*) malloc(sizeof(Node));
node->data = data;
... | int func0(Node* node) {
if (node == NULL) {
return 0;
} else {
int left_height = func0(node->left);
int right_height = func0(node->right);
if (left_height > right_height) {
return left_height + 1;
} else {
return right_height + 1;
... | int main() {
// Constructing trees as per the given Python code
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
Node* root1 = newNode(1);
root1->left = newNode(2);
root1->right =... | O3 | c | func0:
endbr64
xor %eax,%eax
test %rdi,%rdi
je 1aa0 <func0+0x5d0>
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rdi),%rax
mov 0x10(%rdi),%r8
test %rax,%rax
je 1a50 <func0+0x580>
mov 0x8(%rax),%rdx
mov 0x10(%rax),%r10
test %rdx,%rdx
je 1ae0 <func0+0x610>
mov 0x8(%rdx),%rax
mov ... | func0_part_0:
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
mov rbp, [rdi+8]
test rbp, rbp
jz loc_16E8
mov r12, [rbp+8]
test r12, r12
jz loc_1590
mov r13, [r12+8]
test r13, r13
jz loc_1C10
mov r14, [r13+8]
test r14, r14... | long long func0_part_0(long long a1, long long a2, long long a3)
{
long long v4; // rbp
long long v5; // r12
long long v6; // r13
long long v7; // r14
int v8; // r15d
int v9; // eax
long long v10; // r13
int v11; // eax
int v12; // r15d
int v13; // eax
bool v14; // cc
long long v15; // r12
in... | func0.part.0:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV RBP,qword ptr [RDI + 0x8]
TEST RBP,RBP
JZ 0x001016e8
MOV R12,qword ptr [RBP + 0x8]
TEST R12,R12
JZ 0x00101590
MOV R13,qword ptr [R12 + 0x8]
TEST R13,R13
JZ 0x00101c10
MOV R14,qword ptr [R13 + 0x8]
TEST R14,R14
JZ 0x00101c50
... | int func0_part_0(long param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
long lVar9;
long lVar10;
long lVar11;
lVar10 = *(long *)(param_1 + 8);
if (lVar10 == 0) {
lVar10 = *(long *)(param_1 + 0x10);
iVar2 = 1;
iVar3 = 0;
joined_r... |
7,604 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* dt) {
static char new_format[11];
int year, month, day;
sscanf(dt, "%d-%d-%d", &year, &month, &day);
sprintf(new_format, "%02d-%02d-%d", day, month, year);
return new_format;
}
| int main() {
assert(strcmp(func0("2026-01-02"), "02-01-2026") == 0);
assert(strcmp(func0("2021-01-04"), "04-01-2021") == 0);
assert(strcmp(func0("2030-06-06"), "06-06-2030") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0xc(%rbp),%rsi
lea -0x10(%rbp),%rcx
lea -0x14(%rbp),%rdx
mov -0x28(%rbp),%rax
mov %rsi,%r8
lea 0xe06(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
call... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rsi, [rbp+var_C]
lea rcx, [rbp+var_10]
lea rdx, [rbp+var_14]
mov rax, [rbp+var_28]
mov r8, rsi
lea rsi, aDDD; "%d-%d-%d"
mov rdi, rax
mov ... | char * func0(long long a1)
{
int v2; // [rsp+1Ch] [rbp-14h] BYREF
int v3; // [rsp+20h] [rbp-10h] BYREF
int v4; // [rsp+24h] [rbp-Ch] BYREF
unsigned long long v5; // [rsp+28h] [rbp-8h]
v5 = __readfsqword(0x28u);
__isoc99_sscanf(a1, "%d-%d-%d", &v2, &v3, &v4);
sprintf(new_format_1, "%02d-%02d-%d", v4, v3, ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RSI,[RBP + -0xc]
LEA RCX,[RBP + -0x10]
LEA RDX,[RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x28]
MOV R8,RSI
LEA RSI,[0x102008]
MOV RDI,RAX
MOV EAX,0x0
CALL 0x001010c0
M... | int1 * func0(int8 param_1)
{
long in_FS_OFFSET;
uint local_1c;
uint local_18;
uint local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__isoc99_sscanf(param_1,"%d-%d-%d",&local_1c,&local_18,&local_14);
sprintf(new_format_1,"%02d-%02d-%d",(ulong)local_14,(ulong)local_18,(ulong)local_1... |
7,605 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* dt) {
static char new_format[11];
int year, month, day;
sscanf(dt, "%d-%d-%d", &year, &month, &day);
sprintf(new_format, "%02d-%02d-%d", day, month, year);
return new_format;
}
| int main() {
assert(strcmp(func0("2026-01-02"), "02-01-2026") == 0);
assert(strcmp(func0("2021-01-04"), "04-01-2021") == 0);
assert(strcmp(func0("2030-06-06"), "06-06-2030") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbx
sub $0x20,%rsp
mov $0x28,%ebx
mov %fs:(%rbx),%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rcx
lea 0xc(%rsp),%rdx
lea 0x14(%rsp),%r8
lea 0xe2c(%rip),%rsi
callq 10a0 <__isoc99_sscanf@plt>
sub $0x8,%rsp
mov 0x14(%rsp),%eax
push %rax
mov 0x20(%rsp)... | func0:
endbr64
push rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+28h+var_10], rax
xor eax, eax
lea rcx, [rsp+28h+var_18]
lea rdx, [rsp+28h+var_1C]
lea r8, [rsp+28h+var_14]
lea rsi, aDDD; "%d-%d-%d"
call ___isoc99_sscanf
sub rsp, 8
mov eax, [rsp+30h+var_1C]
push rax
mov ... | void * func0(long long a1)
{
int v2; // [rsp+Ch] [rbp-1Ch] BYREF
int v3; // [rsp+10h] [rbp-18h] BYREF
int v4; // [rsp+14h] [rbp-14h] BYREF
unsigned long long v5; // [rsp+18h] [rbp-10h]
v5 = __readfsqword(0x28u);
__isoc99_sscanf(a1, "%d-%d-%d", &v2, &v3, &v4);
__sprintf_chk(&new_format_1, 1LL, 11LL, "%02d... | func0:
ENDBR64
PUSH RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RCX,[RSP + 0x10]
LEA RDX,[RSP + 0xc]
LEA R8,[RSP + 0x14]
LEA RSI,[0x102004]
CALL 0x001010c0
SUB RSP,0x8
MOV EAX,dword ptr [RSP + 0x14]
PUSH RAX
MOV R9D,dword ptr [RSP + 0x20]
MOV R8D,dword ptr [RSP + 0x24]
LE... | int1 * func0(int8 param_1)
{
long in_FS_OFFSET;
int4 local_1c;
int4 local_18;
int4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__isoc99_sscanf(param_1,"%d-%d-%d",&local_1c,&local_18,&local_14);
__sprintf_chk(new_format_1,1,0xb,"%02d-%02d-%d",local_14,local_18,local_1c);
if ... |
7,606 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* dt) {
static char new_format[11];
int year, month, day;
sscanf(dt, "%d-%d-%d", &year, &month, &day);
sprintf(new_format, "%02d-%02d-%d", day, month, year);
return new_format;
}
| int main() {
assert(strcmp(func0("2026-01-02"), "02-01-2026") == 0);
assert(strcmp(func0("2021-01-04"), "04-01-2021") == 0);
assert(strcmp(func0("2030-06-06"), "06-06-2030") == 0);
return 0;
}
| O2 | c | func0:
endbr64
sub $0x28,%rsp
lea 0xd65(%rip),%rsi
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rcx
lea 0xc(%rsp),%rdx
lea 0x14(%rsp),%r8
callq 10a0 <__isoc99_sscanf@plt>
sub $0x8,%rsp
mov $0xb,%edx
lea 0xd3a(%rip),%rcx
mov 0x14(%rsp),%eax
mov $0x1,%esi
lea... | func0:
endbr64
push r12
lea rsi, aDDD; "%d-%d-%d"
lea r12, new_format_1
sub rsp, 20h
mov rax, fs:28h
mov [rsp+28h+var_10], rax
xor eax, eax
lea rcx, [rsp+28h+var_18]
lea rdx, [rsp+28h+var_1C]
lea r8, [rsp+28h+var_14]
call ___isoc99_sscanf
sub rsp, 8
mov edx, 0Bh
mov ... | void * func0(long long a1)
{
int v2; // [rsp+Ch] [rbp-1Ch] BYREF
int v3; // [rsp+10h] [rbp-18h] BYREF
int v4; // [rsp+14h] [rbp-14h] BYREF
unsigned long long v5; // [rsp+18h] [rbp-10h]
v5 = __readfsqword(0x28u);
__isoc99_sscanf(a1, "%d-%d-%d", &v2, &v3, &v4);
__sprintf_chk(&new_format_1, 1LL, 11LL, "%02d... | func0:
ENDBR64
PUSH R12
LEA RSI,[0x102004]
LEA R12,[0x104018]
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RCX,[RSP + 0x10]
LEA RDX,[RSP + 0xc]
LEA R8,[RSP + 0x14]
CALL 0x001010c0
SUB RSP,0x8
MOV EDX,0xb
MOV RDI,R12
MOV EAX,dword ptr [RSP + 0x14]
LEA RCX,[0x10200d]
MOV ESI,0x1... | int1 * func0(int8 param_1)
{
long in_FS_OFFSET;
int4 local_1c;
int4 local_18;
int4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__isoc99_sscanf(param_1,"%d-%d-%d",&local_1c,&local_18,&local_14);
__sprintf_chk(new_format_1,1,0xb,"%02d-%02d-%d",local_14,local_18,local_1c);
if ... |
7,607 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* dt) {
static char new_format[11];
int year, month, day;
sscanf(dt, "%d-%d-%d", &year, &month, &day);
sprintf(new_format, "%02d-%02d-%d", day, month, year);
return new_format;
}
| int main() {
assert(strcmp(func0("2026-01-02"), "02-01-2026") == 0);
assert(strcmp(func0("2021-01-04"), "04-01-2021") == 0);
assert(strcmp(func0("2030-06-06"), "06-06-2030") == 0);
return 0;
}
| O3 | c | func0:
endbr64
sub $0x28,%rsp
lea 0xd65(%rip),%rsi
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rcx
lea 0xc(%rsp),%rdx
lea 0x14(%rsp),%r8
callq 10a0 <__isoc99_sscanf@plt>
sub $0x8,%rsp
mov $0xb,%edx
lea 0xd3a(%rip),%rcx
mov 0x14(%rsp),%eax
mov $0x1,%esi
lea... | func0:
endbr64
push rbx
lea rsi, aDDD; "%d-%d-%d"
lea rbx, new_format_1
sub rsp, 20h
mov rax, fs:28h
mov [rsp+28h+var_10], rax
xor eax, eax
lea rcx, [rsp+28h+var_18]
lea rdx, [rsp+28h+var_1C]
lea r8, [rsp+28h+var_14]
call ___isoc99_sscanf
sub rsp, 8
mov edx, 0Bh
mov ... | void * func0(long long a1)
{
int v2; // [rsp+Ch] [rbp-1Ch] BYREF
int v3; // [rsp+10h] [rbp-18h] BYREF
int v4; // [rsp+14h] [rbp-14h] BYREF
unsigned long long v5; // [rsp+18h] [rbp-10h]
v5 = __readfsqword(0x28u);
__isoc99_sscanf(a1, "%d-%d-%d", &v2, &v3, &v4);
__sprintf_chk(&new_format_1, 2LL, 11LL, "%02d... | func0:
ENDBR64
PUSH RBX
LEA RSI,[0x102004]
LEA RBX,[0x104018]
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RCX,[RSP + 0x10]
LEA RDX,[RSP + 0xc]
LEA R8,[RSP + 0x14]
CALL 0x001010c0
SUB RSP,0x8
MOV EDX,0xb
MOV RDI,RBX
MOV EAX,dword ptr [RSP + 0x14]
LEA RCX,[0x10200d]
MOV ESI,0x2... | int1 * func0(int8 param_1)
{
long in_FS_OFFSET;
int4 local_1c;
int4 local_18;
int4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
__isoc99_sscanf(param_1,"%d-%d-%d",&local_1c,&local_18,&local_14);
__sprintf_chk(new_format_1,2,0xb,"%02d-%02d-%d",local_14,local_18,local_1c);
if ... |
7,608 | func0 |
#include <assert.h>
| int func0(int *tuplex, int size, int value) {
int count = 0;
for (int i = 0; i < size; i++) {
if (tuplex[i] == value) {
count++;
}
}
return count;
}
| int main() {
int tuplex1[] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
int tuplex2[] = {2, 4, 7, 7, 7, 3, 4, 4, 7};
assert(func0(tuplex1, 9, 4) == 3);
assert(func0(tuplex1, 9, 2) == 2);
assert(func0(tuplex2, 9, 7) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ae <func0+0x45>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x20(%r... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11AE
loc_118B:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cm... | long long func0(long long a1, int a2, int a3)
{
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
if ( a3 == *(_DWORD *)(4LL * i + a1) )
++v4;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ae
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX... | int func0(long param_1,int param_2,int param_3)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (param_3 == *(int *)(param_1 + (long)local_c * 4)) {
local_10 = local_10 + 1;
}
}
return local_10;
} |
7,609 | func0 |
#include <assert.h>
| int func0(int *tuplex, int size, int value) {
int count = 0;
for (int i = 0; i < size; i++) {
if (tuplex[i] == value) {
count++;
}
}
return count;
}
| int main() {
int tuplex1[] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
int tuplex2[] = {2, 4, 7, 7, 7, 3, 4, 4, 7};
assert(func0(tuplex1, 9, 4) == 3);
assert(func0(tuplex1, 9, 2) == 2);
assert(func0(tuplex2, 9, 7) == 4);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 1199 <func0+0x30>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%rdi
mov $0x0,%ecx
cmp %edx,(%rax)
sete %sil
movzbl %sil,%esi
add %esi,%ecx
add $0x4,%rax
cmp %rdi,%rax
jne 1181 <func0+0x18>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1196 <f... | func0:
endbr64
test esi, esi
jle short loc_1199
mov rax, rdi
lea ecx, [rsi-1]
lea rdi, [rdi+rcx*4+4]
mov ecx, 0
loc_1181:
cmp [rax], edx
setz sil
movzx esi, sil
add ecx, esi
add rax, 4
cmp rax, rdi
jnz short loc_1181
loc_1196:
mov eax, ecx
retn
loc_1199:
mov ecx, ... | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
long long v4; // rdi
unsigned int v5; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[a2 - 1 + 1];
v5 = 0;
do
v5 += *v3++ == a3;
while ( v3 != (_DWORD *)v4 );
}
return v5;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101199
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA RDI,[RDI + RCX*0x4 + 0x4]
MOV ECX,0x0
LAB_00101181:
CMP dword ptr [RAX],EDX
SETZ SIL
MOVZX ESI,SIL
ADD ECX,ESI
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x00101181
LAB_00101196:
MOV EAX,ECX
RET
LAB_00101199:
MOV ECX,0x0
JMP 0x00101196 | int func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(*param_1 == param_3);
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}... |
7,610 | func0 |
#include <assert.h>
| int func0(int *tuplex, int size, int value) {
int count = 0;
for (int i = 0; i < size; i++) {
if (tuplex[i] == value) {
count++;
}
}
return count;
}
| int main() {
int tuplex1[] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
int tuplex2[] = {2, 4, 7, 7, 7, 3, 4, 4, 7};
assert(func0(tuplex1, 9, 4) == 3);
assert(func0(tuplex1, 9, 2) == 2);
assert(func0(tuplex2, 9, 7) == 4);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 1340 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
xor %ecx,%ecx
cmp %edx,(%rdi)
sete %cl
add $0x4,%rdi
add %ecx,%eax
cmp %rsi,%rdi
jne 1328 <func0+0x18>
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
r... | func0:
endbr64
test esi, esi
jle short loc_1340
lea eax, [rsi-1]
lea rsi, [rdi+rax*4+4]
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1328:
xor ecx, ecx
cmp [rdi], edx
setz cl
add rdi, 4
add eax, ecx
cmp rdi, rsi
jnz short loc_1328
retn
loc_1340:
xor eax, eax
retn | long long func0(_DWORD *a1, int a2, int a3)
{
long long v3; // rsi
long long result; // rax
BOOL v5; // ecx
if ( a2 <= 0 )
return 0LL;
v3 = (long long)&a1[a2 - 1 + 1];
LODWORD(result) = 0;
do
{
v5 = *a1++ == a3;
result = (unsigned int)(v5 + result);
}
while ( a1 != (_DWORD *)v3 );
re... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101340
LEA EAX,[RSI + -0x1]
LEA RSI,[RDI + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101328:
XOR ECX,ECX
CMP dword ptr [RDI],EDX
SETZ CL
ADD RDI,0x4
ADD EAX,ECX
CMP RDI,RSI
JNZ 0x00101328
RET
LAB_00101340:
XOR EAX,EAX
RET | int func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar3 = 0;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar3 + (uint)(iVar2 == param_3);
} while (param_1 != piVar1... |
7,611 | func0 |
#include <assert.h>
| int func0(int *tuplex, int size, int value) {
int count = 0;
for (int i = 0; i < size; i++) {
if (tuplex[i] == value) {
count++;
}
}
return count;
}
| int main() {
int tuplex1[] = {2, 4, 5, 6, 2, 3, 4, 4, 7};
int tuplex2[] = {2, 4, 7, 7, 7, 3, 4, 4, 7};
assert(func0(tuplex1, 9, 4) == 3);
assert(func0(tuplex1, 9, 2) == 2);
assert(func0(tuplex2, 9, 7) == 4);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 13a8 <func0+0xe8>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 13ab <func0+0xeb>
mov %esi,%ecx
movd %edx,%xmm3
pxor %xmm0,%xmm0
mov %rdi,%rax
shr $0x2,%ecx
pshufd $0x0,%xmm3,%xmm2
shl $0x4,%rcx
add %rdi,%rcx
nopl 0x0(%rax)
movdqu (%rax),%xmm1
add $0x10,%r... | func0:
endbr64
test esi, esi
jle loc_1210
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1213
mov ecx, esi
movd xmm3, edx
pxor xmm0, xmm0
mov rax, rdi
shr ecx, 2
pshufd xmm2, xmm3, 0
shl rcx, 4
add rcx, rdi
nop dword ptr [rax+00h]
loc_1178:
movdqu xmm1, xmmword ptr [rax]
add ... | long long func0(const __m128i *a1, int a2, unsigned int a3)
{
__m128i v3; // xmm0
const __m128i *v4; // rax
__m128i v5; // xmm2
__m128i v6; // xmm1
int v7; // ecx
__m128i v8; // xmm0
long long result; // rax
long long v10; // r9
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101210
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101213
MOV ECX,ESI
MOVD XMM3,EDX
PXOR XMM0,XMM0
MOV RAX,RDI
SHR ECX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RCX,0x4
ADD RCX,RDI
NOP dword ptr [RAX]
LAB_00101178:
MOVDQU XMM1,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM1,XMM2
PSUBD XMM0,XMM1
CMP RCX,... | int func0(int *param_1,uint param_2,int param_3)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
uint uVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
if ((int)param_2 < 1) {
return 0;
}
if (param_2 - 1 < 3) {
uVar6 = 0;
iVar7 = 0;
}
else {
iVar7 = 0... |
7,612 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include<string.h>
| char* func0(const char* text) {
regex_t regex;
int ret;
char* patterns = "ab*?";
ret = regcomp(®ex, patterns, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
ret = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!ret) {
return "Found ... | int main() {
assert(strcmp(func0("msb"), "Not matched!") == 0);
assert(strcmp(func0("a0c"), "Found a match!") == 0);
assert(strcmp(func0("abbc"), "Found a match!") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xdf9(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10d0 <regcomp@plt>
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aAb; "ab*?"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov rdi, rax; p... | const char * func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-5Ch]
regex_t preg; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+68h] [rbp-8h]
v4 = __readfsqword(0x28u);
if ( regcomp(&preg, "ab*?", 1) )
return "Error compiling regex";
v2 = regexec(&preg, a1, 0LL, 0LL, 0);
regfree(&preg);... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010d0
MOV dword p... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_58,"ab*?",1);
if (iVar1 == 0) {
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if (i... |
7,613 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include<string.h>
| char* func0(const char* text) {
regex_t regex;
int ret;
char* patterns = "ab*?";
ret = regcomp(®ex, patterns, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
ret = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!ret) {
return "Found ... | int main() {
assert(strcmp(func0("msb"), "Not matched!") == 0);
assert(strcmp(func0("a0c"), "Found a match!") == 0);
assert(strcmp(func0("abbc"), "Found a match!") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1,%edx
lea 0xe54(%rip),%rsi
callq 10c0 <regcomp@plt>
mov %eax,%edx
lea 0xe1d(%rip),%rax
test %edx,%edx
je 121e <func0+0x55>
mov 0x48(%rsp),... | func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov rdi, rsp
mov edx, 1
lea rsi, aAb; "ab*?"
call _regcomp
mov edx, eax
lea rax, aErrorCompiling; "Error compiling regex"
test edx, edx
jz short loc_... | const char * func0(long long a1)
{
int v1; // edx
const char *result; // rax
int v3; // ebx
_QWORD v4[13]; // [rsp+0h] [rbp-68h] BYREF
v4[9] = __readfsqword(0x28u);
v1 = regcomp(v4, "ab*?", 1LL);
result = "Error compiling regex";
if ( !v1 )
{
v3 = regexec(v4, a1, 0LL, 0LL, 0LL);
regfree(v4);
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102049]
CALL 0x001010d0
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JZ 0x0010123e
LAB_00101227:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr FS:[0x28]
J... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"ab*?",1);
pcVar2 = "Error compiling regex";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x... |
7,614 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include<string.h>
| char* func0(const char* text) {
regex_t regex;
int ret;
char* patterns = "ab*?";
ret = regcomp(®ex, patterns, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
ret = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!ret) {
return "Found ... | int main() {
assert(strcmp(func0("msb"), "Not matched!") == 0);
assert(strcmp(func0("a0c"), "Found a match!") == 0);
assert(strcmp(func0("abbc"), "Found a match!") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd87(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10c0 <regcomp@plt>
mov %eax,%r8d
lea 0xd31(%rip),%rax
test %r8d,%r8d
je 1310 <func0+0x60>
m... | func0:
endbr64
push r12
mov edx, 1
lea rsi, aAb; "ab*?"
push rbp
mov rbp, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov r12, rsp
mov rdi, r12
call _regcomp
mov r8d, eax
lea rax, aErrorCompiling; "Error compiling regex"
test r8d, r8d
j... | const char * func0(long long a1)
{
int v1; // r8d
const char *result; // rax
int v3; // ebp
_QWORD v4[13]; // [rsp+0h] [rbp-68h] BYREF
v4[9] = __readfsqword(0x28u);
v1 = regcomp(v4, "ab*?", 1LL);
result = "Error compiling regex";
if ( !v1 )
{
v3 = regexec(v4, a1, 0LL, 0LL);
regfree(v4);
r... | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
LEA RSI,[0x102049]
PUSH RBP
MOV RBP,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV R12,RSP
MOV RDI,R12
CALL 0x001010d0
MOV R8D,EAX
LEA RAX,[0x102004]
TEST R8D,R8D
JZ 0x00101320
LAB_00101304:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"ab*?",1);
pcVar2 = "Error compiling regex";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x... |
7,615 | func0 | #include <assert.h>
#include <regex.h>
#include <stdio.h>
#include<string.h>
| char* func0(const char* text) {
regex_t regex;
int ret;
char* patterns = "ab*?";
ret = regcomp(®ex, patterns, REG_EXTENDED);
if (ret) {
return "Error compiling regex";
}
ret = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!ret) {
return "Found ... | int main() {
assert(strcmp(func0("msb"), "Not matched!") == 0);
assert(strcmp(func0("a0c"), "Found a match!") == 0);
assert(strcmp(func0("abbc"), "Found a match!") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
lea 0xd87(%rip),%rsi
push %rbp
mov %rdi,%rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%r12
mov %r12,%rdi
callq 10c0 <regcomp@plt>
mov %eax,%r8d
lea 0xd31(%rip),%rax
test %r8d,%r8d
je 1310 <func0+0x60>
m... | func0:
endbr64
push rbp
mov edx, 1; cflags
lea rsi, pattern; "ab*?"
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
mov edx, eax
lea rax, aErrorCompiling; "Error compiling regex"
tes... | const char * func0(char *string)
{
int v1; // edx
const char *result; // rax
int v3; // ebx
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
v1 = regcomp(&_0, "ab*?", 1);
result = "Error compiling regex";
if ( !v1 )
{
v3 = r... | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x102049]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010d0
MOV EDX,EAX
LEA RAX,[0x102004]
TEST EDX,EDX
JZ 0x00101320
LAB_00101301:
MOV RDX,qword ptr [RSP + 0x48]
SUB RDX,qword ptr... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&rStack_68,"ab*?",1);
pcVar2 = "Error compiling regex";
if (iVar1 == 0) {
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x... |
7,616 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int number) {
double total = 0;
total = pow(((number * (number + 1)) / 2.0), 2);
return total;
}
| int main() {
assert(func0(7) == 784);
assert(func0(5) == 225);
assert(func0(15) == 14400);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
pxor %xmm0,%xmm0
movsd %xmm0,-0x8(%rbp)
mov -0x14(%rbp),%eax
add $0x1,%eax
imul -0x14(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd 0xee9(%rip),%xmm1
divsd %xmm1,%xmm0
movsd 0xedd(%rip),%xmm1
callq 1060 <pow@plt>
movq %xmm0,%r... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
pxor xmm0, xmm0
movsd [rbp+var_8], xmm0
mov eax, [rbp+var_14]
add eax, 1
imul eax, [rbp+var_14]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
movsd xmm1, cs:y
divsd xmm0, xmm1
movq rax, xmm0
movsd xmm0, cs:y
movapd ... | long long func0(int a1)
{
return pow((double)(a1 * (a1 + 1)) / 2.0, 2.0);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x8],XMM0
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x14]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr [0x00102060]
DIVSD XMM0,XMM1
MOVQ RAX,XMM0
MOVSD XMM0,qword... | double func0(int param_1)
{
double dVar1;
dVar1 = pow((double)((param_1 + 1) * param_1) / DAT_00102060,DAT_00102060);
return dVar1;
} |
7,617 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int number) {
double total = 0;
total = pow(((number * (number + 1)) / 2.0), 2);
return total;
}
| int main() {
assert(func0(7) == 784);
assert(func0(5) == 225);
assert(func0(15) == 14400);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
lea 0x1(%rdi),%edi
imul %eax,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd 0xec3(%rip),%xmm0
mulsd %xmm0,%xmm0
retq
| func0:
endbr64
lea eax, [rdi+1]
imul eax, edi
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm0
retn | double func0(int a1)
{
return (double)(a1 * (a1 + 1)) * 0.5 * ((double)(a1 * (a1 + 1)) * 0.5);
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
IMUL EAX,EDI
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
double dVar1;
dVar1 = (double)((param_1 + 1) * param_1) * _DAT_00102008;
return dVar1 * dVar1;
} |
7,618 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int number) {
double total = 0;
total = pow(((number * (number + 1)) / 2.0), 2);
return total;
}
| int main() {
assert(func0(7) == 784);
assert(func0(5) == 225);
assert(func0(15) == 14400);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%r8d
lea 0x1(%rdi),%edi
pxor %xmm0,%xmm0
imul %r8d,%edi
cvtsi2sd %edi,%xmm0
mulsd 0xeaa(%rip),%xmm0
mulsd %xmm0,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
lea eax, [rdi+1]
pxor xmm0, xmm0
imul eax, edi
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm0
retn | double func0(int a1)
{
return (double)(a1 * (a1 + 1)) * 0.5 * ((double)(a1 * (a1 + 1)) * 0.5);
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
PXOR XMM0,XMM0
IMUL EAX,EDI
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
double dVar1;
dVar1 = (double)((param_1 + 1) * param_1) * _DAT_00102008;
return dVar1 * dVar1;
} |
7,619 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int number) {
double total = 0;
total = pow(((number * (number + 1)) / 2.0), 2);
return total;
}
| int main() {
assert(func0(7) == 784);
assert(func0(5) == 225);
assert(func0(15) == 14400);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%r8d
lea 0x1(%rdi),%edi
pxor %xmm0,%xmm0
imul %r8d,%edi
cvtsi2sd %edi,%xmm0
mulsd 0xeaa(%rip),%xmm0
mulsd %xmm0,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
lea eax, [rdi+1]
pxor xmm0, xmm0
imul eax, edi
cvtsi2sd xmm0, eax
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm0
retn | double func0(int a1)
{
return (double)(a1 * (a1 + 1)) * 0.5 * ((double)(a1 * (a1 + 1)) * 0.5);
} | func0:
ENDBR64
LEA EAX,[RDI + 0x1]
PXOR XMM0,XMM0
IMUL EAX,EDI
CVTSI2SD XMM0,EAX
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(int param_1)
{
double dVar1;
dVar1 = (double)((param_1 + 1) * param_1) * _DAT_00102008;
return dVar1 * dVar1;
} |
7,620 | func0 |
#include <assert.h>
#include <string.h>
#define MAX_ELEMENTS 100
| int func0(const char *input[], int input_size, const char *output[]) {
int count = 0;
for(int i = 0; i < input_size; i++) {
int exists = 0;
for(int j = 0; j < count; j++) {
if(strcmp(input[i], output[j]) == 0) {
exists = 1;
break;
}... | int main() {
const char *input1[] = {"Python", "Exercises", "Practice", "Solution", "Exercises"};
const char *expected1[] = {"Python", "Exercises", "Practice", "Solution"};
const char *output1[MAX_ELEMENTS];
int count1 = func0(input1, 5, output1);
assert(count1 == 4);
for(int i = 0; i < co... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 1254 <func0+0xcb>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 120d <func0+0x84>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%ra... | 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_10], 0
mov [rbp+var_C], 0
jmp loc_1254
loc_11B3:
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_120D
loc_11C3:
mov eax, [rbp+var_4]
cdq... | long long func0(long long a1, int a2, long long a3)
{
int v3; // eax
unsigned int v6; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
int v8; // [rsp+28h] [rbp-8h]
int j; // [rsp+2Ch] [rbp-4h]
v6 = 0;
for ( i = 0; i < a2; ++i )
{
v8 = 0;
for ( j = 0; j < (int)v6; ++j )
{
if ( !st... | 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 + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101254
LAB_001011b3:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010120d
LAB_00... | int func0(long param_1,int param_2,long param_3)
{
bool bVar1;
int iVar2;
int4 local_18;
int4 local_14;
int4 local_c;
local_18 = 0;
local_14 = 0;
do {
if (param_2 <= local_14) {
return local_18;
}
bVar1 = false;
for (local_c = 0; local_c < local_18; local_c = local_c + 1) {
... |
7,621 | func0 |
#include <assert.h>
#include <string.h>
#define MAX_ELEMENTS 100
| int func0(const char *input[], int input_size, const char *output[]) {
int count = 0;
for(int i = 0; i < input_size; i++) {
int exists = 0;
for(int j = 0; j < count; j++) {
if(strcmp(input[i], output[j]) == 0) {
exists = 1;
break;
}... | int main() {
const char *input1[] = {"Python", "Exercises", "Practice", "Solution", "Exercises"};
const char *expected1[] = {"Python", "Exercises", "Practice", "Solution"};
const char *output1[MAX_ELEMENTS];
int count1 = func0(input1, 5, output1);
assert(count1 == 4);
for(int i = 0; i < co... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %esi,%esi
jle 11c2 <func0+0x39>
mov %rdx,%r15
mov %rdi,%r13
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%rax
mov %rax,(%rsp)
mov $0x0,%r14d
lea 0x8(%rdx),%rax
mov %rax,0x8(%rsp)
jmp ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test esi, esi
jle short loc_11C2
mov r15, rdx
mov r13, rdi
lea eax, [rsi-1]
lea rax, [rdi+rax*8+8]
mov [rsp+48h+var_48], rax
mov r14d, 0
lea rax, [rdx+8]
mov [rsp+48h+var_40], r... | long long func0(_QWORD *a1, int a2, _QWORD *a3)
{
_QWORD *v4; // r13
int v5; // r14d
long long v7; // rbp
_QWORD *v8; // rbx
_QWORD *v9; // [rsp+8h] [rbp-40h]
if ( a2 <= 0 )
{
return 0;
}
else
{
v4 = a1;
v5 = 0;
v9 = a3 + 1;
do
{
if ( v5 <= 0 )
{
LABEL_5:
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST ESI,ESI
JLE 0x001011c2
MOV R15,RDX
MOV R13,RDI
LEA EAX,[RSI + -0x1]
LEA RAX,[RDI + RAX*0x8 + 0x8]
MOV qword ptr [RSP],RAX
MOV R14D,0x0
LEA RAX,[RDX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001011f3
LAB_001011c2:
MOV R14D,0x0
LAB_00... | int func0(int8 *param_1,int param_2,int8 *param_3)
{
int8 *puVar1;
char *__s1;
int iVar2;
int8 *puVar3;
int iVar4;
if (param_2 < 1) {
iVar4 = 0;
}
else {
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar4 = 0;
do {
if (0 < iVar4) {
__s1 = (char *)*param_1;
puVar... |
7,622 | func0 |
#include <assert.h>
#include <string.h>
#define MAX_ELEMENTS 100
| int func0(const char *input[], int input_size, const char *output[]) {
int count = 0;
for(int i = 0; i < input_size; i++) {
int exists = 0;
for(int j = 0; j < count; j++) {
if(strcmp(input[i], output[j]) == 0) {
exists = 1;
break;
}... | int main() {
const char *input1[] = {"Python", "Exercises", "Practice", "Solution", "Exercises"};
const char *expected1[] = {"Python", "Exercises", "Practice", "Solution"};
const char *output1[MAX_ELEMENTS];
int count1 = func0(input1, 5, output1);
assert(count1 == 4);
for(int i = 0; i < co... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %esi,%esi
jle 155f <func0+0xaf>
lea -0x1(%rsi),%eax
mov %rdx,%r14
mov %rdi,%r12
xor %r13d,%r13d
lea 0x8(%rdi,%rax,8),%rax
mov %rax,(%rsp)
lea 0x8(%rdx),%rax
mov %rax,0x8(%rsp)
nopl ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test esi, esi
jle loc_155F
lea eax, [rsi-1]
mov r14, rdx
mov r12, rdi
xor r13d, r13d
lea rax, [rdi+rax*8+8]
mov [rsp+48h+var_48], rax
lea rax, [rdx+8]
mov [rsp+48h+var_40], rax
... | long long func0(long long *a1, int a2, _QWORD *a3)
{
long long *v4; // r12
unsigned int v5; // r13d
long long v6; // rbx
_QWORD *v7; // r15
long long v9; // rax
long long v10; // [rsp+0h] [rbp-48h]
_QWORD *v11; // [rsp+8h] [rbp-40h]
if ( a2 <= 0 )
{
return 0;
}
else
{
v4 = a1;
v5 =... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST ESI,ESI
JLE 0x0010155f
LEA EAX,[RSI + -0x1]
MOV R14,RDX
MOV R12,RDI
XOR R13D,R13D
LEA RAX,[RDI + RAX*0x8 + 0x8]
MOV qword ptr [RSP],RAX
LEA RAX,[RDX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001014f0:
MOV... | int func0(int8 *param_1,int param_2,int8 *param_3)
{
int8 *puVar1;
char *__s1;
int iVar2;
long lVar3;
int iVar4;
int8 *puVar5;
if (param_2 < 1) {
iVar4 = 0;
}
else {
iVar4 = 0;
puVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
__s1 = (char *)*param_1;
if (iVar4 != 0) {
... |
7,623 | func0 |
#include <assert.h>
#include <string.h>
#define MAX_ELEMENTS 100
| int func0(const char *input[], int input_size, const char *output[]) {
int count = 0;
for(int i = 0; i < input_size; i++) {
int exists = 0;
for(int j = 0; j < count; j++) {
if(strcmp(input[i], output[j]) == 0) {
exists = 1;
break;
}... | int main() {
const char *input1[] = {"Python", "Exercises", "Practice", "Solution", "Exercises"};
const char *expected1[] = {"Python", "Exercises", "Practice", "Solution"};
const char *output1[MAX_ELEMENTS];
int count1 = func0(input1, 5, output1);
assert(count1 == 4);
for(int i = 0; i < co... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %esi,%esi
jle 165f <func0+0xaf>
lea -0x1(%rsi),%eax
mov %rdx,%r14
mov %rdi,%r12
xor %r13d,%r13d
lea 0x8(%rdi,%rax,8),%rax
mov %rax,(%rsp)
lea 0x8(%rdx),%rax
mov %rax,0x8(%rsp)
nopl ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
test esi, esi
jle loc_15F9
movsxd rsi, esi
mov r14, rdx
mov r12, rdi
xor r13d, r13d
lea rax, [rdi+rsi*8]
mov [rsp+48h+var_48], rax
xchg ax, ax
loc_1580:
movsxd rax, r13d
mov rbx, [... | long long func0(const char **a1, int a2, const char **a3)
{
const char **v4; // r12
int v5; // r13d
const char *v6; // rbx
const char **v7; // r15
const char **v9; // [rsp+0h] [rbp-48h]
long long v10; // [rsp+8h] [rbp-40h]
if ( a2 <= 0 )
{
return 0;
}
else
{
v4 = a1;
v5 = 0;
v9 =... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
TEST ESI,ESI
JLE 0x001015f9
MOVSXD RSI,ESI
MOV R14,RDX
MOV R12,RDI
XOR R13D,R13D
LEA RAX,[RDI + RSI*0x8]
MOV qword ptr [RSP],RAX
NOP
LAB_00101580:
MOVSXD RAX,R13D
MOV RBX,qword ptr [R12]
MOV qword ptr [RSP + 0x8],RAX
LEA RBP,[R14 + RAX*0x... | int func0(int8 *param_1,int param_2,int8 *param_3)
{
int8 *puVar1;
int iVar2;
char *__s1;
int iVar3;
int8 *puVar4;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar1 = param_1 + param_2;
iVar3 = 0;
do {
__s1 = (char *)*param_1;
puVar4 = param_3;
if (0 < iVar3) {
... |
7,624 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* text) {
size_t length = strlen(text);
size_t new_length = 0;
char* result = (char*)malloc(sizeof(char) * (length * 2));
int i, j = 0;
for (i = 0; i < length; i++) {
if (i > 0 && isupper(text[i]) && (islower(text[i - 1]) || isdigit(text[i - 1]))) {
... | int main() {
char* result;
result = func0("GoogleAssistant");
assert(strcmp(result, "google_assistant") == 0);
free(result);
result = func0("ChromeCast");
assert(strcmp(result, "chrome_cast") == 0);
free(result);
result = func0("QuadCore");
assert(strcmp(result, "quad_... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10c0 <strlen@plt>
mov %rax,-0x18(%rbp)
movq $0x0,-0x10(%rbp)
mov -0x18(%rbp),%rax
add %rax,%rax
mov %rax,%rdi
callq 1100 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_18], rax
mov [rbp+var_10], 0
mov rax, [rbp+var_18]
add rax, rax
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_1C], 0
... | _BYTE * func0(const char *a1)
{
char v1; // cl
int v2; // eax
char v3; // cl
int v4; // eax
int i; // [rsp+10h] [rbp-20h]
int v7; // [rsp+14h] [rbp-1Ch]
size_t v8; // [rsp+18h] [rbp-18h]
_BYTE *v9; // [rsp+28h] [rbp-8h]
v8 = strlen(a1);
v9 = malloc(2 * v8);
v7 = 0;
for ( i = 0; i < v8; ++i )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010c0
MOV qword ptr [RBP + -0x18],RAX
MOV qword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RAX
MOV RDI,RAX
CALL 0x00101100
MOV qword ptr [RBP + -0x8],RAX
MOV dword pt... | void * func0(char *param_1)
{
int iVar1;
size_t sVar2;
void *pvVar3;
ushort **ppuVar4;
int local_28;
int local_24;
sVar2 = strlen(param_1);
pvVar3 = malloc(sVar2 * 2);
local_24 = 0;
local_28 = 0;
do {
if (sVar2 <= (ulong)(long)local_28) {
*(int *)((long)pvVar3 + (long)local_24) = 0;
... |
7,625 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* text) {
size_t length = strlen(text);
size_t new_length = 0;
char* result = (char*)malloc(sizeof(char) * (length * 2));
int i, j = 0;
for (i = 0; i < length; i++) {
if (i > 0 && isupper(text[i]) && (islower(text[i - 1]) || isdigit(text[i - 1]))) {
... | int main() {
char* result;
result = func0("GoogleAssistant");
assert(strcmp(result, "google_assistant") == 0);
free(result);
result = func0("ChromeCast");
assert(strcmp(result, "chrome_cast") == 0);
free(result);
result = func0("QuadCore");
assert(strcmp(result, "quad_... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r12
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r13
lea 0x0(%r13,%r13,1),%rdi
callq 10b0 <malloc@plt>
mov %rax,%r14
test %r13,%r13
... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
call _strlen
mov r14, rax
lea rdi, [rax+rax]
call _malloc
mov r13, rax
test r14, r14
jz loc_131E
mov r12d, 0
mov ebp, 0
jmp short loc_12C1
loc_1248:
test ax, ... | long long func0(char *a1)
{
long long v2; // r14
long long v3; // r13
int v4; // r12d
int v5; // ebp
long long *v6; // rax
long long v7; // rdx
long long v8; // r15
int v10; // [rsp+Ch] [rbp-3Ch]
v2 = strlen();
v3 = malloc(2 * v2);
if ( v2 )
{
v4 = 0;
v5 = 0;
do
{
if ( v5... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
CALL 0x001010c0
MOV R14,RAX
LEA RDI,[RAX + RAX*0x1]
CALL 0x001010f0
MOV R13,RAX
TEST R14,R14
JZ 0x0010131e
MOV R12D,0x0
MOV EBP,0x0
JMP 0x001012c1
LAB_00101248:
TEST AX,AX
JZ 0x00101296
MOVSX RAX,byte ptr [RBX + -0x1]
TEST byt... | void * func0(char *param_1)
{
char cVar1;
ushort *puVar2;
int iVar3;
size_t sVar4;
void *pvVar5;
ushort **ppuVar6;
__int32_t **pp_Var7;
int iVar8;
int iVar9;
sVar4 = strlen(param_1);
pvVar5 = malloc(sVar4 * 2);
if (sVar4 == 0) {
iVar9 = 0;
}
else {
iVar9 = 0;
iVar8 = 0;
d... |
7,626 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* text) {
size_t length = strlen(text);
size_t new_length = 0;
char* result = (char*)malloc(sizeof(char) * (length * 2));
int i, j = 0;
for (i = 0; i < length; i++) {
if (i > 0 && isupper(text[i]) && (islower(text[i - 1]) || isdigit(text[i - 1]))) {
... | int main() {
char* result;
result = func0("GoogleAssistant");
assert(strcmp(result, "google_assistant") == 0);
free(result);
result = func0("ChromeCast");
assert(strcmp(result, "chrome_cast") == 0);
free(result);
result = func0("QuadCore");
assert(strcmp(result, "quad_... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
callq 10b0 <strlen@plt>
lea (%rax,%rax,1),%rdi
mov %rax,0x10(%rsp)
mov %rax,%rbx
callq 10d0 <malloc@plt>
mov %rax,%r13
test %rbx,%rbx
je 1410 <func0+0x120>
callq 10e0 <__ctype_t... | func0:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 28h
call _strlen
lea rdi, [rax+rax]
mov [rsp+58h+var_48], rax
mov rbx, rax
call _malloc
mov r14, rax
test rbx, rbx
jz loc_1428
call ___ctype_tolower_loc
xor ebx, ebx
... | long long func0(long long a1)
{
long long v2; // rax
long long v3; // r14
long long v4; // rbx
int v5; // r12d
long long *v6; // rax
int v7; // edx
long long v8; // rsi
long long v9; // rax
_BYTE *v10; // r9
__int16 v11; // di
char v12; // bp
_BYTE *v13; // r15
_BYTE *v14; // r12
long long ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
CALL 0x001010c0
LEA RDI,[RAX + RAX*0x1]
MOV qword ptr [RSP + 0x10],RAX
MOV RBX,RAX
CALL 0x001010f0
MOV R14,RAX
TEST RBX,RBX
JZ 0x00101428
CALL 0x00101100
XOR EBX,EBX
XOR R12D,R12D
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0... | int1 * func0(char *param_1)
{
int iVar1;
char cVar2;
__int32_t *p_Var3;
ushort *puVar4;
size_t sVar5;
int1 *puVar6;
__int32_t **pp_Var7;
ushort **ppuVar8;
long lVar9;
size_t sVar10;
int iVar11;
int1 *puVar12;
sVar5 = strlen(param_1);
puVar6 = (int1 *)malloc(sVar5 * 2);
puVar12 = puVar6... |
7,627 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* text) {
size_t length = strlen(text);
size_t new_length = 0;
char* result = (char*)malloc(sizeof(char) * (length * 2));
int i, j = 0;
for (i = 0; i < length; i++) {
if (i > 0 && isupper(text[i]) && (islower(text[i - 1]) || isdigit(text[i - 1]))) {
... | int main() {
char* result;
result = func0("GoogleAssistant");
assert(strcmp(result, "google_assistant") == 0);
free(result);
result = func0("ChromeCast");
assert(strcmp(result, "chrome_cast") == 0);
free(result);
result = func0("QuadCore");
assert(strcmp(result, "quad_... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
callq 10b0 <strlen@plt>
lea (%rax,%rax,1),%rdi
mov %rax,0x10(%rsp)
mov %rax,%rbx
callq 10d0 <malloc@plt>
mov %rax,%r13
test %rbx,%rbx
je 1410 <func0+0x120>
callq 10e0 <__ctype_t... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
call _strlen
lea rdi, [rax+rax]; size
mov [rsp+58h+var_48], rax
mov rbx, rax
call _malloc
mov r14, rax
test rbx, rbx
jz loc_1418
call ___ctype_tolower_loc
xor ebx... | _BYTE * func0(const char *a1)
{
_BYTE *v2; // rax
_BYTE *v3; // r14
long long v4; // rbx
int v5; // r15d
char v6; // bp
int v7; // r13d
_BYTE *v8; // rdx
long long v9; // rax
const unsigned __int16 **v10; // rax
const unsigned __int16 *v11; // rdi
unsigned __int16 v12; // r8
_BYTE *v13; // r15
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
CALL 0x001010c0
LEA RDI,[RAX + RAX*0x1]
MOV qword ptr [RSP + 0x10],RAX
MOV RBX,RAX
CALL 0x001010f0
MOV R14,RAX
TEST RBX,RBX
JZ 0x00101418
CALL 0x00101100
XOR EBX,EBX
XOR R15D,R15D
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0... | int * func0(char *param_1)
{
int iVar1;
char cVar2;
__int32_t *p_Var3;
ushort *puVar4;
size_t sVar5;
int *puVar6;
__int32_t **pp_Var7;
ushort **ppuVar8;
size_t sVar9;
int iVar10;
int *puVar11;
sVar5 = strlen(param_1);
puVar6 = (int *)malloc(sVar5 * 2);
puVar11 = puVar6;
if (sVar5 != 0)... |
7,628 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m == 0 || n == 0) {
return 1;
}
return func0(m - 1, n) + func0(m - 1, n - 1) + func0(m, n - 1);
}
| int main() {
assert(func0(3, 4) == 129);
assert(func0(3, 3) == 63);
assert(func0(4, 5) == 681);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
cmpl $0x0,-0x18(%rbp)
je 1168 <func0+0x1f>
cmpl $0x0,-0x14(%rbp)
jne 116f <func0+0x26>
mov $0x1,%eax
jmp 11ae <func0+0x65>
mov -0x18(%rbp),%eax
lea -0x1(%rax),%edx
mov -0x1... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
cmp [rbp+var_18], 0
jz short loc_1168
cmp [rbp+var_14], 0
jnz short loc_116F
loc_1168:
mov eax, 1
jmp short loc_11AE
loc_116F:
mov eax, [rbp+var_18]
lea edx, [rax... | long long func0(unsigned int a1, unsigned int a2)
{
int v3; // ebx
int v4; // ebx
if ( !a2 || !a1 )
return 1LL;
v3 = func0(a2 - 1, a1);
v4 = func0(a2 - 1, a1 - 1) + v3;
return v4 + (unsigned int)func0(a2, a1 - 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
CMP dword ptr [RBP + -0x18],0x0
JZ 0x00101168
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x0010116f
LAB_00101168:
MOV EAX,0x1
JMP 0x001011ae
LAB_0010116f:
MOV EAX,dword ptr [RBP + -0x18]
LEA EDX,[RAX + -0x... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
if ((param_2 == 0) || (param_1 == 0)) {
iVar3 = 1;
}
else {
iVar1 = func0(param_2 + -1,param_1);
iVar2 = func0(param_2 + -1,param_1 + -1);
iVar3 = func0(param_2,param_1 + -1);
iVar3 = iVar3 + iVar1 + iVar2;
}
r... |
7,629 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m == 0 || n == 0) {
return 1;
}
return func0(m - 1, n) + func0(m - 1, n - 1) + func0(m, n - 1);
}
| int main() {
assert(func0(3, 4) == 129);
assert(func0(3, 3) == 63);
assert(func0(4, 5) == 681);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
je 11a0 <func0+0x57>
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebx
mov %esi,%ebp
mov $0x1,%eax
test %edi,%edi
je 1195 <func0+0x4c>
lea -0x1(%rsi),%r13d
mov %edi,%esi
mov %r13d,%edi
callq 1149 <func0>
mov %eax,%r12d
sub $... | func0:
endbr64
test esi, esi
jz short loc_11A0
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebx, edi
mov ebp, esi
mov eax, 1
test edi, edi
jz short loc_1195
lea r13d, [rsi-1]
mov esi, edi
mov edi, r13d
call func0
mov r12d, eax
sub ebx, 1
mov e... | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
int v3; // r12d
int v4; // r12d
if ( !a2 )
return 1LL;
result = 1LL;
if ( a1 )
{
v3 = func0(a2 - 1, a1);
v4 = func0(a2 - 1, a1 - 1) + v3;
return v4 + (unsigned int)func0(a2, a1 - 1);
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JZ 0x001011a0
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
MOV EBP,ESI
MOV EAX,0x1
TEST EDI,EDI
JZ 0x00101195
LEA R13D,[RSI + -0x1]
MOV ESI,EDI
MOV EDI,R13D
CALL 0x00101149
MOV R12D,EAX
SUB EBX,0x1
MOV ESI,EBX
MOV EDI,R13D
CALL 0x00101149
ADD R12D,EAX
MOV ESI,EBX
MOV EDI,EBP
C... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
if (param_2 != 0) {
iVar3 = 1;
if (param_1 != 0) {
iVar1 = func0(param_2 + -1,param_1);
iVar2 = func0(param_2 + -1,param_1 + -1);
iVar3 = func0(param_2,param_1 + -1);
iVar3 = iVar3 + iVar1 + iVar2;
}
... |
7,630 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m == 0 || n == 0) {
return 1;
}
return func0(m - 1, n) + func0(m - 1, n - 1) + func0(m, n - 1);
}
| int main() {
assert(func0(3, 4) == 129);
assert(func0(3, 3) == 63);
assert(func0(4, 5) == 681);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
je 1278 <func0+0x78>
push %r15
mov $0x1,%eax
push %r14
xor %r14d,%r14d
push %r13
push %r12
mov %esi,%r12d
push %rbp
mov %edi,%ebp
push %rbx
sub $0x8,%rsp
test %edi,%edi
je 1264 <func0+0x64>
lea -0x1(%r12),%r15d
mov %ebp,%esi
lea -0x1(%rbp),%r... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_4C], edi
mov [rsp+98h+var_48], esi
test edi, edi
jz loc_1FF1
mov [rsp+98h+var_3C], 0
test esi, esi
jz loc_1FF1
loc_1232:
mov eax, [rsp+98h+var_48]
sub eax, 1
mov ... | long long func0(int a1, int a2)
{
unsigned int v2; // ebx
unsigned int v3; // r13d
int v4; // ebx
int i; // r15d
long long v6; // rsi
unsigned int v7; // r14d
int v8; // ebp
int v9; // r15d
unsigned int v10; // r12d
int v11; // ebp
long long v12; // rsi
unsigned int v13; // r14d
int v14; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV dword ptr [RSP + 0x4c],EDI
MOV dword ptr [RSP + 0x50],ESI
TEST EDI,EDI
JZ 0x00101ff1
MOV dword ptr [RSP + 0x5c],0x0
TEST ESI,ESI
JZ 0x00101ff1
LAB_00101232:
MOV EAX,dword ptr [RSP + 0x50]
SUB EAX,0x1
MOV dword ptr [RSP + 0x34],EAX
SET... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
bool bVar11;
int local_98;
int local_94;
int local_90;
int local_8c;
int local_88;
int local_84;
int local_80;
int local_7c;
int lo... |
7,631 | func0 |
#include <assert.h>
| int func0(int n, int m) {
if (m == 0 || n == 0) {
return 1;
}
return func0(m - 1, n) + func0(m - 1, n - 1) + func0(m, n - 1);
}
| int main() {
assert(func0(3, 4) == 129);
assert(func0(3, 3) == 63);
assert(func0(4, 5) == 681);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
je 1278 <func0+0x78>
push %r15
mov $0x1,%eax
push %r14
xor %r14d,%r14d
push %r13
push %r12
mov %esi,%r12d
push %rbp
mov %edi,%ebp
push %rbx
sub $0x8,%rsp
test %edi,%edi
je 1264 <func0+0x64>
lea -0x1(%r12),%r15d
mov %ebp,%esi
lea -0x1(%rbp),%r... | func0:
endbr64
test esi, esi
jz loc_1D9F
push r15
mov ecx, edi
mov eax, 1
push r14
push r13
push r12
xor r12d, r12d
push rbp
push rbx
sub rsp, 48h
test edi, edi
jz loc_1D90
lea eax, [rcx-1]
mov r9d, esi
mov [rsp+78h+var_44], r12d
mov [rsp+78h+var_48], es... | long long func0(unsigned int a1, unsigned int a2)
{
unsigned int v2; // ecx
long long result; // rax
unsigned int v4; // eax
unsigned int v5; // r14d
unsigned int v6; // r9d
unsigned int v7; // esi
unsigned int v8; // r9d
unsigned int v9; // r14d
unsigned int v10; // ebp
unsigned int v11; // r8d
... | func0:
ENDBR64
TEST ESI,ESI
JZ 0x00101d9f
PUSH R15
MOV ECX,EDI
MOV EAX,0x1
PUSH R14
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
SUB RSP,0x48
TEST EDI,EDI
JZ 0x00101d90
LEA EAX,[RCX + -0x1]
MOV R9D,ESI
MOV dword ptr [RSP + 0x34],R12D
MOV dword ptr [RSP + 0x30],ESI
MOV R14D,EAX
SUB R9D,0x1
JZ 0x00101d7d
LAB_0010124... | int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int local_78;
int local_6c;
int local_68;
int local_5c;
int local_58;
int local_4c;... |
7,632 | func0 |
#include <assert.h>
| int func0(int number) {
int total = 0;
total = (number * (number + 1) * (2 * number + 1)) / 6;
return total;
}
| int main() {
assert(func0(6) == 91);
assert(func0(7) == 140);
assert(func0(12) == 650);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x14(%rbp),%eax
add $0x1,%eax
imul -0x14(%rbp),%eax
mov -0x14(%rbp),%edx
add %edx,%edx
add $0x1,%edx
imul %edx,%eax
movslq %eax,%rdx
imul $0x2aaaaaab,%rdx,%rdx
shr $0x20,%rdx
sar $0x1f,%eax
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
mov eax, [rbp+var_14]
add eax, 1
imul eax, [rbp+var_14]
mov edx, [rbp+var_14]
add edx, edx
add edx, 1
imul eax, edx
movsxd rdx, eax
imul rdx, 2AAAAAABh
mov rcx, rdx
shr rcx, 20h
cdq
mov ... | long long func0(int a1)
{
return (unsigned int)((2 * a1 + 1) * a1 * (a1 + 1) / 6);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x14]
ADD EDX,EDX
ADD EDX,0x1
IMUL EAX,EDX
MOVSXD RDX,EAX
IMUL RDX,RDX,0x2aaaaaab
MOV RCX,RDX
SHR RCX,0x20
CDQ
MOV EAX... | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1)) / 6;
} |
7,633 | func0 |
#include <assert.h>
| int func0(int number) {
int total = 0;
total = (number * (number + 1) * (2 * number + 1)) / 6;
return total;
}
| int main() {
assert(func0(6) == 91);
assert(func0(7) == 140);
assert(func0(12) == 650);
return 0;
}
| O1 | c | func0:
endbr64
lea 0x1(%rdi),%edx
imul %edi,%edx
lea 0x1(%rdi,%rdi,1),%eax
imul %eax,%edx
movslq %edx,%rax
imul $0x2aaaaaab,%rax,%rax
shr $0x20,%rax
sar $0x1f,%edx
sub %edx,%eax
retq
| func0:
endbr64
lea edx, [rdi+1]
imul edx, edi
lea eax, [rdi+rdi+1]
imul edx, eax
movsxd rax, edx
imul rax, 2AAAAAABh
shr rax, 20h
sar edx, 1Fh
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)((2 * a1 + 1) * a1 * (a1 + 1) / 6);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
IMUL EDX,EDI
LEA EAX,[RDI + RDI*0x1 + 0x1]
IMUL EDX,EAX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SAR EDX,0x1f
SUB EAX,EDX
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1)) / 6;
} |
7,634 | func0 |
#include <assert.h>
| int func0(int number) {
int total = 0;
total = (number * (number + 1) * (2 * number + 1)) / 6;
return total;
}
| int main() {
assert(func0(6) == 91);
assert(func0(7) == 140);
assert(func0(12) == 650);
return 0;
}
| O2 | c | func0:
endbr64
lea 0x1(%rdi),%edx
lea 0x1(%rdi,%rdi,1),%eax
imul %edi,%edx
imul %eax,%edx
movslq %edx,%rax
sar $0x1f,%edx
imul $0x2aaaaaab,%rax,%rax
shr $0x20,%rax
sub %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
lea edx, [rdi+1]
lea eax, [rdi+rdi+1]
imul edx, edi
imul edx, eax
movsxd rax, edx
sar edx, 1Fh
imul rax, 2AAAAAABh
shr rax, 20h
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)((2 * a1 + 1) * a1 * (a1 + 1) / 6);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
LEA EAX,[RDI + RDI*0x1 + 0x1]
IMUL EDX,EDI
IMUL EDX,EAX
MOVSXD RAX,EDX
SAR EDX,0x1f
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SUB EAX,EDX
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1)) / 6;
} |
7,635 | func0 |
#include <assert.h>
| int func0(int number) {
int total = 0;
total = (number * (number + 1) * (2 * number + 1)) / 6;
return total;
}
| int main() {
assert(func0(6) == 91);
assert(func0(7) == 140);
assert(func0(12) == 650);
return 0;
}
| O3 | c | func0:
endbr64
lea 0x1(%rdi),%edx
lea 0x1(%rdi,%rdi,1),%eax
imul %edi,%edx
imul %eax,%edx
movslq %edx,%rax
sar $0x1f,%edx
imul $0x2aaaaaab,%rax,%rax
shr $0x20,%rax
sub %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
lea edx, [rdi+1]
lea eax, [rdi+rdi+1]
imul edx, edi
imul edx, eax
movsxd rax, edx
sar edx, 1Fh
imul rax, 2AAAAAABh
shr rax, 20h
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)((2 * a1 + 1) * a1 * (a1 + 1) / 6);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
LEA EAX,[RDI + RDI*0x1 + 0x1]
IMUL EDX,EDI
IMUL EDX,EAX
MOVSXD RAX,EDX
SAR EDX,0x1f
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SUB EAX,EDX
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1)) / 6;
} |
7,636 | func0 | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} pair;
| pair* func0(pair test_list[], int test_list_size, int ord_list[], int ord_list_size) {
pair *res = (pair*)malloc(ord_list_size * sizeof(pair));
int i, j;
for(i = 0; i < ord_list_size; i++) {
for(j = 0; j < test_list_size; j++) {
if (ord_list[i] == test_list[j].key) {
... | int main() {
pair test_list1[] = {{4, 3}, {1, 9}, {2, 10}, {3, 2}};
int ord_list1[] = {1, 4, 2, 3};
pair *result1 = func0(test_list1, 4, ord_list1, 4);
assert((result1[0].key == 1 && result1[0].value == 9) &&
(result1[1].key == 4 && result1[1].value == 3) &&
(result1[2].key =... | 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 -0x20(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1090 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 1272 <func0+0xe9>
mo... | 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_20]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_10], 0
jmp loc_1272
loc_... | _DWORD * func0(long long a1, int a2, long long a3, int a4)
{
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+24h] [rbp-Ch]
_DWORD *v9; // [rsp+28h] [rbp-8h]
v9 = malloc(8LL * a4);
for ( i = 0; i < a4; ++i )
{
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a3) == *(_DWORD *)(8LL * j + a1... | 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 + -0x20]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101090
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x10],0x0
JMP... | void * func0(long param_1,int param_2,long param_3,int param_4)
{
void *pvVar1;
int local_18;
int local_14;
pvVar1 = malloc((long)param_4 << 3);
local_18 = 0;
do {
if (param_4 <= local_18) {
return pvVar1;
}
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
if (*(... |
7,637 | func0 | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} pair;
| pair* func0(pair test_list[], int test_list_size, int ord_list[], int ord_list_size) {
pair *res = (pair*)malloc(ord_list_size * sizeof(pair));
int i, j;
for(i = 0; i < ord_list_size; i++) {
for(j = 0; j < test_list_size; j++) {
if (ord_list[i] == test_list[j].key) {
... | int main() {
pair test_list1[] = {{4, 3}, {1, 9}, {2, 10}, {3, 2}};
int ord_list1[] = {1, 4, 2, 3};
pair *result1 = func0(test_list1, 4, ord_list1, 4);
assert((result1[0].key == 1 && result1[0].value == 9) &&
(result1[1].key == 4 && result1[1].value == 3) &&
(result1[2].key =... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r12
mov %esi,%ebx
mov %rdx,%rbp
mov %ecx,%r13d
movslq %ecx,%rdi
shl $0x3,%rdi
callq 1090 <malloc@plt>
test %r13d,%r13d
jle 11ff <func0+0x76>
lea -0x1(%r13),%r10d
mov %r12,%r11
lea -0x1(%rbx),%edx
lea ... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov ebx, esi
mov r12, rdx
mov r13d, ecx
movsxd rdi, ecx
shl rdi, 3
call _malloc
test r13d, r13d
jle short loc_11F7
mov r10d, r13d
lea edx, [rbx-1]
lea r8, [rbp+rdx*8+8]
mov r9d, 0
jm... | long long func0(_DWORD *a1, int a2, long long a3, int a4)
{
long long result; // rax
long long v7; // r9
_DWORD *v8; // rdx
result = malloc(8LL * a4);
if ( a4 > 0 )
{
v7 = 0LL;
do
{
if ( a2 > 0 )
{
v8 = a1;
while ( *(_DWORD *)(a3 + 4 * v7) != *v8 )
{
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV EBX,ESI
MOV R12,RDX
MOV R13D,ECX
MOVSXD RDI,ECX
SHL RDI,0x3
CALL 0x00101090
TEST R13D,R13D
JLE 0x001011f7
MOV R10D,R13D
LEA EDX,[RBX + -0x1]
LEA R8,[RBP + RDX*0x8 + 0x8]
MOV R9D,0x0
JMP 0x001011db
LAB_001011c6:
MOV dword ptr [RAX + R9*0x8],E... | void func0(int *param_1,int param_2,long param_3,uint param_4)
{
void *pvVar1;
int *piVar2;
ulong uVar3;
pvVar1 = malloc((long)(int)param_4 << 3);
if (0 < (int)param_4) {
uVar3 = 0;
do {
if (0 < param_2) {
piVar2 = param_1;
do {
if (*(int *)(param_3 + uVar3 * 4) == ... |
7,638 | func0 | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} pair;
| pair* func0(pair test_list[], int test_list_size, int ord_list[], int ord_list_size) {
pair *res = (pair*)malloc(ord_list_size * sizeof(pair));
int i, j;
for(i = 0; i < ord_list_size; i++) {
for(j = 0; j < test_list_size; j++) {
if (ord_list[i] == test_list[j].key) {
... | int main() {
pair test_list1[] = {{4, 3}, {1, 9}, {2, 10}, {3, 2}};
int ord_list1[] = {1, 4, 2, 3};
pair *result1 = func0(test_list1, 4, ord_list1, 4);
assert((result1[0].key == 1 && result1[0].value == 9) &&
(result1[1].key == 4 && result1[1].value == 3) &&
(result1[2].key =... | O2 | c | func0:
endbr64
push %r13
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
movslq %ecx,%rdi
push %rbx
mov %rdi,%r13
shl $0x3,%rdi
mov %esi,%ebx
sub $0x8,%rsp
callq 1090 <malloc@plt>
test %r13d,%r13d
jle 14c0 <func0+0x80>
lea -0x1(%rbx),%ecx
lea -0x1(%r13),%edx
xor %r9d,%r9d
lea ... | func0:
endbr64
push r14
push r13
movsxd r13, ecx
push r12
mov r12, rdx
push rbp
mov rbp, rdi
lea rdi, ds:0[r13*8]
push rbx
mov ebx, esi
call _malloc
test r13d, r13d
jle short loc_14A8
lea edx, [rbx-1]
xor edi, edi
lea rsi, [rbp+rdx*8+8]
nop dword ptr [rax+rax+00... | long long func0(_DWORD *a1, int a2, long long a3, int a4)
{
long long v4; // r13
long long result; // rax
long long i; // rdi
int v9; // ecx
_DWORD *v10; // rdx
int v11; // edx
v4 = a4;
result = malloc(8LL * a4);
if ( (int)v4 > 0 )
{
for ( i = 0LL; i != v4; ++i )
{
if ( a2 > 0 )
... | func0:
ENDBR64
PUSH R14
PUSH R13
MOVSXD R13,ECX
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
LEA RDI,[R13*0x8]
PUSH RBX
MOV EBX,ESI
CALL 0x00101090
TEST R13D,R13D
JLE 0x001014a8
LEA EDX,[RBX + -0x1]
XOR EDI,EDI
LEA RSI,[RBP + RDX*0x8 + 0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101478:
TEST EBX,EBX
JLE 0x0010149f
MOV ECX,dw... | void func0(int *param_1,int param_2,long param_3,int param_4)
{
int iVar1;
int iVar2;
void *pvVar3;
int *piVar4;
long lVar5;
pvVar3 = malloc((long)param_4 * 8);
if (0 < param_4) {
lVar5 = 0;
do {
if (0 < param_2) {
iVar1 = *(int *)(param_3 + lVar5 * 4);
piVar4 = param_1;
... |
7,639 | func0 | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int key;
int value;
} pair;
| pair* func0(pair test_list[], int test_list_size, int ord_list[], int ord_list_size) {
pair *res = (pair*)malloc(ord_list_size * sizeof(pair));
int i, j;
for(i = 0; i < ord_list_size; i++) {
for(j = 0; j < test_list_size; j++) {
if (ord_list[i] == test_list[j].key) {
... | int main() {
pair test_list1[] = {{4, 3}, {1, 9}, {2, 10}, {3, 2}};
int ord_list1[] = {1, 4, 2, 3};
pair *result1 = func0(test_list1, 4, ord_list1, 4);
assert((result1[0].key == 1 && result1[0].value == 9) &&
(result1[1].key == 4 && result1[1].value == 3) &&
(result1[2].key =... | O3 | c | func0:
endbr64
push %r13
push %r12
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
movslq %ecx,%rdi
push %rbx
mov %rdi,%r13
shl $0x3,%rdi
mov %esi,%ebx
sub $0x8,%rsp
callq 1090 <malloc@plt>
test %r13d,%r13d
jle 1440 <func0+0x80>
lea -0x1(%rbx),%ecx
lea -0x1(%r13),%edx
xor %r9d,%r9d
lea ... | func0:
endbr64
push r14
push r13
movsxd r13, esi
push r12
movsxd r12, ecx
push rbp
mov rbp, rdx
push rbx
mov rbx, rdi
lea rdi, ds:0[r12*8]; size
call _malloc
xor edi, edi
test r12d, r12d
jle short loc_13FA
loc_13EC:
test r13d, r13d
jg short loc_1403
add rdi, 1
cmp ... | _QWORD * func0(_DWORD *a1, int a2, long long a3, int a4)
{
long long v4; // r12
_QWORD *result; // rax
long long v8; // rdi
_DWORD *v9; // rsi
unsigned int v10; // ecx
_DWORD *v11; // rdx
v4 = a4;
result = malloc(8LL * a4);
v8 = 0LL;
if ( (int)v4 > 0 )
{
while ( a2 <= 0 )
{
if ( v4 ... | func0:
ENDBR64
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOVSXD R12,ECX
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RDI
LEA RDI,[R12*0x8]
CALL 0x00101090
XOR EDI,EDI
TEST R12D,R12D
JLE 0x001013fa
LAB_001013ec:
TEST R13D,R13D
JG 0x00101403
ADD RDI,0x1
CMP R12,RDI
JNZ 0x001013ec
LAB_001013fa:
POP RBX
POP RBP
POP R12
POP R13
PO... | void func0(int *param_1,int param_2,long param_3,int param_4)
{
int iVar1;
void *pvVar2;
int *piVar3;
long lVar4;
long lVar5;
lVar5 = (long)param_4;
pvVar2 = malloc(lVar5 * 8);
lVar4 = 0;
if (0 < param_4) {
do {
if (0 < param_2) {
LAB_00101410:
do {
iVar1 = *(int *)(par... |
7,640 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <limits.h>
| char func0(const char *str1) {
int frequency[256] = {0}; // Assuming ASCII charset
int max_freq = 0;
char max_char = '\0';
int len = strlen(str1);
for (int i = 0; i < len; i++) {
frequency[(unsigned char)str1[i]]++;
if (frequency[(unsigned char)str1[i]] > max_freq) {
... | int main() {
assert(func0("hello world") == 'l');
assert(func0("hello ") == 'l');
assert(func0("python pr") == 'p');
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x430,%rsp
mov %rdi,-0x428(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x410(%rbp),%rdx
mov $0x0,%eax
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x41c(%rbp)
movb $0x0,-0x41d(%rbp)
mov -0x428(%rbp)... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 430h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_410]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mov [rbp+var_41C], 0
mov [rbp+var_41D], 0
mov rax, [rbp+s]
mov rdi, rax; ... | long long func0(const char *a1)
{
unsigned __int8 v2; // [rsp+13h] [rbp-41Dh]
int v3; // [rsp+14h] [rbp-41Ch]
int i; // [rsp+18h] [rbp-418h]
int v5; // [rsp+1Ch] [rbp-414h]
_DWORD v6[258]; // [rsp+20h] [rbp-410h] BYREF
unsigned long long v7; // [rsp+428h] [rbp-8h]
v7 = __readfsqword(0x28u);
memset(v6,... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x430
MOV qword ptr [RBP + -0x428],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x410]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x41c],0x0
MOV byte ptr [RBP + -0x41d],0x0
MOV RAX,qword ptr [RBP + -0... | char func0(char *param_1)
{
size_t sVar1;
long lVar2;
int *piVar3;
long in_FS_OFFSET;
char local_425;
int local_424;
int local_420;
int local_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = local_418;
for (lVar2 = 0x80; lVar2 != 0; lVar2 = lVar2 + -1) {
piVa... |
7,641 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <limits.h>
| char func0(const char *str1) {
int frequency[256] = {0}; // Assuming ASCII charset
int max_freq = 0;
char max_char = '\0';
int len = strlen(str1);
for (int i = 0; i < len; i++) {
frequency[(unsigned char)str1[i]]++;
if (frequency[(unsigned char)str1[i]] > max_freq) {
... | int main() {
assert(func0("hello world") == 'l');
assert(func0("hello ") == 'l');
assert(func0("python pr") == 'p');
return 0;
}
| O1 | c | func0:
endbr64
sub $0x418,%rsp
mov %rdi,%rsi
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x80,%ecx
rep stos %rax,%es:(%rdi)
mov $0xffffffffffffffff,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
not %rcx
sub $0x1,%rcx
test %ecx,%ecx
jle 11e8 <func0+0x7f>
m... | func0:
endbr64
push rbx
sub rsp, 410h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 80h
rep stosq
mov rdi, rbx
call _strlen
test eax, eax
jle short loc_11FE
mov rdx, rbx
lea eax, [rax-1]
lea r8, [rbx+rax+1]
mov r9d... | long long func0(unsigned __int8 *a1)
{
int v1; // eax
unsigned __int8 *v2; // rdx
long long v3; // r8
unsigned int v4; // r9d
int v5; // edi
unsigned int v6; // esi
int v7; // eax
_DWORD v9[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v10; // [rsp+408h] [rbp-10h]
v10 = __readfsqword(0x28u... | func0:
ENDBR64
PUSH RBX
SUB RSP,0x410
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x80
STOSQ.REP RDI
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JLE 0x001011fe
MOV RDX,RBX
LEA EAX,[RAX + -0x1]
LEA R8,[RBX + RAX*0x1 + 0x1]
MOV R9D,0x0
MOV EDI,0x0
JMP 0x001011e3
LA... | byte func0(byte *param_1)
{
byte *pbVar1;
byte bVar2;
int iVar3;
size_t sVar4;
long lVar5;
int iVar6;
int *piVar7;
byte bVar8;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar7 = aiStack_418;
for (lVar5 = 0x80; lVar5 != 0; lVar5 = ... |
7,642 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <limits.h>
| char func0(const char *str1) {
int frequency[256] = {0}; // Assuming ASCII charset
int max_freq = 0;
char max_char = '\0';
int len = strlen(str1);
for (int i = 0; i < len; i++) {
frequency[(unsigned char)str1[i]]++;
if (frequency[(unsigned char)str1[i]] > max_freq) {
... | int main() {
assert(func0("hello world") == 'l');
assert(func0("hello ") == 'l');
assert(func0("python pr") == 'p');
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov $0x80,%ecx
mov %rdi,%rbx
sub $0x410,%rsp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
mov %rbx,%rdi
callq 1070 <strlen@plt>
test %eax,%eax
jle 12c0 <func0+0x90>
sub $0x1,%eax
mov %rbx,%rdi
xor %r9d,%r9d
... | func0:
endbr64
push rbx
mov ecx, 80h
mov rbx, rdi
sub rsp, 410h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov rdi, rbx
call _strlen
test eax, eax
jle short loc_12C0
sub eax, 1
mov rdi, rbx
xor r9d, r9d
xor esi, esi
lea ... | long long func0(unsigned __int8 *a1)
{
int v1; // eax
unsigned int v2; // r9d
int v3; // esi
long long v4; // r8
long long v5; // rdx
int v6; // eax
_DWORD v8[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v9; // [rsp+408h] [rbp-10h]
v9 = __readfsqword(0x28u);
memset(v8, 0, 0x400uLL);
v1 ... | func0:
ENDBR64
PUSH RBX
MOV ECX,0x80
MOV RBX,RDI
SUB RSP,0x410
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JLE 0x001012c0
SUB EAX,0x1
MOV RDI,RBX
XOR R9D,R9D
XOR ESI,ESI
LEA R8,[RBX + RAX*0x1 + 0x1]
NOP dword ptr [RAX]
LAB_00... | byte func0(byte *param_1)
{
byte *pbVar1;
byte bVar2;
int iVar3;
size_t sVar4;
long lVar5;
int iVar6;
int *piVar7;
byte bVar8;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar7 = aiStack_418;
for (lVar5 = 0x80; lVar5 != 0; lVar5 = ... |
7,643 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <limits.h>
| char func0(const char *str1) {
int frequency[256] = {0}; // Assuming ASCII charset
int max_freq = 0;
char max_char = '\0';
int len = strlen(str1);
for (int i = 0; i < len; i++) {
frequency[(unsigned char)str1[i]]++;
if (frequency[(unsigned char)str1[i]] > max_freq) {
... | int main() {
assert(func0("hello world") == 'l');
assert(func0("hello ") == 'l');
assert(func0("python pr") == 'p');
return 0;
}
| O3 | c | func0:
endbr64
push %rbx
mov $0x80,%ecx
mov %rdi,%rbx
sub $0x410,%rsp
mov %fs:0x28,%rax
mov %rax,0x408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
rep stos %rax,%es:(%rdi)
mov %rbx,%rdi
callq 1070 <strlen@plt>
test %eax,%eax
jle 12c0 <func0+0x90>
sub $0x1,%eax
mov %rbx,%rdi
xor %r9d,%r9d
... | func0:
endbr64
push rbx
mov ecx, 80h
mov rbx, rdi
sub rsp, 410h
mov rax, fs:28h
mov [rsp+418h+var_10], rax
xor eax, eax
mov rdi, rsp
rep stosq
mov rdi, rbx; s
call _strlen
test eax, eax
jle short loc_12C0
sub eax, 1
mov rdi, rbx
xor r9d, r9d
xor esi, esi
lea ... | long long func0(char *s)
{
int v1; // eax
unsigned int v2; // r9d
int v3; // esi
char *v4; // r8
long long v5; // rdx
int v6; // eax
_DWORD v8[258]; // [rsp+0h] [rbp-418h] BYREF
unsigned long long v9; // [rsp+408h] [rbp-10h]
v9 = __readfsqword(0x28u);
memset(v8, 0, 0x400uLL);
v1 = strlen(s);
i... | func0:
ENDBR64
PUSH RBX
MOV ECX,0x80
MOV RBX,RDI
SUB RSP,0x410
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x408],RAX
XOR EAX,EAX
MOV RDI,RSP
STOSQ.REP RDI
MOV RDI,RBX
CALL 0x00101070
TEST EAX,EAX
JLE 0x001012c0
SUB EAX,0x1
MOV RDI,RBX
XOR R9D,R9D
XOR ESI,ESI
LEA R8,[RBX + RAX*0x1 + 0x1]
NOP dword ptr [RAX]
LAB_00... | byte func0(byte *param_1)
{
byte *pbVar1;
byte bVar2;
int iVar3;
size_t sVar4;
long lVar5;
int iVar6;
int *piVar7;
byte bVar8;
long in_FS_OFFSET;
int aiStack_418 [258];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar7 = aiStack_418;
for (lVar5 = 0x80; lVar5 != 0; lVar5 = ... |
7,644 | func0 |
#include <assert.h>
#include <limits.h>
| void func0(int A[], int B[], int C[], int p, int q, int r, int res[3]) {
int diff = INT_MAX;
int res_i = 0;
int res_j = 0;
int res_k = 0;
int i = 0;
int j = 0;
int k = 0;
while(i < p && j < q && k < r) {
int minimum = A[i] < B[j] ? (A[i] < C[k] ? A[i] : C[k]) : (B[j] < C... | int main() {
int res[3];
func0((int[]){1, 4, 10}, (int[]){2, 15, 20}, (int[]){10, 12}, 3, 3, 2, res);
assert(res[0] == 10 && res[1] == 15 && res[2] == 10);
func0((int[]){20, 24, 100}, (int[]){2, 19, 22, 79, 800}, (int[]){10, 12, 23, 24, 119}, 3, 5, 5, res);
assert(res[0] == 24 && res[1] == 22... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %ecx,-0x4c(%rbp)
mov %r8d,-0x50(%rbp)
mov %r9d,-0x54(%rbp)
movl $0x7fffffff,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov [rbp+var_4C], ecx
mov [rbp+var_50], r8d
mov [rbp+var_54], r9d
mov [rbp+var_24], 7FFFFFFFh
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var... | long long func0(long long a1, long long a2, long long a3, int a4, int a5, int a6, _DWORD *a7)
{
int v7; // eax
int v8; // eax
long long result; // rax
int v10; // [rsp+30h] [rbp-24h]
int v11; // [rsp+34h] [rbp-20h]
int v12; // [rsp+38h] [rbp-1Ch]
int v13; // [rsp+3Ch] [rbp-18h]
int v14; // [rsp+40h] [r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV dword ptr [RBP + -0x4c],ECX
MOV dword ptr [RBP + -0x50],R8D
MOV dword ptr [RBP + -0x54],R9D
MOV dword ptr [RBP + -0x24],0x7fffffff
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + ... | void func0(long param_1,long param_2,long param_3,int param_4,int param_5,int param_6,
int4 *param_7)
{
int iVar1;
int iVar2;
int iVar3;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
int local_18;
int local_14;
local_2c = 0x7fffffff;
local_28 = 0;
local_24... |
7,645 | func0 |
#include <assert.h>
#include <limits.h>
| void func0(int A[], int B[], int C[], int p, int q, int r, int res[3]) {
int diff = INT_MAX;
int res_i = 0;
int res_j = 0;
int res_k = 0;
int i = 0;
int j = 0;
int k = 0;
while(i < p && j < q && k < r) {
int minimum = A[i] < B[j] ? (A[i] < C[k] ? A[i] : C[k]) : (B[j] < C... | int main() {
int res[3];
func0((int[]){1, 4, 10}, (int[]){2, 15, 20}, (int[]){10, 12}, 3, 3, 2, res);
assert(res[0] == 10 && res[1] == 15 && res[2] == 10);
func0((int[]){20, 24, 100}, (int[]){2, 19, 22, 79, 800}, (int[]){10, 12, 23, 24, 119}, 3, 5, 5, res);
assert(res[0] == 24 && res[1] == 22... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov 0x38(%rsp),%r15
test %r8d,%r8d
setg %r10b
test %r9d,%r9d
setg %al
test %al,%r10b
je 1277 <func0+0x10e>
test %ecx,%ecx
jle 1277 <func0+0x10e>
mov $0x0,%ebx
mov $0x0,%r13d
mov $0x0,%r12d
movl $0x0,-... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r13, rsi
mov rbp, rdx
mov r15, [rsp+30h+arg_0]
test r8d, r8d
setnle dl
test r9d, r9d
setnle al
test dl, al
jz loc_125E
mov r14d, ecx
test ecx, ecx
jle loc_125E
mov edi, ... | long long func0(long long a1, long long a2, long long a3, int a4, int a5, int a6, _DWORD *a7)
{
int v11; // edi
int v12; // r11d
int v13; // r10d
int v14; // ebx
int v15; // eax
int v16; // esi
int v17; // eax
int v18; // edx
int v19; // ecx
long long result; // rax
int v21; // [rsp+0h] [rbp-3Ch]... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R13,RSI
MOV RBP,RDX
MOV R15,qword ptr [RSP + 0x38]
TEST R8D,R8D
SETG DL
TEST R9D,R9D
SETG AL
TEST DL,AL
JZ 0x0010125e
MOV R14D,ECX
TEST ECX,ECX
JLE 0x0010125e
MOV EDI,0x0
MOV R11D,0x0
MOV R10D,0x0
MOV dword ptr [RSP + -0x4],0x0
MOV dwo... | void func0(long param_1,long param_2,long param_3,int param_4,int param_5,int param_6,
int4 *param_7)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int local_3c;
int local_38;
int local_34;
if ((0 < param_5 && 0 < param_6) && (0 < param_4... |
7,646 | func0 |
#include <assert.h>
#include <limits.h>
| void func0(int A[], int B[], int C[], int p, int q, int r, int res[3]) {
int diff = INT_MAX;
int res_i = 0;
int res_j = 0;
int res_k = 0;
int i = 0;
int j = 0;
int k = 0;
while(i < p && j < q && k < r) {
int minimum = A[i] < B[j] ? (A[i] < C[k] ? A[i] : C[k]) : (B[j] < C... | int main() {
int res[3];
func0((int[]){1, 4, 10}, (int[]){2, 15, 20}, (int[]){10, 12}, 3, 3, 2, res);
assert(res[0] == 10 && res[1] == 15 && res[2] == 10);
func0((int[]){20, 24, 100}, (int[]){2, 19, 22, 79, 800}, (int[]){10, 12, 23, 24, 119}, 3, 5, 5, res);
assert(res[0] == 24 && res[1] == 22... | O2 | c | func0:
endbr64
mov %r9d,%eax
push %r15
test %eax,%eax
push %r14
push %r13
setg %r10b
test %r8d,%r8d
push %r12
setg %al
push %rbp
push %rbx
mov %r9d,-0x10(%rsp)
mov (%rdi),%r9d
test %al,%r10b
je 1510 <func0+0x140>
test %ecx,%ecx
jle 1510 <func0+0x140>
movl $0x0,-0x4(%rsp)
xor ... | func0:
endbr64
push r15
test r9d, r9d
push r14
mov r14d, ecx
setnle cl
test r8d, r8d
push r13
setnle al
mov r13, rdx
push r12
mov r12, rsi
push rbp
push rbx
mov edx, [rdi]
mov [rsp+30h+var_40], r9d
test cl, al
jz loc_1529
test r14d, r14d
jle loc_1529
mov ... | long long func0(int *a1, unsigned int *a2, unsigned int *a3, int a4, int a5, int a6, _DWORD *a7)
{
int v10; // edx
int v12; // edi
int v13; // r10d
int v14; // r9d
int v15; // r15d
unsigned int v16; // esi
signed int v17; // eax
int v18; // eax
unsigned int *v19; // rbx
int v20; // ecx
unsigned i... | func0:
ENDBR64
PUSH R15
TEST R9D,R9D
PUSH R14
MOV R14D,ECX
SETG CL
TEST R8D,R8D
PUSH R13
SETG AL
MOV R13,RDX
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOV EDX,dword ptr [RDI]
MOV dword ptr [RSP + -0x10],R9D
TEST CL,AL
JZ 0x00101529
TEST R14D,R14D
JLE 0x00101529
MOV RBP,RDI
MOV dword ptr [RSP + -0x4],0x0
XOR EDI,EDI
XOR R1... | void func0(int *param_1,int *param_2,int *param_3,int param_4,int param_5,int param_6,int *param_7)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int *piVar9;
int iVar10;
int local_3c;
int local_38;
int local_34;
iVar3 = *param_1;
piVar4 = ... |
7,647 | func0 |
#include <assert.h>
#include <limits.h>
| void func0(int A[], int B[], int C[], int p, int q, int r, int res[3]) {
int diff = INT_MAX;
int res_i = 0;
int res_j = 0;
int res_k = 0;
int i = 0;
int j = 0;
int k = 0;
while(i < p && j < q && k < r) {
int minimum = A[i] < B[j] ? (A[i] < C[k] ? A[i] : C[k]) : (B[j] < C... | int main() {
int res[3];
func0((int[]){1, 4, 10}, (int[]){2, 15, 20}, (int[]){10, 12}, 3, 3, 2, res);
assert(res[0] == 10 && res[1] == 15 && res[2] == 10);
func0((int[]){20, 24, 100}, (int[]){2, 19, 22, 79, 800}, (int[]){10, 12, 23, 24, 119}, 3, 5, 5, res);
assert(res[0] == 24 && res[1] == 22... | O3 | c | func0:
endbr64
mov %r9d,%eax
push %r15
test %eax,%eax
push %r14
push %r13
setg %r10b
test %r8d,%r8d
push %r12
setg %al
push %rbp
push %rbx
mov %r9d,-0x10(%rsp)
mov (%rdi),%r9d
test %al,%r10b
je 14f0 <func0+0x140>
test %ecx,%ecx
jle 14f0 <func0+0x140>
movl $0x0,-0x4(%rsp)
xor ... | func0:
endbr64
push r15
test r9d, r9d
push r14
mov r14, rdx
push r13
mov r13, rsi
setnle sil
test r8d, r8d
push r12
push rbp
push rbx
mov ebx, ecx
mov rax, [rsp+30h+arg_0]
mov edx, [rdi]
mov [rsp+30h+var_40], ecx
setnle cl
test sil, cl
jz loc_14F7
test ebx, e... | _DWORD * func0(int *a1, int *a2, int *a3, int a4, int a5, int a6, _DWORD *a7)
{
_DWORD *result; // rax
int v10; // edx
int v12; // edi
int v13; // r11d
int v14; // r10d
int v15; // r15d
int v16; // esi
int v17; // eax
int v18; // eax
int *v19; // rbp
int v20; // ecx
int *v21; // rbx
int v23; /... | func0:
ENDBR64
PUSH R15
TEST R9D,R9D
PUSH R14
MOV R14,RDX
PUSH R13
MOV R13,RSI
SETG SIL
TEST R8D,R8D
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ECX
MOV RAX,qword ptr [RSP + 0x38]
MOV EDX,dword ptr [RDI]
MOV dword ptr [RSP + -0x10],ECX
SETG CL
TEST SIL,CL
JZ 0x001014f7
TEST EBX,EBX
JLE 0x001014f7
MOV R12,RDI
MOV dword ptr [RSP ... | void func0(int *param_1,int *param_2,int *param_3,int param_4,int param_5,int param_6,int *param_7)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int *piVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int local_3c;
int local_38;
int local_34;
iVar3 = *param_1;
piVar4 = ... |
7,648 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *make;
int model;
char *color;
} Phone;
int comparator(const void *v1, const void *v2) {
Phone *p1 = (Phone *)v1;
Phone *p2 = (Phone *)v2;
return strcmp(p1->color, p2->color);
}
... | void func0(Phone *models, int len) {
qsort(models, len, sizeof(Phone), comparator);
}
| int main() {
Phone phones1[] = {{"Nokia", 216, "Black"}, {"Mi Max", 2, "Gold"}, {"Samsung", 7, "Blue"}};
Phone sorted1[] = {{"Nokia", 216, "Black"}, {"Samsung", 7, "Blue"}, {"Mi Max", 2, "Gold"}};
int len1 = sizeof(phones1) / sizeof(phones1[0]);
func0(phones1, len1);
for (int i = 0; i < len1;... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rsi
mov -0x8(%rbp),%rax
lea -0x65(%rip),%rcx
mov $0x18,%edx
mov %rax,%rdi
callq 1080 <qsort@plt>
leaveq
retq
| func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+base], rdi
mov [rbp+var_C], esi
mov eax, [rbp+var_C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, comparator
mov rcx, rdx; compar
mov edx, 18h; size
mov rdi, rax; base
call _qsort
nop
leave
retn | void func0(void *a1, int a2)
{
qsort(a1, a2, 0x18uLL, comparator);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x1011a9]
MOV RCX,RDX
MOV EDX,0x18
MOV RDI,RAX
CALL 0x00101080
NOP
LEAVE
RET | void func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x18,comparator);
return;
} |
7,649 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *make;
int model;
char *color;
} Phone;
int comparator(const void *v1, const void *v2) {
Phone *p1 = (Phone *)v1;
Phone *p2 = (Phone *)v2;
return strcmp(p1->color, p2->color);
}
... | void func0(Phone *models, int len) {
qsort(models, len, sizeof(Phone), comparator);
}
| int main() {
Phone phones1[] = {{"Nokia", 216, "Black"}, {"Mi Max", 2, "Gold"}, {"Samsung", 7, "Blue"}};
Phone sorted1[] = {{"Nokia", 216, "Black"}, {"Samsung", 7, "Blue"}, {"Mi Max", 2, "Gold"}};
int len1 = sizeof(phones1) / sizeof(phones1[0]);
func0(phones1, len1);
for (int i = 0; i < len1;... | O1 | c | func0:
endbr64
sub $0x8,%rsp
movslq %esi,%rsi
lea -0x2c(%rip),%rcx
mov $0x18,%edx
callq 1080 <qsort@plt>
add $0x8,%rsp
retq
| func0:
endbr64
sub rsp, 8
movsxd rsi, esi
lea rcx, comparator
mov edx, 18h
call _qsort
add rsp, 8
retn | long long func0(long long a1, int a2)
{
return qsort(a1, a2, 24LL, comparator);
} | func0:
ENDBR64
SUB RSP,0x8
MOVSXD RSI,ESI
LEA RCX,[0x1011a9]
MOV EDX,0x18
CALL 0x00101080
ADD RSP,0x8
RET | void func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x18,comparator);
return;
} |
7,650 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *make;
int model;
char *color;
} Phone;
int comparator(const void *v1, const void *v2) {
Phone *p1 = (Phone *)v1;
Phone *p2 = (Phone *)v2;
return strcmp(p1->color, p2->color);
}
... | void func0(Phone *models, int len) {
qsort(models, len, sizeof(Phone), comparator);
}
| int main() {
Phone phones1[] = {{"Nokia", 216, "Black"}, {"Mi Max", 2, "Gold"}, {"Samsung", 7, "Blue"}};
Phone sorted1[] = {{"Nokia", 216, "Black"}, {"Samsung", 7, "Blue"}, {"Mi Max", 2, "Gold"}};
int len1 = sizeof(phones1) / sizeof(phones1[0]);
func0(phones1, len1);
for (int i = 0; i < len1;... | O2 | c | func0:
endbr64
movslq %esi,%rsi
lea -0x2e(%rip),%rcx
mov $0x18,%edx
jmpq 1080 <qsort@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rsi, esi
lea rcx, comparator
mov edx, 18h
jmp _qsort | long long func0(long long a1, int a2)
{
return qsort(a1, a2, 24LL, comparator);
} | func0:
ENDBR64
MOVSXD RSI,ESI
LEA RCX,[0x101660]
MOV EDX,0x18
JMP 0x00101080 | void func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x18,comparator);
return;
} |
7,651 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *make;
int model;
char *color;
} Phone;
int comparator(const void *v1, const void *v2) {
Phone *p1 = (Phone *)v1;
Phone *p2 = (Phone *)v2;
return strcmp(p1->color, p2->color);
}
... | void func0(Phone *models, int len) {
qsort(models, len, sizeof(Phone), comparator);
}
| int main() {
Phone phones1[] = {{"Nokia", 216, "Black"}, {"Mi Max", 2, "Gold"}, {"Samsung", 7, "Blue"}};
Phone sorted1[] = {{"Nokia", 216, "Black"}, {"Samsung", 7, "Blue"}, {"Mi Max", 2, "Gold"}};
int len1 = sizeof(phones1) / sizeof(phones1[0]);
func0(phones1, len1);
for (int i = 0; i < len1;... | O3 | c | func0:
endbr64
movslq %esi,%rsi
lea -0x2e(%rip),%rcx
mov $0x18,%edx
jmpq 1080 <qsort@plt>
nopl 0x0(%rax,%rax,1)
| func0:
endbr64
movsxd rsi, esi; nmemb
lea rcx, comparator; compar
mov edx, 18h; size
jmp _qsort | void func0(void *a1, int a2)
{
qsort(a1, a2, 0x18uLL, comparator);
} | func0:
ENDBR64
MOVSXD RSI,ESI
LEA RCX,[0x101690]
MOV EDX,0x18
JMP 0x00101080 | void func0(void *param_1,int param_2)
{
qsort(param_1,(long)param_2,0x18,comparator);
return;
} |
7,652 | func0 |
#include <stdio.h>
#include <assert.h>
void shift_down(int arr[], int start, int end) {
int root = start;
while (root * 2 + 1 <= end) {
int child = root * 2 + 1;
if (child + 1 <= end && arr[child] < arr[child + 1]) {
child += 1;
}
if (child <= end && arr[... | void func0(int arr[], int length) {
heapify(arr, length);
int end = length - 1;
while (end > 0) {
int temp = arr[end];
arr[end] = arr[0];
arr[0] = temp;
end -= 1;
shift_down(arr, 0, end);
}
}
| int main() {
int arr1[] = {12, 2, 4, 5, 2, 3};
func0(arr1, 6);
int sorted1[] = {2, 2, 3, 4, 5, 12};
for (int i = 0; i < 6; i++) {
assert(arr1[i] == sorted1[i]);
}
int arr2[] = {32, 14, 5, 6, 7, 19};
func0(arr2, 6);
int sorted2[] = {5, 6, 7, 14, 19, 32};
for (int i... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov -0x1c(%rbp),%edx
mov -0x18(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1286 <heapify>
mov -0x1c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x8(%rbp)
jmp 1357 <func0+0x85>
mov -0x8(%rbp)... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov edx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov esi, edx
mov rdi, rax
call heapify
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_8], eax
jmp short loc_1357
loc_1301:
mov ... | long long func0(_DWORD *a1, unsigned int a2)
{
long long result; // rax
int i; // [rsp+18h] [rbp-8h]
int v4; // [rsp+1Ch] [rbp-4h]
heapify(a1, a2);
result = a2 - 1;
for ( i = a2 - 1; i > 0; result = shift_down(a1, 0LL, (unsigned int)i) )
{
v4 = a1[i];
a1[i] = *a1;
*a1 = v4;
--i;
}
re... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EDX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101286
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x00101357
LAB_00101301:... | void func0(int4 *param_1,int param_2)
{
int4 uVar1;
int local_10;
heapify(param_1,param_2);
local_10 = param_2 + -1;
while (0 < local_10) {
uVar1 = param_1[local_10];
param_1[local_10] = *param_1;
*param_1 = uVar1;
local_10 = local_10 + -1;
shift_down(param_1,0,local_10);
}
return;... |
7,653 | func0 |
#include <stdio.h>
#include <assert.h>
void shift_down(int arr[], int start, int end) {
int root = start;
while (root * 2 + 1 <= end) {
int child = root * 2 + 1;
if (child + 1 <= end && arr[child] < arr[child + 1]) {
child += 1;
}
if (child <= end && arr[... | void func0(int arr[], int length) {
heapify(arr, length);
int end = length - 1;
while (end > 0) {
int temp = arr[end];
arr[end] = arr[0];
arr[0] = temp;
end -= 1;
shift_down(arr, 0, end);
}
}
| int main() {
int arr1[] = {12, 2, 4, 5, 2, 3};
func0(arr1, 6);
int sorted1[] = {2, 2, 3, 4, 5, 12};
for (int i = 0; i < 6; i++) {
assert(arr1[i] == sorted1[i]);
}
int arr2[] = {32, 14, 5, 6, 7, 19};
func0(arr2, 6);
int sorted2[] = {5, 6, 7, 14, 19, 32};
for (int i... | O1 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%ebx
callq 11bc <heapify>
sub $0x1,%ebx
test %ebx,%ebx
jle 1230 <func0+0x40>
movslq %ebx,%rbx
mov 0x0(%rbp,%rbx,4),%eax
mov 0x0(%rbp),%edx
mov %edx,0x0(%rbp,%rbx,4)
mov %eax,0x0(%rbp)
lea -0x1(%rbx),%edx
mov $0x0,%esi
mov ... | func0:
endbr64
push rbp
push rbx
mov rbp, rdi
mov ebx, esi
call heapify
sub ebx, 1
test ebx, ebx
jle short loc_1233
movsxd rbx, ebx
loc_120D:
mov eax, [rbp+rbx*4+0]
mov edx, [rbp+0]
mov [rbp+rbx*4+0], edx
mov [rbp+0], eax
lea edx, [rbx-1]
mov esi, 0
mov rdi, rbp
... | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
long long v3; // rbx
int v4; // eax
result = heapify();
LODWORD(v3) = a2 - 1;
if ( a2 - 1 > 0 )
{
v3 = (int)v3;
do
{
v4 = a1[v3];
a1[v3] = *a1;
*a1 = v4;
result = shift_down(a1, 0LL, (unsigned int)--v3);
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
CALL 0x001011bf
SUB EBX,0x1
TEST EBX,EBX
JLE 0x00101233
MOVSXD RBX,EBX
LAB_0010120d:
MOV EAX,dword ptr [RBP + RBX*0x4]
MOV EDX,dword ptr [RBP]
MOV dword ptr [RBP + RBX*0x4],EDX
MOV dword ptr [RBP],EAX
LEA EDX,[RBX + -0x1]
MOV ESI,0x0
MOV RDI,RBP
CALL 0x00101169
S... | void func0(int4 *param_1,int param_2)
{
int4 uVar1;
long lVar2;
heapify();
if (0 < param_2 + -1) {
lVar2 = (long)(param_2 + -1);
do {
uVar1 = param_1[lVar2];
param_1[lVar2] = *param_1;
*param_1 = uVar1;
shift_down(param_1,0,(int)lVar2 + -1);
lVar2 = lVar2 + -1;
} wh... |
7,654 | func0 |
#include <stdio.h>
#include <assert.h>
void shift_down(int arr[], int start, int end) {
int root = start;
while (root * 2 + 1 <= end) {
int child = root * 2 + 1;
if (child + 1 <= end && arr[child] < arr[child + 1]) {
child += 1;
}
if (child <= end && arr[... | void func0(int arr[], int length) {
heapify(arr, length);
int end = length - 1;
while (end > 0) {
int temp = arr[end];
arr[end] = arr[0];
arr[0] = temp;
end -= 1;
shift_down(arr, 0, end);
}
}
| int main() {
int arr1[] = {12, 2, 4, 5, 2, 3};
func0(arr1, 6);
int sorted1[] = {2, 2, 3, 4, 5, 12};
for (int i = 0; i < 6; i++) {
assert(arr1[i] == sorted1[i]);
}
int arr2[] = {32, 14, 5, 6, 7, 19};
func0(arr2, 6);
int sorted2[] = {5, 6, 7, 14, 19, 32};
for (int i... | O2 | c | func0:
endbr64
lea -0x2(%rsi),%eax
lea -0x1(%rsi),%edx
mov %eax,%r10d
shr $0x1f,%r10d
add %eax,%r10d
sar %r10d
test %esi,%esi
jle 1482 <func0+0x32>
nopl 0x0(%rax,%rax,1)
mov %r10d,%esi
callq 13b0 <shift_down>
sub $0x1,%r10d
cmp $0xffffffff,%r10d
jne 1470 <func0+0x20>
movslq %edx,%r... | func0:
endbr64
lea eax, [rsi-2]
lea edx, [rsi-1]
mov r11d, eax
shr r11d, 1Fh
add r11d, eax
sar r11d, 1
test esi, esi
jle short loc_146E
nop dword ptr [rax+rax+00h]
loc_1460:
mov esi, r11d
call shift_down
sub r11d, 1
jnb short loc_1460
loc_146E:
movsxd r11, edx
test ... | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
long long v3; // rdx
unsigned int v4; // r11d
int v5; // r11d
bool v6; // cf
long long v7; // r11
int v8; // eax
result = (unsigned int)(a2 - 2);
v3 = (unsigned int)(a2 - 1);
v4 = (a2 - 2) / 2;
if ( a2 > 0 )
{
do
{
re... | func0:
ENDBR64
LEA EAX,[RSI + -0x2]
LEA EDX,[RSI + -0x1]
MOV R11D,EAX
SHR R11D,0x1f
ADD R11D,EAX
SAR R11D,0x1
TEST ESI,ESI
JLE 0x0010146e
NOP dword ptr [RAX + RAX*0x1]
LAB_00101460:
MOV ESI,R11D
CALL 0x001013b0
SUB R11D,0x1
JNC 0x00101460
LAB_0010146e:
MOVSXD R11,EDX
TEST EDX,EDX
JLE 0x001014a0
NOP dword ptr [RAX]
LAB_... | void func0(int4 *param_1,int param_2)
{
int4 uVar1;
int iVar2;
int extraout_EDX;
int iVar3;
long lVar4;
bool bVar5;
iVar2 = param_2 + -1;
iVar3 = (param_2 + -2) / 2;
if (0 < param_2) {
do {
shift_down();
bVar5 = iVar3 != 0;
iVar3 = iVar3 + -1;
iVar2 = extraout_EDX;
... |
7,655 | func0 |
#include <stdio.h>
#include <assert.h>
void shift_down(int arr[], int start, int end) {
int root = start;
while (root * 2 + 1 <= end) {
int child = root * 2 + 1;
if (child + 1 <= end && arr[child] < arr[child + 1]) {
child += 1;
}
if (child <= end && arr[... | void func0(int arr[], int length) {
heapify(arr, length);
int end = length - 1;
while (end > 0) {
int temp = arr[end];
arr[end] = arr[0];
arr[0] = temp;
end -= 1;
shift_down(arr, 0, end);
}
}
| int main() {
int arr1[] = {12, 2, 4, 5, 2, 3};
func0(arr1, 6);
int sorted1[] = {2, 2, 3, 4, 5, 12};
for (int i = 0; i < 6; i++) {
assert(arr1[i] == sorted1[i]);
}
int arr2[] = {32, 14, 5, 6, 7, 19};
func0(arr2, 6);
int sorted2[] = {5, 6, 7, 14, 19, 32};
for (int i... | O3 | c | func0:
endbr64
lea -0x2(%rsi),%edx
push %rbp
lea -0x1(%rsi),%r11d
push %rbx
mov %edx,%ebx
shr $0x1f,%ebx
add %edx,%ebx
mov %ebx,%ebp
and $0xfffffffe,%ebx
sar %ebp
test %esi,%esi
jle 152a <func0+0x8a>
mov %ebx,%r8d
movslq %ebp,%rcx
cmp %r11d,%ebx
jl 14f8 <func0+0x58>
jmp 151... | func0:
endbr64
lea r11d, [rsi-2]
push rbx
mov rdx, rdi
lea r9d, [rsi-1]
mov r10d, r11d
shr r10d, 1Fh
add r10d, r11d
mov ebx, r10d
and r10d, 0FFFFFFFEh
sar ebx, 1
test esi, esi
jle short loc_14B5
nop word ptr [rax+rax+00000000h]
loc_1450:
mov esi, r10d
movsxd rcx, e... | void func0(int *a1, int a2)
{
int v2; // r11d
int v4; // r9d
signed int v5; // r10d
int v6; // ebx
int v7; // esi
long long v8; // rcx
int *v9; // rdi
int v10; // esi
int *v11; // r8
int v12; // ecx
int v13; // eax
long long v14; // r10
int *v15; // rax
int v16; // ecx
long long v17; // r... | func0:
ENDBR64
LEA R11D,[RSI + -0x2]
PUSH RBX
MOV RDX,RDI
LEA R9D,[RSI + -0x1]
MOV R10D,R11D
SHR R10D,0x1f
ADD R10D,R11D
MOV EBX,R10D
AND R10D,0xfffffffe
SAR EBX,0x1
TEST ESI,ESI
JLE 0x001014b5
NOP word ptr [RAX + RAX*0x1]
LAB_00101450:
MOV ESI,R10D
MOVSXD RCX,EBX
CMP R10D,R9D
JL 0x00101484
JMP 0x001014a9
LAB_00101460:... | void func0(int4 *param_1,int param_2)
{
int iVar1;
int4 uVar2;
int iVar3;
int iVar4;
long lVar5;
int iVar6;
int iVar7;
int iVar8;
int *piVar9;
uint uVar10;
uint uVar11;
long lVar12;
int iVar13;
iVar13 = param_2 + -2;
iVar8 = param_2 + -1;
uVar10 = iVar13 - (iVar13 >> 0x1f) & 0xffffff... |
7,656 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num[], int size) {
int count_elim = 0;
for (int i = 0; i < size; i++) {
// Since we cannot differentiate tuple type directly in C,
// let's assume the marker for tuple is a specific integer, e.g., -1
if (num[i] == -1) {
break;
}
count_el... | int main() {
int arr1[] = {10, 20, 30, -1, 40}; // -1 represents tuple (10,20)
int arr2[] = {10, -1, -1, 40}; // -1 represents tuples (20,30) and (10,20)
int arr3[] = {-1}; // -1 represents tuple (10,(20,30,(10,20),40))
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 1);
assert... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ab <func0+0x42>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0xffffffff,%eax
je 11b5 <func0+0... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11AB
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp eax, 0FFFFFFFFh
jz ... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2 && *(_DWORD *)(4LL * i + a1) != -1; ++i )
++v3;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ab
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX... | int func0(long param_1,int param_2)
{
int local_10;
int local_c;
local_10 = 0;
local_c = 0;
while ((local_c < param_2 && (*(int *)(param_1 + (long)local_c * 4) != -1))) {
local_10 = local_10 + 1;
local_c = local_c + 1;
}
return local_10;
} |
7,657 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num[], int size) {
int count_elim = 0;
for (int i = 0; i < size; i++) {
// Since we cannot differentiate tuple type directly in C,
// let's assume the marker for tuple is a specific integer, e.g., -1
if (num[i] == -1) {
break;
}
count_el... | int main() {
int arr1[] = {10, 20, 30, -1, 40}; // -1 represents tuple (10,20)
int arr2[] = {10, -1, -1, 40}; // -1 represents tuples (20,30) and (10,20)
int arr3[] = {-1}; // -1 represents tuple (10,(20,30,(10,20),40))
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 1);
assert... | O1 | c | func0:
endbr64
test %esi,%esi
jle 1195 <func0+0x2c>
lea -0x1(%rsi),%esi
mov $0x0,%eax
jmp 117e <func0+0x15>
mov %rcx,%rax
mov %eax,%edx
cmpl $0xffffffff,(%rdi,%rax,4)
je 1192 <func0+0x29>
lea 0x1(%rax),%edx
lea 0x1(%rax),%rcx
cmp %rsi,%rax
jne 117b <func0+0x12>
mov %edx,%eax
ret... | func0:
endbr64
test esi, esi
jle short loc_1189
mov eax, 0
loc_1176:
cmp dword ptr [rdi], 0FFFFFFFFh
jz short locret_118E
add eax, 1
add rdi, 4
cmp esi, eax
jnz short loc_1176
mov eax, esi
retn
loc_1189:
mov eax, 0
locret_118E:
retn | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
if ( a2 <= 0 )
return 0LL;
result = 0LL;
while ( *a1 != -1 )
{
result = (unsigned int)(result + 1);
++a1;
if ( a2 == (_DWORD)result )
return (unsigned int)a2;
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101189
MOV EAX,0x0
LAB_00101176:
CMP dword ptr [RDI],-0x1
JZ 0x0010118e
ADD EAX,0x1
ADD RDI,0x4
CMP ESI,EAX
JNZ 0x00101176
MOV EAX,ESI
RET
LAB_00101189:
MOV EAX,0x0
LAB_0010118e:
RET | int func0(int *param_1,int param_2)
{
int iVar1;
if (param_2 < 1) {
iVar1 = 0;
}
else {
iVar1 = 0;
while (*param_1 != -1) {
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
if (param_2 == iVar1) {
return param_2;
}
}
}
return iVar1;
} |
7,658 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num[], int size) {
int count_elim = 0;
for (int i = 0; i < size; i++) {
// Since we cannot differentiate tuple type directly in C,
// let's assume the marker for tuple is a specific integer, e.g., -1
if (num[i] == -1) {
break;
}
count_el... | int main() {
int arr1[] = {10, 20, 30, -1, 40}; // -1 represents tuple (10,20)
int arr2[] = {10, -1, -1, 40}; // -1 represents tuples (20,30) and (10,20)
int arr3[] = {-1}; // -1 represents tuple (10,(20,30,(10,20),40))
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 1);
assert... | O2 | c | func0:
endbr64
test %esi,%esi
jle 116d <func0+0x2d>
lea -0x1(%rsi),%ecx
xor %eax,%eax
jmp 1160 <func0+0x20>
lea 0x1(%rax),%r8d
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1169 <func0+0x29>
mov %rdx,%rax
cmpl $0xffffffff,(%rdi,%rax,4)
mov %eax,%r8d
jne 1150 <func0+0x10>
mov %r8d,%eax
ret... | func0:
endbr64
xor eax, eax
test esi, esi
jg short loc_123B
jmp short locret_1240
loc_1230:
add eax, 1
add rdi, 4
cmp esi, eax
jz short locret_1248
loc_123B:
cmp dword ptr [rdi], 0FFFFFFFFh
jnz short loc_1230
locret_1240:
retn
locret_1248:
retn | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
result = 0LL;
if ( a2 > 0 )
{
do
{
if ( *a1 == -1 )
break;
result = (unsigned int)(result + 1);
++a1;
}
while ( a2 != (_DWORD)result );
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST ESI,ESI
JG 0x0010123b
JMP 0x00101240
LAB_00101230:
ADD EAX,0x1
ADD RDI,0x4
CMP ESI,EAX
JZ 0x00101248
LAB_0010123b:
CMP dword ptr [RDI],-0x1
JNZ 0x00101230
LAB_00101240:
RET
LAB_00101248:
RET | void func0(int *param_1,int param_2)
{
int iVar1;
iVar1 = 0;
if (0 < param_2) {
while (*param_1 != -1) {
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
if (param_2 == iVar1) {
return;
}
}
}
return;
} |
7,659 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int num[], int size) {
int count_elim = 0;
for (int i = 0; i < size; i++) {
// Since we cannot differentiate tuple type directly in C,
// let's assume the marker for tuple is a specific integer, e.g., -1
if (num[i] == -1) {
break;
}
count_el... | int main() {
int arr1[] = {10, 20, 30, -1, 40}; // -1 represents tuple (10,20)
int arr2[] = {10, -1, -1, 40}; // -1 represents tuples (20,30) and (10,20)
int arr3[] = {-1}; // -1 represents tuple (10,(20,30,(10,20),40))
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 1);
assert... | O3 | c | func0:
endbr64
test %esi,%esi
jle 121d <func0+0x2d>
lea -0x1(%rsi),%ecx
xor %eax,%eax
jmp 1210 <func0+0x20>
lea 0x1(%rax),%r8d
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 1219 <func0+0x29>
mov %rdx,%rax
cmpl $0xffffffff,(%rdi,%rax,4)
mov %eax,%r8d
jne 1200 <func0+0x10>
mov %r8d,%eax
ret... | func0:
endbr64
xor eax, eax
test esi, esi
jg short loc_115B
retn
loc_1150:
add eax, 1
add rdi, 4
cmp esi, eax
jz short locret_1168
loc_115B:
cmp dword ptr [rdi], 0FFFFFFFFh
jnz short loc_1150
retn
locret_1168:
retn | long long func0(_DWORD *a1, int a2)
{
long long result; // rax
result = 0LL;
if ( a2 > 0 )
{
do
{
if ( *a1 == -1 )
break;
result = (unsigned int)(result + 1);
++a1;
}
while ( a2 != (_DWORD)result );
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST ESI,ESI
JG 0x0010115b
RET
LAB_00101150:
ADD EAX,0x1
ADD RDI,0x4
CMP ESI,EAX
JZ 0x00101168
LAB_0010115b:
CMP dword ptr [RDI],-0x1
JNZ 0x00101150
RET
LAB_00101168:
RET | void func0(int *param_1,int param_2)
{
int iVar1;
iVar1 = 0;
if (param_2 < 1) {
return;
}
do {
if (*param_1 == -1) {
return;
}
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
} while (param_2 != iVar1);
return;
} |
7,660 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int tup_size, int check_list[], int list_size) {
bool res = false;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < tup_size; j++) {
if (check_list[i] == test_tup[j]) {
res = true;
break;
}
}
... | int main() {
int test_tup1[] = {4, 5, 7, 9, 3};
int check_list1[] = {6, 7, 10, 11};
int test_tup2[] = {1, 2, 3, 4};
int check_list2[] = {4, 6, 7, 8, 9};
int test_tup3[] = {3, 2, 1, 4, 5};
int check_list3[] = {9, 8, 7, 6};
assert(func0(test_tup1, 5, check_list1, 4) == true);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
movb $0x0,-0x9(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11e1 <func0+0x78>
movl $0x0,-0x4(%rbp)
jmp 11cf <func0+0x66>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov [rbp+var_9], 0
mov [rbp+var_8], 0
jmp short loc_11E1
loc_118C:
mov [rbp+var_4], 0
jmp short loc_11CF
loc_1195:
mov eax, [rbp+var_8]
cdqe
lea ... | long long func0(long long a1, int a2, long long a3, int a4)
{
unsigned __int8 v5; // [rsp+1Fh] [rbp-9h]
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
v5 = 0;
for ( i = 0; i < a4; ++i )
{
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a3) == *(_DWORD *)(4LL * j + a1) )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x20],ECX
MOV byte ptr [RBP + -0x9],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011e1
LAB_0010118c:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cf
LAB_00101195:
MOV EA... | char func0(long param_1,int param_2,long param_3,int param_4)
{
char local_11;
int local_10;
int local_c;
local_11 = '\0';
local_10 = 0;
do {
if (param_4 <= local_10) {
return local_11;
}
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_3 + (long)l... |
7,661 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int tup_size, int check_list[], int list_size) {
bool res = false;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < tup_size; j++) {
if (check_list[i] == test_tup[j]) {
res = true;
break;
}
}
... | int main() {
int test_tup1[] = {4, 5, 7, 9, 3};
int check_list1[] = {6, 7, 10, 11};
int test_tup2[] = {1, 2, 3, 4};
int check_list2[] = {4, 6, 7, 8, 9};
int test_tup3[] = {3, 2, 1, 4, 5};
int check_list3[] = {9, 8, 7, 6};
assert(func0(test_tup1, 5, check_list1, 4) == true);
... | O1 | c | func0:
endbr64
test %ecx,%ecx
jle 11ab <func0+0x42>
mov %rdx,%r8
lea -0x1(%rcx),%eax
lea 0x4(%rdx,%rax,4),%r10
mov %rdi,%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
jmp 1192 <func0+0x29>
add $0x4,%r8
cmp %r10,%r8
je 11b7 <func0+0x4e>
test %esi,%esi
jle 1189 <func0+0x20>
mov... | func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_11AA
mov rdi, rdx
lea eax, [rcx-1]
lea r9, [rdx+rax*4+4]
lea eax, [rsi-1]
lea rcx, [r8+rax*4+4]
jmp short loc_1192
loc_1189:
add rdi, 4
cmp rdi, r9
jz short loc_11B6
loc_1192:
test esi, esi
jle short loc_1189
m... | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v5; // rdi
_DWORD *v6; // rax
if ( a4 <= 0 )
return 0LL;
v5 = a3;
while ( a2 <= 0 )
{
LABEL_3:
if ( ++v5 == &a3[a4 - 1 + 1] )
return 0LL;
}
v6 = a1;
while ( *v5 != *v6 )
{
if ( ++v6 == &a1[a2 - 1 + 1] )
goto ... | func0:
ENDBR64
MOV R8,RDI
TEST ECX,ECX
JLE 0x001011aa
MOV RDI,RDX
LEA EAX,[RCX + -0x1]
LEA R9,[RDX + RAX*0x4 + 0x4]
LEA EAX,[RSI + -0x1]
LEA RCX,[R8 + RAX*0x4 + 0x4]
JMP 0x00101192
LAB_00101189:
ADD RDI,0x4
CMP RDI,R9
JZ 0x001011b6
LAB_00101192:
TEST ESI,ESI
JLE 0x00101189
MOV EDX,dword ptr [RDI]
MOV RAX,R8
LAB_0010119... | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (param_4 < 1) {
return 0;
}
piVar1 = param_3 + (ulong)(param_4 - 1) + 1;
do {
if (0 < param_2) {
piVar2 = param_1;
do {
if (*param_3 == *piVar2) {
return 1;
}
... |
7,662 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int tup_size, int check_list[], int list_size) {
bool res = false;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < tup_size; j++) {
if (check_list[i] == test_tup[j]) {
res = true;
break;
}
}
... | int main() {
int test_tup1[] = {4, 5, 7, 9, 3};
int check_list1[] = {6, 7, 10, 11};
int test_tup2[] = {1, 2, 3, 4};
int check_list2[] = {4, 6, 7, 8, 9};
int test_tup3[] = {3, 2, 1, 4, 5};
int check_list3[] = {9, 8, 7, 6};
assert(func0(test_tup1, 5, check_list1, 4) == true);
... | O2 | c | func0:
endbr64
test %ecx,%ecx
jle 1371 <func0+0x51>
lea -0x1(%rcx),%eax
mov %rdx,%r8
lea 0x4(%rdx,%rax,4),%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
test %esi,%esi
jle 1368 <func0+0x48>
mov (%r8),%edx
mov %rdi,%rax
jmp 1359 <func0+0x39>
nopl 0x0(%rax)
a... | func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_1381
lea eax, [rcx-1]
lea r9, [rdx+rax*4+4]
lea eax, [rsi-1]
lea rdi, [rdi+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_1350:
test esi, esi
jle short loc_1378
mov ecx, [rdx]
mov rax, r8
jmp short loc_1369
loc_1360:
add ... | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
long long v5; // r9
long long v6; // rdi
_DWORD *v7; // rax
if ( a4 <= 0 )
return 0LL;
v5 = (long long)&a3[a4 - 1 + 1];
v6 = (long long)&a1[a2 - 1 + 1];
while ( a2 <= 0 )
{
LABEL_8:
if ( ++a3 == (_DWORD *)v5 )
return 0LL;
}
v7... | func0:
ENDBR64
MOV R8,RDI
TEST ECX,ECX
JLE 0x00101381
LEA EAX,[RCX + -0x1]
LEA R9,[RDX + RAX*0x4 + 0x4]
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101350:
TEST ESI,ESI
JLE 0x00101378
MOV ECX,dword ptr [RDX]
MOV RAX,R8
JMP 0x00101369
LAB_00101360:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x... | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_4) {
piVar1 = param_3 + (ulong)(param_4 - 1) + 1;
do {
if (0 < param_2) {
piVar2 = param_1;
do {
if (*param_3 == *piVar2) {
return 1;
}
... |
7,663 | func0 |
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
| bool func0(int test_tup[], int tup_size, int check_list[], int list_size) {
bool res = false;
for (int i = 0; i < list_size; i++) {
for (int j = 0; j < tup_size; j++) {
if (check_list[i] == test_tup[j]) {
res = true;
break;
}
}
... | int main() {
int test_tup1[] = {4, 5, 7, 9, 3};
int check_list1[] = {6, 7, 10, 11};
int test_tup2[] = {1, 2, 3, 4};
int check_list2[] = {4, 6, 7, 8, 9};
int test_tup3[] = {3, 2, 1, 4, 5};
int check_list3[] = {9, 8, 7, 6};
assert(func0(test_tup1, 5, check_list1, 4) == true);
... | O3 | c | func0:
endbr64
test %ecx,%ecx
jle 1251 <func0+0x51>
lea -0x1(%rcx),%eax
mov %rdx,%r8
lea 0x4(%rdx,%rax,4),%r9
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
test %esi,%esi
jle 1248 <func0+0x48>
mov (%r8),%edx
mov %rdi,%rax
jmp 1239 <func0+0x39>
nopl 0x0(%rax)
a... | func0:
endbr64
mov r8, rdi
test ecx, ecx
jle short loc_1191
movsxd rcx, ecx
movsxd rax, esi
lea r9, [rdx+rcx*4]
lea rdi, [rdi+rax*4]
nop dword ptr [rax+00000000h]
loc_1160:
test esi, esi
jle short loc_1188
loc_1164:
mov ecx, [rdx]
mov rax, r8
jmp short loc_1179
loc_1170:
add ... | long long func0(_DWORD *a1, int a2, _DWORD *a3, int a4)
{
_DWORD *v5; // r9
_DWORD *v6; // rdi
_DWORD *v7; // rax
if ( a4 <= 0 )
return 0LL;
v5 = &a3[a4];
v6 = &a1[a2];
while ( a2 <= 0 )
{
if ( ++a3 == v5 )
return 0LL;
}
do
{
v7 = a1;
do
{
if ( *a3 == *v7 )
... | func0:
ENDBR64
MOV R8,RDI
TEST ECX,ECX
JLE 0x00101191
MOVSXD RCX,ECX
MOVSXD RAX,ESI
LEA R9,[RDX + RCX*0x4]
LEA RDI,[RDI + RAX*0x4]
NOP dword ptr [RAX]
LAB_00101160:
TEST ESI,ESI
JLE 0x00101188
LAB_00101164:
MOV ECX,dword ptr [RDX]
MOV RAX,R8
JMP 0x00101179
LAB_00101170:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x00101198
LAB_0010117... | int8 func0(int *param_1,int param_2,int *param_3,int param_4)
{
int *piVar1;
int *piVar2;
if (0 < param_4) {
piVar1 = param_3 + param_4;
do {
if (0 < param_2) {
do {
piVar2 = param_1;
do {
if (*param_3 == *piVar2) {
return 1;
}
... |
7,664 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int *num1, int size1, int *num2, int size2) {
// Allocate memory to hold the combined arrays results
int *result = (int *)malloc((size1 + size2) * sizeof(int));
int i = 0, j = 0, k = 0;
// Merge two arrays
while (i < size1 && j < size2) {
if (num1[i] < num2[j]) {
... | int main() {
int arr1[] = {1, 3, 5, 7, 9, 11};
int arr2[] = {0, 2, 4, 6, 8, 10};
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int* result1 = func0(arr1, 6, arr2, 6);
for (int i = 0; i < 12; i++) assert(result1[i] == expected1[i]);
int arr3[] = {1, 3, 5, 6, 8, 9};
int ar... | 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 %ecx,-0x30(%rbp)
mov -0x2c(%rbp),%edx
mov -0x30(%rbp),%eax
add %edx,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_30], ecx
mov edx, [rbp+var_2C]
mov eax, [rbp+var_30]
add eax, edx
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mo... | _DWORD * func0(long long a1, int a2, long long a3, int a4)
{
int v4; // eax
_DWORD *v5; // rcx
int v6; // eax
int v7; // eax
int v8; // eax
_DWORD *v9; // rcx
int v10; // eax
int v11; // eax
_DWORD *v12; // rcx
int v13; // eax
int v17; // [rsp+2Ch] [rbp-14h]
int v18; // [rsp+30h] [rbp-10h]
int... | 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 dword ptr [RBP + -0x30],ECX
MOV EDX,dword ptr [RBP + -0x2c]
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,EDX
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -... | void * func0(long param_1,int param_2,long param_3,int param_4)
{
void *pvVar1;
int local_1c;
int local_18;
int local_14;
pvVar1 = malloc((long)(param_4 + param_2) << 2);
local_1c = 0;
local_18 = 0;
local_14 = 0;
while ((local_1c < param_2 && (local_18 < param_4))) {
if (*(int *)(param_1 + (lo... |
7,665 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int *num1, int size1, int *num2, int size2) {
// Allocate memory to hold the combined arrays results
int *result = (int *)malloc((size1 + size2) * sizeof(int));
int i = 0, j = 0, k = 0;
// Merge two arrays
while (i < size1 && j < size2) {
if (num1[i] < num2[j]) {
... | int main() {
int arr1[] = {1, 3, 5, 7, 9, 11};
int arr2[] = {0, 2, 4, 6, 8, 10};
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int* result1 = func0(arr1, 6, arr2, 6);
for (int i = 0; i < 12; i++) assert(result1[i] == expected1[i]);
int arr3[] = {1, 3, 5, 6, 8, 9};
int ar... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%ebx
mov %rdx,%r12
mov %ecx,%ebp
lea (%rsi,%rcx,1),%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
test %ebx,%ebx
jle 123f <func0+0x76>
test %ebp,%ebp
jle 123f <func0+0x76>
mov... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rdi
mov ebx, esi
mov r12, rdx
mov ebp, ecx
lea edi, [rsi+rcx]
movsxd rdi, edi
shl rdi, 2
call _malloc
mov r9, rax
test ebx, ebx
jle short loc_1245
test ebp, ebp
jle short loc_1245
mov ... | long long func0(long long a1, int a2, long long a3, int a4)
{
long long v8; // rax
long long v9; // r9
_DWORD *v10; // rsi
int v11; // edx
int v12; // ecx
int v13; // r10d
int v14; // r8d
int v15; // edi
long long v16; // rdx
long long v17; // r10
v8 = malloc(4LL * (a2 + a4));
v9 = v8;
if ( ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV EBX,ESI
MOV R12,RDX
MOV EBP,ECX
LEA EDI,[RSI + RCX*0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010d0
MOV R9,RAX
TEST EBX,EBX
JLE 0x00101245
TEST EBP,EBP
JLE 0x00101245
MOV RSI,RAX
MOV EDX,0x1
MOV EAX,0x0
MOV ECX,0x0
JMP 0x00101226
LAB_0010120f... | int * func0(long param_1,int param_2,long param_3,int param_4)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int iVar5;
long lVar6;
int iVar7;
int *piVar8;
long lVar9;
piVar4 = (int *)malloc((long)(param_2 + param_4) << 2);
if ((param_2 < 1) || (param_4 < 1)) {
iVar7 = 0;
iVar3 = 0;
... |
7,666 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int *num1, int size1, int *num2, int size2) {
// Allocate memory to hold the combined arrays results
int *result = (int *)malloc((size1 + size2) * sizeof(int));
int i = 0, j = 0, k = 0;
// Merge two arrays
while (i < size1 && j < size2) {
if (num1[i] < num2[j]) {
... | int main() {
int arr1[] = {1, 3, 5, 7, 9, 11};
int arr2[] = {0, 2, 4, 6, 8, 10};
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int* result1 = func0(arr1, 6, arr2, 6);
for (int i = 0; i < 12; i++) assert(result1[i] == expected1[i]);
int arr3[] = {1, 3, 5, 6, 8, 9};
int ar... | O2 | c | func0:
endbr64
push %r13
mov %rdi,%r13
lea (%rsi,%rcx,1),%edi
push %r12
movslq %edi,%rdi
mov %rdx,%r12
push %rbp
shl $0x2,%rdi
mov %ecx,%ebp
push %rbx
mov %esi,%ebx
sub $0x8,%rsp
callq 10d0 <malloc@plt>
test %ebx,%ebx
jle 1610 <func0+0xf0>
test %ebp,%ebp
jle 1610 <func0+0xf0>
mov... | func0:
endbr64
push r15
mov r15, rdx
push r14
push r13
mov r13d, esi
push r12
mov r12d, ecx
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdi
lea edi, [rsi+rcx]
movsxd rdi, edi
shl rdi, 2
call _malloc
test r13d, r13d
mov r8, [rsp+48h+var_40]
mov r14, r... | long long func0(long long a1, int a2, long long a3, int a4)
{
long long v6; // r14
long long v7; // rax
int v8; // ebx
int v9; // ebp
int v10; // r9d
int v11; // edx
int v12; // ecx
int v14; // [rsp+8h] [rbp-40h]
v6 = malloc(4LL * (a2 + a4));
if ( a2 > 0 && a4 > 0 )
{
v7 = 1LL;
v8 = 0;
... | func0:
ENDBR64
PUSH R15
MOV R15,RDX
PUSH R14
PUSH R13
MOV R13D,ESI
PUSH R12
MOV R12D,ECX
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
LEA EDI,[RSI + RCX*0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010f0
TEST R13D,R13D
MOV R8,qword ptr [RSP + 0x8]
MOV R14,RAX
JLE 0x00101650
TEST R12D,R12D
JLE 0x00101650
MO... | void * func0(long param_1,int param_2,long param_3,int param_4)
{
int iVar1;
int iVar2;
void *pvVar3;
long lVar4;
int iVar5;
int iVar6;
int iVar7;
pvVar3 = malloc((long)(param_2 + param_4) << 2);
if ((param_2 < 1) || (param_4 < 1)) {
iVar7 = 0;
iVar5 = 0;
iVar6 = 0;
}
else {
lV... |
7,667 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int *num1, int size1, int *num2, int size2) {
// Allocate memory to hold the combined arrays results
int *result = (int *)malloc((size1 + size2) * sizeof(int));
int i = 0, j = 0, k = 0;
// Merge two arrays
while (i < size1 && j < size2) {
if (num1[i] < num2[j]) {
... | int main() {
int arr1[] = {1, 3, 5, 7, 9, 11};
int arr2[] = {0, 2, 4, 6, 8, 10};
int expected1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int* result1 = func0(arr1, 6, arr2, 6);
for (int i = 0; i < 12; i++) assert(result1[i] == expected1[i]);
int arr3[] = {1, 3, 5, 6, 8, 9};
int ar... | O3 | c | func0:
endbr64
push %r15
mov %esi,%r15d
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %ecx,%r12d
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,0x8(%rsp)
lea (%rsi,%rcx,1),%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10f0 <malloc@plt>
test %r15d,%r15d
mov 0x8(%rsp),%r8
mov %rax,%r1... | func0:
endbr64
push r15
mov r15d, esi
push r14
push r13
mov r13, rdx
push r12
mov r12d, ecx
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdi
lea edi, [rsi+rcx]
movsxd rdi, edi
shl rdi, 2; size
call _malloc
test r15d, r15d
mov r8, [rsp+48h+var_40]
mov ... | _DWORD * func0(long long a1, int a2, long long a3, int a4)
{
_DWORD *v7; // rax
_DWORD *v9; // r14
long long v10; // rax
int v11; // ebx
int v12; // ebp
long long v13; // rdi
long long i; // rsi
int v15; // ecx
int v16; // edx
long long v17; // r9
int v19; // [rsp+8h] [rbp-40h]
v7 = malloc(4LL ... | func0:
ENDBR64
PUSH R15
MOV R15D,ESI
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
MOV R12D,ECX
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
LEA EDI,[RSI + RCX*0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010f0
TEST R15D,R15D
MOV R8,qword ptr [RSP + 0x8]
MOV R14,RAX
JLE 0x00101558
TEST R12D,R12D
JLE 0x00101558
MO... | void * func0(long param_1,int param_2,long param_3,int param_4)
{
void *pvVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
long lVar7;
long lVar8;
long lVar9;
pvVar1 = malloc((long)(param_2 + param_4) << 2);
if ((param_2 < 1) || (param_4 < 1)) {
lVar9 = 0;
iVar5 = 0;
i... |
7,668 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
| int func0(const char *text) {
for (int i = 0; text[i] != '\0'; i++) {
if (isdigit(text[i])) {
return i;
}
}
return -1;
}
| int main() {
assert(func0("there are 70 flats in this apartment") == 10);
assert(func0("every adult have 32 teeth") == 17);
assert(func0("isha has 79 chocolates in her bag") == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11bc <func0+0x53>
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
ad... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_4], 0
jmp short loc_11BC
loc_1182:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rcx, edx
mov rdx, [rbp+var_18]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add ... | long long func0(long long a1)
{
unsigned int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; *(_BYTE *)((int)i + a1); ++i )
{
if ( ((*__ctype_b_loc())[*(char *)((int)i + a1)] & 0x800) != 0 )
return i;
}
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011bc
LAB_00101182:
CALL 0x00101070
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX... | int func0(long param_1)
{
ushort **ppuVar1;
int local_c;
local_c = 0;
while( true ) {
if (*(char *)(param_1 + local_c) == '\0') {
return -1;
}
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[*(char *)(param_1 + local_c)] & 0x800) != 0) break;
local_c = local_c + 1;
}
return local_c;... |
7,669 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
| int func0(const char *text) {
for (int i = 0; text[i] != '\0'; i++) {
if (isdigit(text[i])) {
return i;
}
}
return -1;
}
| int main() {
assert(func0("there are 70 flats in this apartment") == 10);
assert(func0("every adult have 32 teeth") == 17);
assert(func0("isha has 79 chocolates in her bag") == 9);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%ebx
test %bl,%bl
je 11b2 <func0+0x49>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rcx
mov $0x0,%eax
mov %eax,%edx
movsbq %bl,%rbx
testb $0x8,0x1(%rcx,%rbx,2)
jne 11a9 <func0+0x40>
add $0x1,%rax
movzbl 0x0(%rbp,... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movzx ebx, byte ptr [rdi]
test bl, bl
jz short loc_11B2
mov rbp, rdi
call ___ctype_b_loc
mov rcx, [rax]
mov eax, 0
loc_118A:
mov edx, eax
movsx rbx, bl
test byte ptr [rcx+rbx*2+1], 8
jnz short loc_11A9
add rax, 1
movzx ebx... | long long func0(char *a1)
{
char v1; // bl
long long v2; // rcx
long long v3; // rax
unsigned int v4; // edx
v1 = *a1;
if ( *a1 )
{
v2 = *(_QWORD *)__ctype_b_loc();
v3 = 0LL;
while ( 1 )
{
v4 = v3;
if ( (*(_BYTE *)(v2 + 2LL * v1 + 1) & 8) != 0 )
break;
v1 = a1[+... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EBX,byte ptr [RDI]
TEST BL,BL
JZ 0x001011b2
MOV RBP,RDI
CALL 0x00101070
MOV RCX,qword ptr [RAX]
MOV EAX,0x0
LAB_0010118a:
MOV EDX,EAX
MOVSX RBX,BL
TEST byte ptr [RCX + RBX*0x2 + 0x1],0x8
JNZ 0x001011a9
ADD RAX,0x1
MOVZX EBX,byte ptr [RBP + RAX*0x1]
TEST BL,BL
JNZ 0x001... | ulong func0(char *param_1)
{
ushort **ppuVar1;
ulong uVar2;
char cVar3;
cVar3 = *param_1;
if (cVar3 != '\0') {
ppuVar1 = __ctype_b_loc();
uVar2 = 0;
do {
if ((*(byte *)((long)*ppuVar1 + (long)cVar3 * 2 + 1) & 8) != 0) {
return uVar2 & 0xffffffff;
}
uVar2 = uVar2 + 1;
... |
7,670 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
| int func0(const char *text) {
for (int i = 0; text[i] != '\0'; i++) {
if (isdigit(text[i])) {
return i;
}
}
return -1;
}
| int main() {
assert(func0("there are 70 flats in this apartment") == 10);
assert(func0("every adult have 32 teeth") == 17);
assert(func0("isha has 79 chocolates in her bag") == 9);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1260 <func0+0x50>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rdx
xor %eax,%eax
jmp 1246 <func0+0x36>
nopl 0x0(%rax)
add $0x1,%rax
movsbq 0x0(%rbp,%rax,1),%rbx
test %bl,%bl
je 1260 <func... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1260
mov rbp, rdi
call ___ctype_b_loc
mov rdx, [rax]
xor eax, eax
jmp short loc_1246
loc_1238:
add rax, 1
movsx rbx, byte ptr [rbp+rax+0]
test bl, bl
jz short loc_1260
loc_... | long long func0(char *a1)
{
long long v1; // rbx
long long v2; // rdx
long long result; // rax
v1 = *a1;
if ( !(_BYTE)v1 )
return 0xFFFFFFFFLL;
v2 = *(_QWORD *)__ctype_b_loc();
result = 0LL;
while ( (*(_BYTE *)(v2 + 2 * v1 + 1) & 8) == 0 )
{
v1 = a1[++result];
if ( !(_BYTE)v1 )
ret... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101260
MOV RBP,RDI
CALL 0x00101070
MOV RDX,qword ptr [RAX]
XOR EAX,EAX
JMP 0x00101246
LAB_00101238:
ADD RAX,0x1
MOVSX RBX,byte ptr [RBP + RAX*0x1]
TEST BL,BL
JZ 0x00101260
LAB_00101246:
MOV R8D,EAX
TEST byte ptr [RDX + RBX*0x2 + 0x1... | ulong func0(char *param_1)
{
char cVar1;
ushort **ppuVar2;
ulong uVar3;
cVar1 = *param_1;
if (cVar1 != '\0') {
ppuVar2 = __ctype_b_loc();
uVar3 = 0;
do {
if ((*(byte *)((long)*ppuVar2 + (long)cVar1 * 2 + 1) & 8) != 0) {
return uVar3 & 0xffffffff;
}
uVar3 = uVar3 + 1;
... |
7,671 | func0 |
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
| int func0(const char *text) {
for (int i = 0; text[i] != '\0'; i++) {
if (isdigit(text[i])) {
return i;
}
}
return -1;
}
| int main() {
assert(func0("there are 70 flats in this apartment") == 10);
assert(func0("every adult have 32 teeth") == 17);
assert(func0("isha has 79 chocolates in her bag") == 9);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
movsbq (%rdi),%rbx
test %bl,%bl
je 1260 <func0+0x50>
mov %rdi,%rbp
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rdx
xor %eax,%eax
jmp 1246 <func0+0x36>
nopl 0x0(%rax)
add $0x1,%rax
movsbq 0x0(%rbp,%rax,1),%rbx
test %bl,%bl
je 1260 <func... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
movsx rbx, byte ptr [rdi]
test bl, bl
jz short loc_1258
mov rbp, rdi
call ___ctype_b_loc
mov rdx, [rax]
xor eax, eax
jmp short loc_1246
loc_1238:
add rax, 1
movsx rbx, byte ptr [rbp+rax+0]
test bl, bl
jz short loc_1258
loc_... | long long func0(char *a1)
{
long long v1; // rbx
const unsigned __int16 *v2; // rdx
long long result; // rax
v1 = *a1;
if ( !(_BYTE)v1 )
return 0xFFFFFFFFLL;
v2 = *__ctype_b_loc();
result = 0LL;
while ( (v2[v1] & 0x800) == 0 )
{
v1 = a1[++result];
if ( !(_BYTE)v1 )
return 0xFFFFFFF... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVSX RBX,byte ptr [RDI]
TEST BL,BL
JZ 0x00101258
MOV RBP,RDI
CALL 0x00101070
MOV RDX,qword ptr [RAX]
XOR EAX,EAX
JMP 0x00101246
LAB_00101238:
ADD RAX,0x1
MOVSX RBX,byte ptr [RBP + RAX*0x1]
TEST BL,BL
JZ 0x00101258
LAB_00101246:
TEST byte ptr [RDX + RBX*0x2 + 0x1],0x8
JZ 0x0... | long func0(char *param_1)
{
char cVar1;
ushort **ppuVar2;
long lVar3;
cVar1 = *param_1;
if (cVar1 != '\0') {
ppuVar2 = __ctype_b_loc();
lVar3 = 0;
do {
if ((*(byte *)((long)*ppuVar2 + (long)cVar1 * 2 + 1) & 8) != 0) {
return lVar3;
}
lVar3 = lVar3 + 1;
cVar1 = p... |
7,672 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char **elements;
int size;
} Set;
int set_contains(Set *set, char *element) {
for (int i = 0; i < set->size; i++) {
if (strcmp(set->elements[i], element) == 0)
return 1;
... | Set func0(char *t[], int size) {
Set s;
s.size = size;
s.elements = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
s.elements[i] = strdup(t[i]);
}
return s;
}
| int main() {
char *test1[] = {"x", "y", "z"};
char *test2[] = {"a", "b", "c"};
char *test3[] = {"z", "d", "e"};
Set result1 = func0(test1, 3);
Set expected1 = func0((char *[]){"y", "x", "z"}, 3);
Set result2 = func0(test2, 3);
Set expected2 = func0((char *[]){"c", "a", "b"}, 3... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
mov %eax,-0x18(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10e0 <malloc@plt>
mov %rax,-0x20(%rbp)
movl $0x0,-0x24(%rbp)
jmp 1396 <f... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov eax, [rbp+var_3C]
mov dword ptr [rbp+var_18], eax
mov eax, [rbp+var_3C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_20], rax
mov [rbp+var_24], ... | _QWORD * func0(long long a1, int a2)
{
int i; // [rsp+1Ch] [rbp-24h]
_QWORD *v4; // [rsp+20h] [rbp-20h]
v4 = malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
v4[i] = strdup(*(const char **)(8LL * i + a1));
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x2... | int [16] func0(long param_1,int param_2)
{
int auVar1 [16];
void *pvVar2;
char *pcVar3;
int4 local_2c;
int4 uStack_1c;
pvVar2 = malloc((long)param_2 << 3);
for (local_2c = 0; local_2c < param_2; local_2c = local_2c + 1) {
pcVar3 = strdup(*(char **)(param_1 + (long)local_2c * 8));
*(char **)((... |
7,673 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char **elements;
int size;
} Set;
int set_contains(Set *set, char *element) {
for (int i = 0; i < set->size; i++) {
if (strcmp(set->elements[i], element) == 0)
return 1;
... | Set func0(char *t[], int size) {
Set s;
s.size = size;
s.elements = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
s.elements[i] = strdup(t[i]);
}
return s;
}
| int main() {
char *test1[] = {"x", "y", "z"};
char *test2[] = {"a", "b", "c"};
char *test3[] = {"z", "d", "e"};
Set result1 = func0(test1, 3);
Set expected1 = func0((char *[]){"y", "x", "z"}, 3);
Set result2 = func0(test2, 3);
Set expected2 = func0((char *[]){"c", "a", "b"}, 3... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %esi,%r14d
movslq %esi,%rdi
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%rbp
test %r14d,%r14d
jle 130d <func0+0x49>
lea -0x1(%r14),%r13d
mov $0x0,%ebx
mov (%r12,%rbx,8),%rdi
callq 10f0 <strdup@plt... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov r14d, esi
movsxd rdi, esi
shl rdi, 3
call _malloc
mov rbp, rax
test r14d, r14d
jle short loc_1309
mov r13d, r14d
mov ebx, 0
loc_12F2:
mov rdi, [r12+rbx*8]
call _strdup
mov [rbp+rbx*8... | long long func0(long long a1, int a2)
{
long long v2; // rbp
long long i; // rbx
v2 = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_QWORD *)(v2 + 8 * i) = strdup(*(_QWORD *)(a1 + 8 * i));
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV R14D,ESI
MOVSXD RDI,ESI
SHL RDI,0x3
CALL 0x001010e0
MOV RBP,RAX
TEST R14D,R14D
JLE 0x00101309
MOV R13D,R14D
MOV EBX,0x0
LAB_001012f2:
MOV RDI,qword ptr [R12 + RBX*0x8]
CALL 0x001010f0
MOV qword ptr [RBP + RBX*0x8],RAX
ADD RBX,0x1
CMP RBX,R13
JN... | int1 [16] func0(long param_1,uint param_2)
{
char *pcVar1;
ulong uVar2;
int1 auVar3 [16];
auVar3._0_8_ = malloc((long)(int)param_2 << 3);
if (0 < (int)param_2) {
uVar2 = 0;
do {
pcVar1 = strdup(*(char **)(param_1 + uVar2 * 8));
*(char **)((long)auVar3._0_8_ + uVar2 * 8) = pcVar1;
... |
7,674 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char **elements;
int size;
} Set;
int set_contains(Set *set, char *element) {
for (int i = 0; i < set->size; i++) {
if (strcmp(set->elements[i], element) == 0)
return 1;
... | Set func0(char *t[], int size) {
Set s;
s.size = size;
s.elements = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
s.elements[i] = strdup(t[i]);
}
return s;
}
| int main() {
char *test1[] = {"x", "y", "z"};
char *test2[] = {"a", "b", "c"};
char *test3[] = {"z", "d", "e"};
Set result1 = func0(test1, 3);
Set expected1 = func0((char *[]){"y", "x", "z"}, 3);
Set result2 = func0(test2, 3);
Set expected2 = func0((char *[]){"c", "a", "b"}, 3... | O2 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%r14
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r12
test %r14d,%r14d
jle 15fa <func0+0x4a>
lea -0x1(%r14),%r13d
xor %ebx,%ebx
nopl 0x0(%rax)
mov 0x0(%rbp,%rbx,8),%rdi
call... | func0:
endbr64
push r14
push r13
movsxd r13, esi
push r12
mov r14, r13
push rbp
mov rbp, rdi
lea rdi, ds:0[r13*8]
push rbx
call _malloc
mov r12, rax
test r13d, r13d
jle short loc_1657
xor ebx, ebx
nop dword ptr [rax+00h]
loc_1640:
mov rdi, [rbp+rbx*8+0]
call _str... | long long func0(long long a1, int a2)
{
long long v2; // r12
long long i; // rbx
v2 = malloc(8LL * a2);
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
*(_QWORD *)(v2 + 8 * i) = strdup(*(_QWORD *)(a1 + 8 * i));
}
return v2;
} | func0:
ENDBR64
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOV R14,R13
PUSH RBP
MOV RBP,RDI
LEA RDI,[R13*0x8]
PUSH RBX
CALL 0x001010e0
MOV R12,RAX
TEST R13D,R13D
JLE 0x00101657
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_00101640:
MOV RDI,qword ptr [RBP + RBX*0x8]
CALL 0x001010f0
MOV qword ptr [R12 + RBX*0x8],RAX
ADD RBX,0x1
CMP... | int1 [16] func0(long param_1,int param_2)
{
char *pcVar1;
long lVar2;
int1 auVar3 [16];
auVar3._0_8_ = malloc((long)param_2 * 8);
if (0 < param_2) {
lVar2 = 0;
do {
pcVar1 = strdup(*(char **)(param_1 + lVar2 * 8));
*(char **)((long)auVar3._0_8_ + lVar2 * 8) = pcVar1;
lVar2 = lVa... |
7,675 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char **elements;
int size;
} Set;
int set_contains(Set *set, char *element) {
for (int i = 0; i < set->size; i++) {
if (strcmp(set->elements[i], element) == 0)
return 1;
... | Set func0(char *t[], int size) {
Set s;
s.size = size;
s.elements = malloc(size * sizeof(char*));
for (int i = 0; i < size; i++) {
s.elements[i] = strdup(t[i]);
}
return s;
}
| int main() {
char *test1[] = {"x", "y", "z"};
char *test2[] = {"a", "b", "c"};
char *test3[] = {"z", "d", "e"};
Set result1 = func0(test1, 3);
Set expected1 = func0((char *[]){"y", "x", "z"}, 3);
Set result2 = func0(test2, 3);
Set expected2 = func0((char *[]){"c", "a", "b"}, 3... | O3 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
mov %rdi,%r14
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r12
test %r14d,%r14d
jle 169a <func0+0x4a>
lea -0x1(%r14),%r13d
xor %ebx,%ebx
nopl 0x0(%rax)
mov 0x0(%rbp,%rbx,8),%rdi
call... | func0:
endbr64
push r14
movsxd r14, esi
push r13
push r12
mov r12, r14
shl r14, 3
push rbp
push rbx
mov rbx, rdi
mov rdi, r14; size
call _malloc
mov r13, rax
test r12d, r12d
jle short loc_1679
mov rbp, rax
add r14, rbx
nop
loc_1660:
mov rdi, [rbx]; s
add rbx... | void * func0(const char **a1, int a2)
{
const char **v2; // rbx
void *v3; // rax
void *v4; // r13
_QWORD *v5; // rbp
const char **v6; // r14
const char *v7; // rdi
v2 = a1;
v3 = malloc(8LL * a2);
v4 = v3;
if ( a2 > 0 )
{
v5 = v3;
v6 = &a1[a2];
do
{
v7 = *v2++;
*v5++ = ... | func0:
ENDBR64
PUSH R14
MOVSXD R14,ESI
PUSH R13
PUSH R12
MOV R12,R14
SHL R14,0x3
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RDI,R14
CALL 0x001010e0
MOV R13,RAX
TEST R12D,R12D
JLE 0x00101679
MOV RBP,RAX
ADD R14,RBX
NOP
LAB_00101660:
MOV RDI,qword ptr [RBX]
ADD RBX,0x8
ADD RBP,0x8
CALL 0x001010f0
MOV qword ptr [RBP + -0x8],RAX
CM... | int [16] func0(int8 *param_1,int param_2)
{
char *pcVar1;
int8 *puVar2;
int8 *puVar3;
int auVar4 [16];
auVar4._0_8_ = (int8 *)malloc((long)param_2 * 8);
if (0 < param_2) {
puVar3 = param_1 + param_2;
puVar2 = auVar4._0_8_;
do {
pcVar1 = (char *)*param_1;
param_1 = param_1 + 1;
... |
7,676 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char character;
int count;
int first_index;
} CharCount;
int compare(const void* a, const void* b) {
CharCount* cc1 = (CharCount*)a;
CharCount* cc2 = (CharCount*)b;
if (cc2->count !=... | CharCount* func0(const char* s, int a) {
int counts[256] = {0};
int first_occurrence[256];
for (int i = 0; i < 256; i++)
first_occurrence[i] = -1;
for (int i = 0; s[i]; i++) {
unsigned char c = s[i];
counts[c]++;
if (first_occurrence[c] == -1)
first_o... | int main() {
CharCount* res1 = func0("lkseropewdssafsdfafkpwe", 3);
assert(res1[0].character == 's' && res1[0].count == 4);
assert(res1[1].character == 'e' && res1[1].count == 3);
assert(res1[2].character == 'f' && res1[2].count == 3);
free(res1);
CharCount* res2 = func0("lkseropewdssafs... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x440,%rsp
mov %rdi,-0x1438(%rbp)
mov %esi,-0x143c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x1410(%rbp),%rdx
mov $0x0,%eax
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
mo... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1000h
or [rsp+1000h+var_1000], 0
sub rsp, 440h
mov [rbp+var_1438], rdi
mov [rbp+var_143C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_1410]
mov eax, 0
mov ecx, 80h
mov rdi, rdx
rep stosq
mo... | char * func0(long long a1, int a2)
{
char *v2; // rdx
unsigned __int8 v4; // [rsp+13h] [rbp-142Dh]
int i; // [rsp+14h] [rbp-142Ch]
int j; // [rsp+18h] [rbp-1428h]
int v7; // [rsp+1Ch] [rbp-1424h]
int k; // [rsp+20h] [rbp-1420h]
int m; // [rsp+24h] [rbp-141Ch]
char *v10; // [rsp+28h] [rbp-1418h]
_DWORD... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x440
MOV qword ptr [RBP + -0x1438],RDI
MOV dword ptr [RBP + -0x143c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x1410]
MOV EAX,0x0
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP... | void * func0(long param_1,int param_2)
{
byte bVar1;
void *pvVar2;
long lVar3;
int8 *puVar4;
int *piVar5;
long in_FS_OFFSET;
int local_1434;
int local_1430;
int local_142c;
int local_1428;
int local_1424;
int local_1418 [256];
int aiStack_1018 [256];
int8 local_c18;
int aiStack_c10 [768];... |
7,677 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char character;
int count;
int first_index;
} CharCount;
int compare(const void* a, const void* b) {
CharCount* cc1 = (CharCount*)a;
CharCount* cc2 = (CharCount*)b;
if (cc2->count !=... | CharCount* func0(const char* s, int a) {
int counts[256] = {0};
int first_occurrence[256];
for (int i = 0; i < 256; i++)
first_occurrence[i] = -1;
for (int i = 0; s[i]; i++) {
unsigned char c = s[i];
counts[c]++;
if (first_occurrence[c] == -1)
first_o... | int main() {
CharCount* res1 = func0("lkseropewdssafsdfafkpwe", 3);
assert(res1[0].character == 's' && res1[0].count == 4);
assert(res1[1].character == 'e' && res1[1].count == 3);
assert(res1[2].character == 'f' && res1[2].count == 3);
free(res1);
CharCount* res2 = func0("lkseropewdssafs... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x418,%rsp
mov %rdi,%r8
mov %esi,%ebx
mov %fs:0x28,%rax
mov %rax,0x1408(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x80,%ecx
rep stos %rax,%es:(%rdi)
lea 0x400(%rsp),%rax
lea 0x800(%rsp),%rdx
movl $0xffffffff,... | func0:
endbr64
push rbp
push rbx
sub rsp, 1000h
or [rsp+1010h+var_1010], 0
sub rsp, 418h
mov r8, rdi
mov ebx, esi
mov rax, fs:28h
mov [rsp+1428h+var_20], rax
xor eax, eax
mov rdi, rsp
mov ecx, 80h
rep stosq
lea rax, [rsp+1428h+var_1028]
lea rdx, [rsp+1428h+var_C28]... | long long func0(unsigned __int8 *a1, int a2)
{
_QWORD *v3; // rax
unsigned __int8 v4; // al
long long v5; // rcx
int v6; // esi
long long v7; // rax
int v8; // ebp
int v9; // esi
long long v10; // rdi
long long result; // rax
long long v12; // rdx
_DWORD v13[256]; // [rsp+0h] [rbp-1428h] BYREF
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x418
MOV R8,RDI
MOV EBX,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1408],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x80
STOSQ.REP RDI
LEA RAX,[RSP + 0x400]
LEA RDX,[RSP + 0x800]
LAB_0010122d:
MOV dword ptr [RAX],0xffffffff
ADD RAX,0x4... | void func0(byte *param_1,uint param_2)
{
byte bVar1;
int *piVar2;
void *pvVar3;
int iVar4;
long lVar5;
long lVar6;
uint uVar7;
long in_FS_OFFSET;
int local_1428 [256];
int local_1028 [256];
int local_c28 [770];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
piVar2 = local_1428... |
7,678 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char character;
int count;
int first_index;
} CharCount;
int compare(const void* a, const void* b) {
CharCount* cc1 = (CharCount*)a;
CharCount* cc2 = (CharCount*)b;
if (cc2->count !=... | CharCount* func0(const char* s, int a) {
int counts[256] = {0};
int first_occurrence[256];
for (int i = 0; i < 256; i++)
first_occurrence[i] = -1;
for (int i = 0; s[i]; i++) {
unsigned char c = s[i];
counts[c]++;
if (first_occurrence[c] == -1)
first_o... | int main() {
CharCount* res1 = func0("lkseropewdssafsdfafkpwe", 3);
assert(res1[0].character == 's' && res1[0].count == 4);
assert(res1[1].character == 'e' && res1[1].count == 3);
assert(res1[2].character == 'f' && res1[2].count == 3);
free(res1);
CharCount* res2 = func0("lkseropewdssafs... | O2 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x410,%rsp
mov $0x80,%ecx
mov %fs:0x28,%rax
mov %rax,0x1408(%rsp)
xor %eax,%eax
mov %esi,%ebx
mov %rsp,%rsi
mov %rdi,%r8
mov %rsi,%rdi
lea 0x800(%rsp),%r12
rep stos %rax,%es:(%rdi)
lea 0x400(%... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 1000h
or [rsp+1018h+var_1018], 0
sub rsp, 410h
mov ecx, 80h
mov rax, fs:28h
mov [rsp+1428h+var_20], rax
xor eax, eax
mov ebp, esi
mov rsi, rsp
mov r9, rdi
lea r8, [rsp+1428h+var_1028]
mov rdi, rsi
rep stosq
mov ... | long long func0(unsigned __int8 *a1, int a2)
{
long long v2; // rcx
long long i; // rax
int v4; // edx
long long v5; // rax
int v6; // ebx
int v7; // ecx
long long v8; // rdx
int v9; // ecx
long long v10; // rax
long long v11; // rcx
long long v12; // r8
_DWORD v14[256]; // [rsp+0h] [rbp-1428h]... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x410
MOV ECX,0x80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1408],RAX
XOR EAX,EAX
MOV EBP,ESI
MOV RSI,RSP
MOV R9,RDI
LEA R8,[RSP + 0x400]
MOV RDI,RSI
STOSQ.REP RDI
MOV RAX,-0x1
MOV ECX,0x80
MOV RDI,R8
STOSQ.REP RDI
MOVZX E... | void * func0(byte *param_1,int param_2)
{
byte bVar1;
int iVar2;
void *__dest;
long lVar3;
long lVar4;
int iVar5;
int *piVar6;
long in_FS_OFFSET;
int aiStack_1428 [256];
int local_1028 [256];
int1 local_c28 [4];
int aiStack_c24 [769];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x... |
7,679 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char character;
int count;
int first_index;
} CharCount;
int compare(const void* a, const void* b) {
CharCount* cc1 = (CharCount*)a;
CharCount* cc2 = (CharCount*)b;
if (cc2->count !=... | CharCount* func0(const char* s, int a) {
int counts[256] = {0};
int first_occurrence[256];
for (int i = 0; i < 256; i++)
first_occurrence[i] = -1;
for (int i = 0; s[i]; i++) {
unsigned char c = s[i];
counts[c]++;
if (first_occurrence[c] == -1)
first_o... | int main() {
CharCount* res1 = func0("lkseropewdssafsdfafkpwe", 3);
assert(res1[0].character == 's' && res1[0].count == 4);
assert(res1[1].character == 'e' && res1[1].count == 3);
assert(res1[2].character == 'f' && res1[2].count == 3);
free(res1);
CharCount* res2 = func0("lkseropewdssafs... | O3 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x410,%rsp
mov $0x80,%ecx
mov %fs:0x28,%rax
mov %rax,0x1408(%rsp)
xor %eax,%eax
mov %esi,%ebp
mov %rsp,%rsi
mov %rdi,%r9
lea 0x400(%rsp),%r8
mov %rsi,%rdi
rep stos %rax,%es:(%rdi)
mov $0xfffff... | func0:
endbr64
push r12
push rbp
push rbx
sub rsp, 1000h
or [rsp+1018h+var_1018], 0
sub rsp, 410h
mov ecx, 80h
xor edx, edx
mov rax, fs:28h
mov [rsp+1428h+var_20], rax
xor eax, eax
mov ebx, esi
mov rsi, rsp
mov r9, rdi
lea r8, [rsp+1428h+var_1028]
mov rdi, r... | void * func0(unsigned __int8 *a1, int a2)
{
long long v2; // rdx
long long i; // rax
int v4; // ecx
long long v5; // rax
long long v6; // rbp
signed int v7; // edx
long long v8; // rcx
unsigned long long v9; // xmm0_8
void *v10; // rax
void *v11; // rcx
_DWORD v13[256]; // [rsp+0h] [rbp-1428h] BYR... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x410
MOV ECX,0x80
XOR EDX,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1408],RAX
XOR EAX,EAX
MOV EBX,ESI
MOV RSI,RSP
MOV R9,RDI
LEA R8,[RSP + 0x400]
MOV RDI,RSI
STOSQ.REP RDI
MOV RAX,-0x1
MOV ECX,0x80
MOV RDI,R8
STOSQ.REP... | void * func0(byte *param_1,uint param_2)
{
byte bVar1;
int iVar2;
int iVar3;
void *__dest;
long lVar4;
long lVar5;
int iVar6;
ulong uVar7;
int *piVar8;
long in_FS_OFFSET;
int local_1428 [256];
int local_1028 [256];
int local_c28 [4];
int8 auStack_c24 [384];
long local_20;
lVar5 = 0;
... |
7,680 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char *list1[], int n) {
int min = strlen(list1[0]);
for (int i = 0; i < n; i++) {
if (strlen(list1[i]) < min) {
min = strlen(list1[i]);
}
}
return min;
}
| int main() {
char *list1[] = {"win", "lose", "great"};
char *list2[] = {"a", "ab", "abc"};
char *list3[] = {"12", "12", "1234"};
assert(func0(list1, 3) == 3);
assert(func0(list2, 3) == 1);
assert(func0(list3, 3) == 2);
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_1209
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 ( strlen(a1[i]) < (int)v3 )
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 0x00101209
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 (sVar1 < (ulong)(long)local_10) {
sVar1 = strl... |
7,681 | func0 |
#include <assert.h>
#include <string.h>
| int func0(char *list1[], int n) {
int min = strlen(list1[0]);
for (int i = 0; i < n; i++) {
if (strlen(list1[i]) < min) {
min = strlen(list1[i]);
}
}
return min;
}
| int main() {
char *list1[] = {"win", "lose", "great"};
char *list2[] = {"a", "ab", "abc"};
char *list3[] = {"12", "12", "1234"};
assert(func0(list1, 3) == 3);
assert(func0(list2, 3) == 1);
assert(func0(list3, 3) == 2);
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
CMOVC ... | 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 (sVar2 < (ulong)(long)(int)uVar3) ... |
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.