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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
3,882 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(int n, int a, int b, int c) {
std::vector<int> dp(n + 10, -1);
dp[0] = 0;
for (int i = 0; i < n; i++) {
if (dp[i] != -1) {
if (i + a <= n) {
dp[i + a] = std::max(dp[i] + 1, dp[i + a]);
}
if (i + b <= n) {
dp[i + b... | int main() {
assert(func0(7, 5, 2, 5) == 2);
assert(func0(17, 2, 1, 3) == 17);
assert(func0(18, 16, 3, 6) == 6);
return 0;
}
| O2 | cpp | func0(int, int, int, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r14
lea 0xa(%rdi),%r14d
movslq %r14d,%r14
push %r13
push %r12
push %rbp
push %rbx
cmp %rax,%r14
ja 141d <_Z5func0iiii+0x11d>
test %r14,%r14
je 1410 <_Z5func0iiii+0x110>
shl $0x2,%r14
mov %edi,%ebx
mov %esi,%ebp
m... | _Z5func0iiii:
endbr64
push r15
push r14
push r13
push r12
lea r12d, [rdi+0Ah]
push rbp
movsxd r12, r12d
push rbx
mov rax, r12
sub rsp, 8
shr rax, 3Dh
jnz loc_13BD
test r12, r12
jz loc_13B0
shl r12, 2
mov ebp, edi
mov r13d, esi
mov r14d, edx
mov rdi, r12... | long long func0(int a1, int a2, int a3, int a4)
{
unsigned long long v4; // r12
_DWORD *v8; // rbx
char *v9; // rdi
int v10; // ecx
int v11; // edx
long long v12; // r8
int v14; // esi
int *v15; // r9
int *v16; // r9
int v17; // esi
int *v18; // r9
int v19; // esi
unsigned int v20; // ebx
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
LEA R12D,[RDI + 0xa]
PUSH RBP
MOVSXD R12,R12D
PUSH RBX
MOV RAX,R12
SUB RSP,0x8
SHR RAX,0x3d
JNZ 0x001013bd
TEST R12,R12
JZ 0x001013b0
SHL R12,0x2
MOV EBP,EDI
MOV R13D,ESI
MOV R14D,EDX
MOV RDI,R12
MOV R15D,ECX
CALL 0x001010c0
MOV RDX,R12
MOV ESI,0xff
MOV RBX,RAX
MOV RDI... | /* WARNING: Control flow encountered bad instruction data */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int, int, int) */
int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
code *pcVar2;
int *__s;
int *piVar3;
int iVar4;
ulong uV... |
3,883 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(int n, int a, int b, int c) {
std::vector<int> dp(n + 10, -1);
dp[0] = 0;
for (int i = 0; i < n; i++) {
if (dp[i] != -1) {
if (i + a <= n) {
dp[i + a] = std::max(dp[i] + 1, dp[i + a]);
}
if (i + b <= n) {
dp[i + b... | int main() {
assert(func0(7, 5, 2, 5) == 2);
assert(func0(17, 2, 1, 3) == 17);
assert(func0(18, 16, 3, 6) == 6);
return 0;
}
| O3 | cpp | func0(int, int, int, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r14
lea 0xa(%rdi),%r14d
movslq %r14d,%r14
push %r13
push %r12
push %rbp
push %rbx
cmp %rax,%r14
ja 1425 <_Z5func0iiii+0x105>
test %r14,%r14
je 1418 <_Z5func0iiii+0xf8>
shl $0x2,%r14
mov %edi,%ebx
mov %esi,%ebp
mo... | _Z5func0iiii:
endbr64
push r15
push r14
push r13
push r12
lea r12d, [rdi+0Ah]
push rbp
movsxd r12, r12d
push rbx
mov rax, r12
sub rsp, 8
shr rax, 3Dh
jnz loc_13BD
test r12, r12
jz loc_13B0
shl r12, 2
mov ebp, edi
mov r13d, esi
mov r14d, edx
mov rdi, r12... | long long func0(int a1, int a2, int a3, int a4)
{
unsigned long long v4; // r12
_DWORD *v8; // rbx
char *v9; // rdi
int v10; // ecx
int v11; // edx
long long v12; // r8
int v14; // esi
int *v15; // r9
int *v16; // r9
int v17; // esi
int *v18; // r9
int v19; // esi
unsigned int v20; // ebx
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
LEA R12D,[RDI + 0xa]
PUSH RBP
MOVSXD R12,R12D
PUSH RBX
MOV RAX,R12
SUB RSP,0x8
SHR RAX,0x3d
JNZ 0x001013bd
TEST R12,R12
JZ 0x001013b0
SHL R12,0x2
MOV EBP,EDI
MOV R13D,ESI
MOV R14D,EDX
MOV RDI,R12
MOV R15D,ECX
CALL 0x001010c0
MOV RDX,R12
MOV ESI,0xff
MOV RBX,RAX
MOV RDI... | /* WARNING: Control flow encountered bad instruction data */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int, int, int) */
int func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
code *pcVar2;
int *__s;
int *piVar3;
int iVar4;
ulong uV... |
3,884 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> test_tup1, std::vector<int> test_tup2) {
std::vector<int> res = test_tup1;
res.insert(res.end(), test_tup2.begin(), test_tup2.end());
return res;
}
| int main() {
assert((func0({3, 4}, {5, 6}) == std::vector<int>{3, 4, 5, 6}));
assert((func0({1, 2}, {3, 4}) == std::vector<int>{1, 2, 3, 4}));
assert((func0({4, 5}, {6, 8}) == std::vector<int>{4, 5, 6, 8}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x40(%rbp),%... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rdx, [rbp+var_40]
mov rax, [rbp+var_38]
mov rsi, rdx
mo... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // r12
long long v4; // rbx
long long v7; // [rsp+28h] [rbp-28h] BYREF
_QWORD v8[4]; // [rsp+30h] [rbp-20h] BYREF
v8[1] = __readfsqword(0x28u);
std::vector<int>::vector(a1, a2);
v3 = std::vector<int>::end(a3);
v4 = std::vector<i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RDX
MOV RDI,R... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1,vector param_2)
{
int8 uVar1;
int8 uVar2;
vector<int,std::allocator<int>> *in_RDX;
int4 in_register_00000034;
int4 in_register_0000003c;
vector<int,std::alloca... |
3,885 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> test_tup1, std::vector<int> test_tup2) {
std::vector<int> res = test_tup1;
res.insert(res.end(), test_tup2.begin(), test_tup2.end());
return res;
}
| int main() {
assert((func0({3, 4}, {5, 6}) == std::vector<int>{3, 4, 5, 6}));
assert((func0({1, 2}, {3, 4}) == std::vector<int>{1, 2, 3, 4}));
assert((func0({4, 5}, {6, 8}) == std::vector<int>{4, 5, 6, 8}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %rsi,%r14
mov %rdx,%r13
mov 0x8(%rsi),%r12
sub (%rsi),%r12
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov %r... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
mov r14, rsi
mov r13, rdx
mov r12, [rsi+8]
sub r12, [rsi]
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
jz short loc_1301
mov rax, 7FFFFFFF... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
unsigned long long v5; // r12
_DWORD *v6; // rbp
_DWORD *v7; // rsi
long long v8; // r12
v5 = a2[1] - *a2;
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
if ( v5 )
{
if ( v5 <= 0x7FFFFFFFFFFFFFFCLL )
{
v6 = (_DWORD *)operator new(v5);
g... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV R14,RSI
MOV R13,RDX
MOV R12,qword ptr [RSI + 0x8]
SUB R12,qword ptr [RSI]
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
JZ 0x00101301
MOV RAX,0x7ffffffffffffffc
CMP RAX,R12
JC 0x001012fc
MOV RDI,R12
LAB_00... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1,vector param_2)
{
int4 *__src;
int4 *__dest;
int8 *in_RDX;
int4 in_register_00000034;
long *plVar1;
int4 in_register_0000003c;
int8 *puVar2;
ulong uVar3;
size_t __n;
puVar2 = ... |
3,886 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> test_tup1, std::vector<int> test_tup2) {
std::vector<int> res = test_tup1;
res.insert(res.end(), test_tup2.begin(), test_tup2.end());
return res;
}
| int main() {
assert((func0({3, 4}, {5, 6}) == std::vector<int>{3, 4, 5, 6}));
assert((func0({1, 2}, {3, 4}) == std::vector<int>{1, 2, 3, 4}));
assert((func0({4, 5}, {6, 8}) == std::vector<int>{4, 5, 6, 8}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rsi),%rbx
sub (%rsi),%rbx
movq $0x0,(%rdi)
mov %rbx,%rax
movq $0x0,0x8(%rdi)
sar $0x... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rdx
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 18h
mov rcx, [rsi+8]
sub rcx, [rsi]
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
jz loc_17E0
mov... | _QWORD * func0(char *a1, _QWORD *a2, char *a3)
{
signed long long v3; // r13
_QWORD *v6; // rbx
unsigned long long v7; // rcx
_DWORD *v8; // rax
_DWORD *v9; // r12
_DWORD *v10; // rsi
signed long long v11; // rbp
unsigned long long v12; // r14
char *v13; // r13
bool v14; // zf
long long v16; // ra... | func0:
MOV RDI,RBX
CALL 0x001019c0
MOV RDI,RBP
LAB_0010118b:
CALL 0x00101170 | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) [clone
.cold] */
void func0(vector param_1,vector param_2)
{
vector<int,std::allocator<int>> *unaff_RBX;
std::vector<int,std::allocator<int>>::~vector(unaff_RBX);
/* WARNING: Subroutine does not retu... |
3,887 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> test_tup1, std::vector<int> test_tup2) {
std::vector<int> res = test_tup1;
res.insert(res.end(), test_tup2.begin(), test_tup2.end());
return res;
}
| int main() {
assert((func0({3, 4}, {5, 6}) == std::vector<int>{3, 4, 5, 6}));
assert((func0({1, 2}, {3, 4}) == std::vector<int>{1, 2, 3, 4}));
assert((func0({4, 5}, {6, 8}) == std::vector<int>{4, 5, 6, 8}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
mov %rdx,%r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x28,%rsp
mov 0x8(%rsi),%rbx
sub (%rsi),%rbx
movups %xmm0,(%rdi)
mov ... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rdx
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 18h
mov rcx, [rsi+8]
sub rcx, [rsi]
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
jz loc_17E0
mov... | _QWORD * func0(char *a1, _QWORD *a2, char *a3)
{
signed long long v3; // r13
_QWORD *v6; // rbx
unsigned long long v7; // rcx
_DWORD *v8; // rax
_DWORD *v9; // r12
_DWORD *v10; // rsi
signed long long v11; // rbp
unsigned long long v12; // r14
char *v13; // r13
bool v14; // zf
long long v16; // ra... | func0:
MOV RDI,RBX
CALL 0x001019c0
MOV RDI,RBP
LAB_0010118b:
CALL 0x00101170 | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) [clone
.cold] */
void func0(vector param_1,vector param_2)
{
vector<int,std::allocator<int>> *unaff_RBX;
std::vector<int,std::allocator<int>>::~vector(unaff_RBX);
/* WARNING: Subroutine does not retu... |
3,888 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string s, int d) {
std::string tmp = s.substr(d) + s.substr(0, d);
return tmp;
}
| int main() {
assert(func0("python", 2) == "thonpy");
assert(func0("bigdata", 3) == "databig");
assert(func0("hadoop", 1) == "adooph");
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %edx,-0x74(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x74(%rbp),%eax
mo... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_74], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_74]
movsxd rdx, eax
lea ... | long long func0(long long a1, long long a2, int a3)
{
_BYTE v5[32]; // [rsp+20h] [rbp-60h] BYREF
_BYTE v6[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v7; // [rsp+68h] [rbp-18h]
v7 = __readfsqword(0x28u);
std::string::substr(v6, a2, 0LL, a3);
std::string::substr(v5, a2, a3, -1LL);
std::operator+... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV dword ptr [RBP + -0x74],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x74]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x40]
MOV RSI,qword ptr [RBP + ... | /* func0(std::string, int) */
int8 func0(int8 param_1,ulong param_2)
{
long in_FS_OFFSET;
string local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::string::substr((ulong)local_48,param_2);
/* try { // try from 00102466 to 0010246a has... |
3,889 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string s, int d) {
std::string tmp = s.substr(d) + s.substr(0, d);
return tmp;
}
| int main() {
assert(func0("python", 2) == "thonpy");
assert(func0("bigdata", 3) == "databig");
assert(func0("hadoop", 1) == "adooph");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %rdi,%rbx
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
movslq %edx,%rbp
mov 0x8(%rsi),%rdx
lea 0x20(%rsp),%rdi
lea 0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push r12
push rbp
push rbx
sub rsp, 50h
mov rbx, rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
movsxd rbp, edx
lea rdi, [rsp+68h+var_48]
lea rax, [rsp+68h+var_38]
mov [rsp+68h+v... | char ** func0(char **a1, long long *a2, int a3)
{
unsigned long long v4; // rbp
long long v5; // rsi
unsigned long long v6; // rdx
unsigned long long v7; // rdx
unsigned long long v8; // rax
unsigned long long v9; // rsi
unsigned long long v10; // rsi
char **v11; // rax
char **v12; // rax
_QWORD *v1... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV RBX,RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOVSXD RBP,EDX
LEA RDI,[RSP + 0x20]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
MOV RSI,qword ptr [RSI]
MOV RDX,qword ptr [R12 + 0x8]
CMP RBP,RDX
CMOVBE RDX,RBP
A... | /* func0(std::string, int) */
long * func0(long *param_1,long *param_2,int param_3)
{
long *plVar1;
long *plVar2;
int8 uVar3;
uint uVar4;
long lVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
long in_FS_OFFSET;
ulong *local_68;
long local_60;
ulong local_58 [2];
ulong *local_48;
ulong local_40... |
3,890 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string s, int d) {
std::string tmp = s.substr(d) + s.substr(0, d);
return tmp;
}
| int main() {
assert(func0("python", 2) == "thonpy");
assert(func0("bigdata", 3) == "databig");
assert(func0("hadoop", 1) == "adooph");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r15
mov %rsi,%rax
push %r14
push %r13
movslq %edx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x68,%rsp
mov 0x8(%rsi),%rdx
mov (%rsi),%rsi
mov %fs:0x28,%rbx
mov %rbx,0x58... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
push rbp
movsxd rbp, edx
push rbx
mov rbx, rdi
sub rsp, 68h
mov rdx, [r13+8]
mov rsi, [rsi]
mov rcx, fs:28h
mov [rsp+98h+var_40], rcx
xor ecx, ecx
le... | char ** func0(char **a1, long long *a2, int a3)
{
unsigned long long v4; // rbp
unsigned long long v6; // rdx
long long v7; // rsi
long long v8; // rcx
unsigned long long v9; // rdx
long long v10; // rsi
unsigned long long v11; // rax
unsigned long long v12; // rdi
char **v13; // rax
_QWORD *v14; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
MOVSXD RBP,EDX
PUSH RBX
MOV RBX,RDI
SUB RSP,0x68
MOV RDX,qword ptr [R13 + 0x8]
MOV RSI,qword ptr [RSI]
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RCX
XOR ECX,ECX
LEA RDI,[RSP + 0x30]
LEA R12,[RSP + 0x40]
CMP RBP,RDX
MOV qword ptr [RSP +... | /* func0(std::string, int) */
long * func0(long *param_1,long *param_2,int param_3)
{
long *plVar1;
int8 uVar2;
uint uVar3;
long lVar4;
uint uVar5;
long *plVar6;
ulong uVar7;
ulong uVar8;
long *plVar9;
long in_FS_OFFSET;
ulong *local_88;
long local_80;
ulong local_78 [2];
ulong *local_68;
... |
3,891 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string s, int d) {
std::string tmp = s.substr(d) + s.substr(0, d);
return tmp;
}
| int main() {
assert(func0("python", 2) == "thonpy");
assert(func0("bigdata", 3) == "databig");
assert(func0("hadoop", 1) == "adooph");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r15
movslq %edx,%r15
mov %rsi,%rcx
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov 0x8(%rsi),%r12
mov (%rsi),%rbx
mov %fs:0x28,%rax
mov %rax,0x68... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push r15
movsxd r8, edx
mov r15, rsi
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 78h
mov rbx, [rsi+8]
mov r12, [rsi]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
le... | char ** func0(char **a1, long long a2, int a3)
{
unsigned long long v3; // r8
size_t v5; // rbx
_BYTE *v6; // r12
_QWORD *v7; // rax
unsigned long long v8; // rbx
_BYTE *v9; // rax
size_t v10; // rbx
_BYTE *v11; // rax
const void *v12; // r15
_QWORD *v13; // rax
unsigned long long v14; // rax
un... | func0:
ENDBR64
PUSH R15
MOVSXD R8,EDX
MOV R15,RSI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x78
MOV RBX,qword ptr [RSI + 0x8]
MOV R12,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA R13,[RSP + 0x50]
LEA RAX,[RSP + 0x40]
CMP R8,RBX
MOV qword ptr [RSP],RA... | /* func0(std::string, int) */
long * func0(long *param_1,long *param_2,int param_3)
{
long *plVar1;
ulong *__dest;
uint uVar2;
long lVar3;
uint uVar4;
long *plVar5;
ulong uVar6;
long *plVar7;
ulong uVar8;
ulong *__src;
long in_FS_OFFSET;
ulong local_90;
ulong *local_88;
ulong local_80;
u... |
3,892 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<std::vector<int>> A) {
int n = A.size();
std::vector<int> memo(n, 0);
int lastRow = n - 1;
for(int i = 0; i < A[lastRow].size(); ++i) {
memo[i] = A[lastRow][i];
}
for(int i = lastRow - 1; i >= 0; --i) {
for(int j = 0; j < A[i].size(); ++j) {
... | int main() {
assert(func0({{2}, {3, 9}, {1, 6, 7}}) == 6);
assert(func0({{2}, {3, 7}, {8, 5, 6}}) == 10);
assert(func0({{3}, {6, 4}, {5, 2, 7}}) == 9);
return 0;
}
| O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x50,%rsp
mov %rdi,-0x58(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x58(%rbp),%rax
mov %rax,%... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 60h
mov [rbp+var_68], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_68]
mov rdi, rax
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EE4sizeEv; std::vector<std::vector... | long long func0(long long a1)
{
long long v1; // rax
int v2; // ebx
unsigned long long v3; // rbx
long long v4; // rax
long long v5; // rax
int v6; // ebx
long long v7; // r12
long long v8; // rax
int v9; // ebx
unsigned long long v10; // rbx
long long v11; // rax
unsigned int v12; // ebx
cha... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x60
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RDI,RAX
CALL 0x00101e2c
MOV dword ptr [RBP + -0x40],EAX
LEA RAX,[RBP + -0x51]
MOV qword ptr [RBP + -0x38],RAX
NOP... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
int4 func0(vector param_1)
{
int iVar1;
int iVar2;
int4 uVar3;
vector<int,std::allocator<int>> *pvVar4;
ulong uVar5;
int *piVar6;
int *piVar7;
int4 *puVar8;
ulong uVar9;
in... |
3,893 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<std::vector<int>> A) {
int n = A.size();
std::vector<int> memo(n, 0);
int lastRow = n - 1;
for(int i = 0; i < A[lastRow].size(); ++i) {
memo[i] = A[lastRow][i];
}
for(int i = lastRow - 1; i >= 0; --i) {
for(int j = 0; j < A[i].size(); ++j) {
... | int main() {
assert(func0({{2}, {3, 9}, {1, 6, 7}}) == 6);
assert(func0({{2}, {3, 7}, {8, 5, 6}}) == 10);
assert(func0({{3}, {6, 4}, {5, 2, 7}}) == 9);
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rdi),%rbx
sub (%rdi),%rbx
sar $0x3,%rbx
movabs $0xaaaaaaaaaaaaaaab,%rax
imul %rax,%rbx
movslq %ebx,%rbp
movab... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, [rdi+8]
sub rbp, [rdi]
sar rbp, 3
mov rax, 0AAAAAAAAAAAAAAABh
imul rbp, rax
movsxd r12, ebp
mov rax, r12
shr rax, 3Dh
jnz loc_137A
mov r13, rdi
test r12, r12
jz ... | long long func0(long long *a1)
{
unsigned long long v1; // rbp
unsigned long long v3; // rbx
unsigned int *v4; // rax
unsigned int *v5; // r10
unsigned int *v6; // rdx
long long v7; // rdi
long long *v8; // rsi
long long v9; // rcx
unsigned long long v10; // rdx
long long *v11; // r9
long long v1... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,qword ptr [RDI + 0x8]
SUB RBP,qword ptr [RDI]
SAR RBP,0x3
MOV RAX,-0x5555555555555555
IMUL RBP,RAX
MOVSXD R12,EBP
MOV RAX,R12
SHR RAX,0x3d
JNZ 0x0010137a
MOV R13,RDI
TEST R12,R12
JZ 0x00101386
LEA RBX,[R12*0x4]
MOV RDI,RBX
CALL 0x00101150
MOV R10,RA... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
int func0(vector param_1)
{
long lVar1;
int *piVar2;
int *piVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
int iVar7;
int *piVar8;
int4 in_register_0000003c;
long *plVar9;
u... |
3,894 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<std::vector<int>> A) {
int n = A.size();
std::vector<int> memo(n, 0);
int lastRow = n - 1;
for(int i = 0; i < A[lastRow].size(); ++i) {
memo[i] = A[lastRow][i];
}
for(int i = lastRow - 1; i >= 0; --i) {
for(int j = 0; j < A[i].size(); ++j) {
... | int main() {
assert(func0({{2}, {3, 9}, {1, 6, 7}}) == 6);
assert(func0({{2}, {3, 7}, {8, 5, 6}}) == 10);
assert(func0({{3}, {6, 4}, {5, 2, 7}}) == 9);
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
movabs $0xaaaaaaaaaaaaaaab,%rax
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov (%rdi),%rsi
mov 0x8(%rdi),%rbx
sub %rsi,%rbx
sar $0x3,%rbx
imul %rax,%rbx
movab... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rax, 0AAAAAAAAAAAAAAABh
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r8, [rdi]
mov rbp, [rdi+8]
sub rbp, r8
sar rbp, 3
imul rbp, rax
movsxd r13, ebp
mov rax, r13
shr rax, 3Dh
jnz loc_1923
test r13, r13
jz ... | long long func0(long long *a1)
{
long long v1; // r8
unsigned long long v2; // rbp
unsigned long long v3; // rbx
void *v4; // rax
unsigned int *v5; // rax
unsigned int *v6; // rdi
long long *v7; // rax
long long v8; // rdx
long long v9; // rcx
unsigned long long v10; // rax
long long *v11; // r9
... | func0:
ENDBR64
MOV RAX,-0x5555555555555555
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R8,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
SUB RBP,R8
SAR RBP,0x3
IMUL RBP,RAX
MOVSXD R13,EBP
MOV RAX,R13
SHR RAX,0x3d
JNZ 0x00101923
TEST R13,R13
JZ 0x0010191a
LEA RBX,[R13*0x4]
MOV R12,RDI
MOV RDI,RBX
CALL 0x00101190
... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
void * func0(vector param_1)
{
uint uVar1;
long lVar2;
long lVar3;
void *pvVar4;
uint *puVar5;
ulong uVar6;
void *extraout_RAX;
uint uVar7;
ulong __n;
int iVar8;
int4 in_... |
3,895 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<std::vector<int>> A) {
int n = A.size();
std::vector<int> memo(n, 0);
int lastRow = n - 1;
for(int i = 0; i < A[lastRow].size(); ++i) {
memo[i] = A[lastRow][i];
}
for(int i = lastRow - 1; i >= 0; --i) {
for(int j = 0; j < A[i].size(); ++j) {
... | int main() {
assert(func0({{2}, {3, 9}, {1, 6, 7}}) == 6);
assert(func0({{2}, {3, 7}, {8, 5, 6}}) == 10);
assert(func0({{3}, {6, 4}, {5, 2, 7}}) == 9);
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
movabs $0xaaaaaaaaaaaaaaab,%rax
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov (%rdi),%rcx
mov 0x8(%rdi),%rbx
sub %rcx,%rbx
sar $0x3,%rbx
imul %rax,%rbx
movab... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rax, 0AAAAAAAAAAAAAAABh
push r14
push r13
push r12
push rbp
push rbx
mov r10, [rdi]
mov rbp, [rdi+8]
sub rbp, r10
sar rbp, 3
imul rbp, rax
movsxd r13, ebp
mov rax, r13
shr rax, 3Dh
jnz loc_1BA8
test r13, r13
jz ... | long long func0(long long *a1)
{
long long v1; // r10
unsigned long long v2; // rbp
unsigned long long v3; // rbx
void *v4; // rax
char *v5; // rax
char *v6; // rdi
char **v7; // rdx
char *v8; // rax
char *v9; // rdx
unsigned long long v10; // rsi
unsigned long long v11; // rax
long long *v12; ... | func0:
ENDBR64
MOV RAX,-0x5555555555555555
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R10,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
SUB RBP,R10
SAR RBP,0x3
IMUL RBP,RAX
MOVSXD R13,EBP
MOV RAX,R13
SHR RAX,0x3d
JNZ 0x00101ba8
TEST R13,R13
JZ 0x00101b85
LEA RBX,[R13*0x4]
MOV R12,RDI
MOV RDI,RBX
CALL 0x00101190
M... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
void * func0(vector param_1)
{
int8 *puVar1;
int *piVar2;
int *piVar3;
uint *puVar4;
uint *puVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
int iVar10;
int iVar11;... |
3,896 | func0 |
#include <assert.h>
#define R 3
#define C 3
| int func0(int cost[R][C], int m, int n) {
int tc[R][C];
tc[0][0] = cost[0][0];
for (int i = 1; i <= m; ++i) {
tc[i][0] = tc[i - 1][0] + cost[i][0];
}
for (int j = 1; j <= n; ++j) {
tc[0][j] = tc[0][j - 1] + cost[0][j];
}
for (int i = 1; i <= m; ++i) {
... | int main() {
int cost1[R][C] = {{1, 2, 3}, {4, 8, 2}, {1, 5, 3}};
int cost2[R][C] = {{2, 3, 4}, {5, 9, 3}, {2, 6, 4}};
int cost3[R][C] = {{3, 4, 5}, {6, 10, 4}, {3, 7, 5}};
assert(func0(cost1, 2, 2) == 8);
assert(func0(cost2, 2, 2) == 12);
assert(func0(cost3, 2, 2) == 16);
return ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x60,%rsp
mov %rdi,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %edx,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x58(%rbp),%rax
mov (%rax),%eax
mov %eax,-0x30(%rbp)
movl $0x1,-0x44(%rbp)
jmp 1200 <func0+0x97>
mov -0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov [rbp+var_60], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_58]
mov eax, [rax]
mov [rbp+var_30], eax
mov [rbp+var_44], 1
jmp short loc_1200
l... | long long func0(_DWORD *a1, int a2, int a3)
{
int i; // [rsp+1Ch] [rbp-44h]
int j; // [rsp+20h] [rbp-40h]
int k; // [rsp+24h] [rbp-3Ch]
int m; // [rsp+28h] [rbp-38h]
int v8; // [rsp+2Ch] [rbp-34h]
_DWORD v9[10]; // [rsp+30h] [rbp-30h]
unsigned long long v10; // [rsp+58h] [rbp-8h]
v10 = __readfsqword(0... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV dword ptr [RBP + -0x60],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x30],EAX
MOV dword ptr [R... | int func0(int *param_1,int param_2,int param_3)
{
long in_FS_OFFSET;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
int local_38 [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_38[0] = *param_1;
for (local_4c = 1; local_4c <= param_2; local_4c = loc... |
3,897 | func0 |
#include <assert.h>
#define R 3
#define C 3
| int func0(int cost[R][C], int m, int n) {
int tc[R][C];
tc[0][0] = cost[0][0];
for (int i = 1; i <= m; ++i) {
tc[i][0] = tc[i - 1][0] + cost[i][0];
}
for (int j = 1; j <= n; ++j) {
tc[0][j] = tc[0][j - 1] + cost[0][j];
}
for (int i = 1; i <= m; ++i) {
... | int main() {
int cost1[R][C] = {{1, 2, 3}, {4, 8, 2}, {1, 5, 3}};
int cost2[R][C] = {{2, 3, 4}, {5, 9, 3}, {2, 6, 4}};
int cost3[R][C] = {{3, 4, 5}, {6, 10, 4}, {3, 7, 5}};
assert(func0(cost1, 2, 2) == 8);
assert(func0(cost2, 2, 2) == 12);
assert(func0(cost3, 2, 2) == 16);
return ... | O1 | c | func0:
endbr64
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov (%rdi),%eax
mov %eax,(%rsp)
test %esi,%esi
jle 1219 <func0+0xb0>
mov %eax,%ecx
add 0xc(%rdi),%ecx
mov %ecx,0xc(%rsp)
cmp $0x1,%esi
jle 11a3 <func0+0x3a>
add 0x18(%rdi),%ecx
mov %ecx,0x18(%rs... | func0:
endbr64
sub rsp, 38h
mov r8d, edx
mov rax, fs:28h
mov [rsp+38h+var_10], rax
xor eax, eax
mov eax, [rdi]
mov [rsp+38h+var_38], eax
test esi, esi
jle loc_1220
mov edx, eax
add edx, [rdi+0Ch]
mov [rsp+38h+var_2C], edx
cmp esi, 1
jle short loc_11A6
add edx, ... | long long func0(int *a1, int a2, int a3)
{
int v4; // eax
int v5; // edx
int v6; // eax
int *v7; // rcx
_DWORD *v8; // rdi
int i; // r9d
int v10; // edx
int v11; // eax
int v12; // eax
_DWORD v14[10]; // [rsp+0h] [rbp-38h] BYREF
unsigned long long v15; // [rsp+28h] [rbp-10h]
v15 = __readfsqwor... | func0:
ENDBR64
SUB RSP,0x38
MOV R8D,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RDI]
MOV dword ptr [RSP],EAX
TEST ESI,ESI
JLE 0x00101220
MOV EDX,EAX
ADD EDX,dword ptr [RDI + 0xc]
MOV dword ptr [RSP + 0xc],EDX
CMP ESI,0x1
JLE 0x001011a6
ADD EDX,dword ptr [RDI + 0x18]
MOV... | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
long in_FS_OFFSET;
int local_38 [6];
int local_20;
long local_10;
piVar2 = local_38;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_38[0] = *param_1;
if (param_2 < 1) {
if (param_3 < 1) goto... |
3,898 | func0 |
#include <assert.h>
#define R 3
#define C 3
| int func0(int cost[R][C], int m, int n) {
int tc[R][C];
tc[0][0] = cost[0][0];
for (int i = 1; i <= m; ++i) {
tc[i][0] = tc[i - 1][0] + cost[i][0];
}
for (int j = 1; j <= n; ++j) {
tc[0][j] = tc[0][j - 1] + cost[0][j];
}
for (int i = 1; i <= m; ++i) {
... | int main() {
int cost1[R][C] = {{1, 2, 3}, {4, 8, 2}, {1, 5, 3}};
int cost2[R][C] = {{2, 3, 4}, {5, 9, 3}, {2, 6, 4}};
int cost3[R][C] = {{3, 4, 5}, {6, 10, 4}, {3, 7, 5}};
assert(func0(cost1, 2, 2) == 8);
assert(func0(cost2, 2, 2) == 12);
assert(func0(cost3, 2, 2) == 16);
return ... | O2 | c | func0:
endbr64
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov (%rdi),%eax
mov %eax,(%rsp)
test %esi,%esi
jle 1356 <func0+0x36>
mov 0xc(%rdi),%ecx
add %eax,%ecx
mov %ecx,0xc(%rsp)
cmp $0x1,%esi
je 1356 <func0+0x36>
add 0x18(%rdi),%ecx
mov %ecx,0x18(%rs... | func0:
endbr64
sub rsp, 38h
movsxd r8, edx
mov rax, fs:28h
mov [rsp+38h+var_10], rax
mov eax, [rdi]
mov [rsp+38h+var_38], eax
test esi, esi
jle short loc_1357
mov edx, [rdi+0Ch]
add edx, eax
mov [rsp+38h+var_2C], edx
cmp esi, 1
jz short loc_1357
add edx, [rdi+18h]
mo... | long long func0(int *a1, int a2, int a3)
{
long long v3; // r8
int v4; // eax
int v5; // edx
int v6; // eax
int *v7; // rcx
_DWORD *v8; // rdi
int i; // r9d
int v10; // edx
int v11; // eax
int v12; // eax
_DWORD v14[10]; // [rsp+0h] [rbp-38h] BYREF
unsigned long long v15; // [rsp+28h] [rbp-10h]... | func0:
ENDBR64
SUB RSP,0x38
MOVSXD R8,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
MOV EAX,dword ptr [RDI]
MOV dword ptr [RSP],EAX
TEST ESI,ESI
JLE 0x00101357
MOV EDX,dword ptr [RDI + 0xc]
ADD EDX,EAX
MOV dword ptr [RSP + 0xc],EDX
CMP ESI,0x1
JZ 0x00101357
ADD EDX,dword ptr [RDI + 0x18]
MOV dword ptr ... | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
long in_FS_OFFSET;
int local_38 [6];
int local_20;
long local_10;
piVar2 = local_38;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_38[0] = *param_1;
if (0 < param_2) {
local_38[3] = param_1... |
3,899 | func0 |
#include <assert.h>
#define R 3
#define C 3
| int func0(int cost[R][C], int m, int n) {
int tc[R][C];
tc[0][0] = cost[0][0];
for (int i = 1; i <= m; ++i) {
tc[i][0] = tc[i - 1][0] + cost[i][0];
}
for (int j = 1; j <= n; ++j) {
tc[0][j] = tc[0][j - 1] + cost[0][j];
}
for (int i = 1; i <= m; ++i) {
... | int main() {
int cost1[R][C] = {{1, 2, 3}, {4, 8, 2}, {1, 5, 3}};
int cost2[R][C] = {{2, 3, 4}, {5, 9, 3}, {2, 6, 4}};
int cost3[R][C] = {{3, 4, 5}, {6, 10, 4}, {3, 7, 5}};
assert(func0(cost1, 2, 2) == 8);
assert(func0(cost2, 2, 2) == 12);
assert(func0(cost3, 2, 2) == 16);
return ... | O3 | c | func0:
endbr64
sub $0x38,%rsp
mov (%rdi),%r8d
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %r8d,(%rsp)
test %esi,%esi
jle 12f9 <func0+0x39>
mov 0xc(%rdi),%eax
add %r8d,%eax
mov %eax,0xc(%rsp)
cmp $0x1,%esi
je 12f9 <func0+0x39>
add 0x18(%rdi),%eax
mov %eax,0x18(%rs... | func0:
endbr64
push rbx
movsxd rcx, esi
movsxd rsi, edx
sub rsp, 30h
mov rax, fs:28h
mov [rsp+38h+var_10], rax
mov eax, [rdi]
mov [rsp+38h+var_38], eax
test ecx, ecx
jle loc_1438
mov edx, [rdi+0Ch]
add edx, eax
mov [rsp+38h+var_2C], edx
cmp ecx, 1
jz short loc_12FF
a... | long long func0(int *a1, int a2, int a3)
{
long long v3; // rcx
long long v4; // rsi
int v5; // eax
int v6; // edx
int v7; // edx
int v8; // r10d
int v9; // r8d
long long v10; // r11
long long v11; // rbx
int v12; // r9d
int v13; // r9d
int v14; // edx
int v15; // edx
_DWORD *v16; // r10
... | func0:
ENDBR64
PUSH RBX
MOVSXD RCX,ESI
MOVSXD RSI,EDX
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
MOV EAX,dword ptr [RDI]
MOV dword ptr [RSP],EAX
TEST ECX,ECX
JLE 0x00101438
MOV EDX,dword ptr [RDI + 0xc]
ADD EDX,EAX
MOV dword ptr [RSP + 0xc],EDX
CMP ECX,0x1
JZ 0x001012ff
ADD EDX,dword ptr [R... | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
long lVar4;
int *piVar5;
long lVar6;
long in_FS_OFFSET;
int local_38 [4];
int local_28 [6];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_38[0] = *param_1;
if (param_2 < 1) {
if (0 < pa... |
3,900 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
// Function to find similar elements
| int* func0(int test_tup1[], int size1, int test_tup2[], int size2, int* res_size) {
int* temp = (int*)malloc((size1 < size2 ? size1 : size2) * sizeof(int));
if (!temp) {
*res_size = 0;
return NULL;
}
int count = 0;
for(int i = 0; i < size1; i++) {
for(int j = 0; j < s... | int main() {
int res_size;
int* res;
// First assertion
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
res = func0(test1_a, 4, test1_b, 4, &res_size);
assert(res_size == 2);
assert(res[0] == 4 && res[1] == 5);
free(res);
// Second assertion
int te... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %rdx,-0x48(%rbp)
mov %ecx,-0x40(%rbp)
mov %r8,-0x50(%rbp)
mov -0x3c(%rbp),%eax
cmp %eax,-0x40(%rbp)
cmovle -0x40(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov [rbp+var_40], ecx
mov [rbp+var_50], r8
mov edx, [rbp+var_40]
mov eax, [rbp+var_3C]
cmp edx, eax
cmovle eax, edx
cdqe
shl rax, 2
mov rdi, rax; size
c... | _DWORD * func0(long long a1, int a2, long long a3, int a4, _DWORD *a5)
{
int v5; // eax
int v7; // eax
int v11; // [rsp+28h] [rbp-28h]
int i; // [rsp+2Ch] [rbp-24h]
int j; // [rsp+30h] [rbp-20h]
int v14; // [rsp+34h] [rbp-1Ch]
int k; // [rsp+38h] [rbp-18h]
int m; // [rsp+3Ch] [rbp-14h]
int n; // [rsp+... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV dword ptr [RBP + -0x40],ECX
MOV qword ptr [RBP + -0x50],R8
MOV EDX,dword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x3c]
CMP EDX,EAX
CMOVLE EAX,EDX
CDQE
SHL RAX,0x2
MOV ... | void * func0(long param_1,int param_2,long param_3,int param_4,int *param_5)
{
int4 uVar1;
bool bVar2;
int iVar3;
void *pvVar4;
int4 local_30;
int4 local_2c;
int4 local_28;
int4 local_20;
int4 local_1c;
int4 local_18;
iVar3 = param_2;
if (param_4 <= param_2) {
iVar3 = param_4;
}
pvVa... |
3,901 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
// Function to find similar elements
| int* func0(int test_tup1[], int size1, int test_tup2[], int size2, int* res_size) {
int* temp = (int*)malloc((size1 < size2 ? size1 : size2) * sizeof(int));
if (!temp) {
*res_size = 0;
return NULL;
}
int count = 0;
for(int i = 0; i < size1; i++) {
for(int j = 0; j < s... | int main() {
int res_size;
int* res;
// First assertion
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
res = func0(test1_a, 4, test1_b, 4, &res_size);
assert(res_size == 2);
assert(res[0] == 4 && res[1] == 5);
free(res);
// Second assertion
int te... | O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r14
mov %esi,%r12d
mov %rdx,%r13
mov %ecx,%ebp
mov %r8,%rbx
cmp %esi,%ecx
mov %esi,%edi
cmovle %ecx,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 1208 <func0+0x5f>
test %... | func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov r13d, esi
mov r12, rdx
mov ebp, ecx
mov rbx, r8
cmp ecx, esi
mov edi, esi
cmovle edi, ecx
movsxd rdi, edi
shl rdi, 2
call _malloc
mov r10, rax
test rax, rax
jz loc_12CB
test r1... | long long func0(int *a1, int a2, _DWORD *a3, int a4, int *a5)
{
int v9; // edi
long long v10; // r10
int *v11; // rdi
int v12; // r9d
_DWORD *v13; // rax
int v14; // edx
_DWORD *v15; // rax
_DWORD *v16; // rsi
long long v17; // r8
_DWORD *v18; // rax
int v19; // edx
v9 = a2;
if ( a4 <= a2 )
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV R13D,ESI
MOV R12,RDX
MOV EBP,ECX
MOV RBX,R8
CMP ECX,ESI
MOV EDI,ESI
CMOVLE EDI,ECX
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV R10,RAX
TEST RAX,RAX
JZ 0x001012cb
TEST R13D,R13D
JLE 0x001012b6
MOV RDI,R14
LEA EAX,[R13 + -0x1]
LEA R8,[R14 + RA... | int * func0(int *param_1,int param_2,int *param_3,int param_4,int *param_5)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int iVar5;
long lVar6;
iVar5 = param_2;
if (param_4 <= param_2) {
iVar5 = param_4;
}
piVar3 = (int *)malloc((long)iVar5 << 2);
if (piVar3 == (int *)0x0) {
iVa... |
3,902 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
// Function to find similar elements
| int* func0(int test_tup1[], int size1, int test_tup2[], int size2, int* res_size) {
int* temp = (int*)malloc((size1 < size2 ? size1 : size2) * sizeof(int));
if (!temp) {
*res_size = 0;
return NULL;
}
int count = 0;
for(int i = 0; i < size1; i++) {
for(int j = 0; j < s... | int main() {
int res_size;
int* res;
// First assertion
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
res = func0(test1_a, 4, test1_b, 4, &res_size);
assert(res_size == 2);
assert(res[0] == 4 && res[1] == 5);
free(res);
// Second assertion
int te... | O2 | c | func0:
endbr64
push %r14
mov %esi,%r14d
push %r13
movslq %ecx,%r13
push %r12
cmp %esi,%r13d
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
cmovle %r13,%rdi
mov %r8,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 152e <func0+0x11e>
test %r14d,%r14d
jle ... | func0:
endbr64
push r14
mov r14d, esi
push r13
movsxd r13, ecx
push r12
cmp r13d, esi
mov r12, rdx
push rbp
mov rbp, rdi
movsxd rdi, esi
push rbx
cmovle rdi, r13
mov rbx, r8
shl rdi, 2
call _malloc
mov r8, rax
test rax, rax
jz loc_1555
test r14d, r14d
jle ... | long long func0(int *a1, int a2, _DWORD *a3, int a4, int *a5)
{
long long v8; // rdi
long long result; // rax
_DWORD *v11; // r8
int *v12; // rdi
int v13; // r10d
long long v14; // r9
int v15; // edx
_DWORD *v16; // rax
_DWORD *v17; // rax
_DWORD *v18; // rsi
long long v19; // r9
_DWORD *v20; /... | func0:
ENDBR64
PUSH R14
MOV R14D,ESI
PUSH R13
MOVSXD R13,ECX
PUSH R12
CMP R13D,ESI
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,ESI
PUSH RBX
CMOVLE RDI,R13
MOV RBX,R8
SHL RDI,0x2
CALL 0x001010b0
MOV R8,RAX
TEST RAX,RAX
JZ 0x00101555
TEST R14D,R14D
JLE 0x00101555
LEA EAX,[R14 + -0x1]
MOV RDI,RBP
LEA R11,[R8 + 0x4]
XOR R1... | int * func0(int *param_1,int param_2,int *param_3,int param_4,int *param_5)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
long lVar5;
int iVar6;
lVar5 = (long)param_2;
if (param_4 <= param_2) {
lVar5 = (long)param_4;
}
piVar3 = (int *)malloc(lVar5 << 2);
if ((piVar3 == (int *)0x0) ||... |
3,903 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
// Function to find similar elements
| int* func0(int test_tup1[], int size1, int test_tup2[], int size2, int* res_size) {
int* temp = (int*)malloc((size1 < size2 ? size1 : size2) * sizeof(int));
if (!temp) {
*res_size = 0;
return NULL;
}
int count = 0;
for(int i = 0; i < size1; i++) {
for(int j = 0; j < s... | int main() {
int res_size;
int* res;
// First assertion
int test1_a[] = {3, 4, 5, 6};
int test1_b[] = {5, 7, 4, 10};
res = func0(test1_a, 4, test1_b, 4, &res_size);
assert(res_size == 2);
assert(res[0] == 4 && res[1] == 5);
free(res);
// Second assertion
int te... | O3 | c | func0:
endbr64
push %r14
mov %esi,%r14d
push %r13
movslq %ecx,%r13
push %r12
cmp %esi,%r13d
mov %rdx,%r12
push %rbp
mov %rdi,%rbp
movslq %esi,%rdi
push %rbx
cmovle %r13,%rdi
mov %r8,%rbx
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 14de <func0+0x11e>
test %r14d,%r14d
jle ... | func0:
endbr64
push r14
movsxd r14, ecx
push r13
movsxd r13, esi
push r12
cmp r14d, r13d
mov r12, rdx
push rbp
mov rbp, rdi
movsxd rdi, r13d
push rbx
cmovle rdi, r14
mov rbx, r8
shl rdi, 2; size
call _malloc
mov r8, rax
test rax, rax
jz loc_150F
test r13d, r13d
j... | _DWORD * func0(int *a1, int a2, _DWORD *a3, int a4, int *a5)
{
long long v8; // rdi
_DWORD *v10; // r8
int *v11; // rdi
int *v12; // r11
int v13; // r10d
int v14; // edx
_DWORD *v15; // rax
long long v16; // r9
_DWORD *v17; // rax
_DWORD *v18; // rsi
long long i; // r9
_DWORD *v20; // rax
int ... | func0:
ENDBR64
PUSH R14
MOVSXD R14,ECX
PUSH R13
MOVSXD R13,ESI
PUSH R12
CMP R14D,R13D
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
MOVSXD RDI,R13D
PUSH RBX
CMOVLE RDI,R14
MOV RBX,R8
SHL RDI,0x2
CALL 0x001010b0
MOV R8,RAX
TEST RAX,RAX
JZ 0x0010150f
TEST R13D,R13D
JLE 0x0010150f
MOVSXD RAX,R14D
MOV RDI,RBP
LEA R11,[RBP + R13*0x4]
LE... | int * func0(int *param_1,int param_2,int *param_3,int param_4,uint *param_5)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
long lVar5;
ulong uVar6;
uint uVar7;
lVar5 = (long)param_2;
if (param_4 <= param_2) {
lVar5 = (long)param_4;
}
piVar3 = (int *)malloc(lVar5 << 2);
if ((piVar3 ... |
3,904 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int result = 0;
for (int i = 2; i <= (int)sqrt(n); i++) {
if (n % i == 0) {
result = 1;
}
}
return result;
}
| int main() {
assert(func0(2) == 0);
assert(func0(10) == 1);
assert(func0(35) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x2,-0x4(%rbp)
jmp 11a0 <func0+0x37>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 119c <func0+0x33>
movl $0x1,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
cvtsi2sdl -... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 2
jmp short loc_11A0
loc_1188:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_119C
mov [rbp+var_8], 1
loc_119C:
add [rbp+v... | long long func0(int a1)
{
unsigned int v2; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v2 = 0;
for ( i = 2; i <= (int)sqrt((double)a1); ++i )
{
if ( !(a1 % i) )
v2 = 1;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001011a0
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x0010119c
MOV dword ptr [RBP + -0x8],0x1
LAB_0010119c:... | int4 func0(int param_1)
{
double dVar1;
int4 local_10;
int4 local_c;
local_10 = 0;
local_c = 2;
while( true ) {
dVar1 = sqrt((double)param_1);
if ((int)dVar1 < local_c) break;
if (param_1 % local_c == 0) {
local_10 = 1;
}
local_c = local_c + 1;
}
return local_10;
} |
3,905 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int result = 0;
for (int i = 2; i <= (int)sqrt(n); i++) {
if (n % i == 0) {
result = 1;
}
}
return result;
}
| int main() {
assert(func0(2) == 0);
assert(func0(10) == 1);
assert(func0(35) == 1);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,%ebp
pxor %xmm3,%xmm3
cvtsi2sd %edi,%xmm3
movsd %xmm3,0x8(%rsp)
movapd %xmm3,%xmm0
sqrtsd %xmm0,%xmm0
cvttsd2si %xmm0,%r13d
mov $0x2,%ebx
mov $0x0,%r12d
pxor %xmm1,%xmm1
ucomisd 0x8(%rsp),%xmm1
ja 11c5 <func0+0x5... | func0:
endbr64
push r12
push rbp
push rbx
mov ebp, edi
mov ebx, 2
mov r12d, 0
jmp short loc_1193
loc_1180:
mov eax, ebp
cdq
idiv ebx
test edx, edx
mov eax, 1
cmovz r12d, eax
add ebx, 1
loc_1193:
pxor xmm0, xmm0
cvtsi2sd xmm0, ebp
pxor xmm1, xmm1
ucomisd xmm1, xmm0
ja ... | long long func0(int a1)
{
int v1; // ebx
unsigned int v2; // r12d
double v3; // xmm0_8
double v4; // xmm0_8
v1 = 2;
v2 = 0;
while ( 1 )
{
v3 = (double)a1;
v4 = (double)a1 < 0.0 ? sqrt(v3) : sqrt(v3);
if ( (int)v4 < v1 )
break;
if ( !(a1 % v1) )
v2 = 1;
++v1;
}
retur... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV EBP,EDI
MOV EBX,0x2
MOV R12D,0x0
JMP 0x00101193
LAB_00101180:
MOV EAX,EBP
CDQ
IDIV EBX
TEST EDX,EDX
MOV EAX,0x1
CMOVZ R12D,EAX
ADD EBX,0x1
LAB_00101193:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBP
PXOR XMM1,XMM1
UCOMISD XMM1,XMM0
JA 0x001011b9
SQRTSD XMM0,XMM0
LAB_001011a9:
CVTTSD2SI ... | int4 func0(int param_1)
{
int iVar1;
int4 uVar2;
double dVar3;
iVar1 = 2;
uVar2 = 0;
while( true ) {
dVar3 = (double)param_1;
if (dVar3 < 0.0) {
dVar3 = sqrt(dVar3);
}
else {
dVar3 = SQRT(dVar3);
}
if ((int)dVar3 < iVar1) break;
if (param_1 % iVar1 == 0) {
u... |
3,906 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int result = 0;
for (int i = 2; i <= (int)sqrt(n); i++) {
if (n % i == 0) {
result = 1;
}
}
return result;
}
| int main() {
assert(func0(2) == 0);
assert(func0(10) == 1);
assert(func0(35) == 1);
return 0;
}
| O2 | c | func0:
endbr64
pxor %xmm1,%xmm1
push %r13
pxor %xmm2,%xmm2
mov $0x1,%r13d
cvtsi2sd %edi,%xmm1
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
mov $0x2,%ebx
movapd %xmm1,%xmm0
sqrtsd %xmm0,%xmm0
sub $0x18,%rsp
cvttsd2si %xmm0,%ebp
jmp 11ae <func0+0x4e>
nopw %cs:0x0(%rax,%rax,1)
mov %edi,%ea... | func0:
endbr64
push r12
pxor xmm1, xmm1
xor r12d, r12d
pxor xmm2, xmm2
push rbp
cvtsi2sd xmm1, edi
mov ebp, 1
push rbx
mov ebx, 2
sub rsp, 10h
jmp short loc_124E
loc_1240:
mov eax, edi
cdq
idiv ebx
test edx, edx
cmovz r12d, ebp
add ebx, 1
loc_124E:
ucomisd xmm2, xmm1
j... | long long func0(int a1)
{
unsigned int v1; // r12d
double v2; // xmm1_8
int i; // ebx
double v4; // xmm0_8
v1 = 0;
v2 = (double)a1;
for ( i = 2; ; ++i )
{
v4 = v2 < 0.0 ? sqrt(v2) : sqrt(v2);
if ( (int)v4 < i )
break;
if ( !(a1 % i) )
v1 = 1;
}
return v1;
} | func0:
ENDBR64
PUSH R12
PXOR XMM1,XMM1
XOR R12D,R12D
PXOR XMM2,XMM2
PUSH RBP
CVTSI2SD XMM1,EDI
MOV EBP,0x1
PUSH RBX
MOV EBX,0x2
SUB RSP,0x10
JMP 0x0010124e
LAB_00101240:
MOV EAX,EDI
CDQ
IDIV EBX
TEST EDX,EDX
CMOVZ R12D,EBP
ADD EBX,0x1
LAB_0010124e:
UCOMISD XMM2,XMM1
JA 0x00101270
MOVAPD XMM0,XMM1
SQRTSD XMM0,XMM0
LAB_0... | int4 func0(int param_1)
{
int iVar1;
int4 uVar2;
double dVar3;
double __x;
uVar2 = 0;
__x = (double)param_1;
iVar1 = 2;
while( true ) {
if (__x < 0.0) {
dVar3 = sqrt(__x);
}
else {
dVar3 = SQRT(__x);
}
if ((int)dVar3 < iVar1) break;
if (param_1 % iVar1 == 0) {
... |
3,907 | func0 |
#include <stdio.h>
#include <math.h>
#include <assert.h>
| int func0(int n) {
int result = 0;
for (int i = 2; i <= (int)sqrt(n); i++) {
if (n % i == 0) {
result = 1;
}
}
return result;
}
| int main() {
assert(func0(2) == 0);
assert(func0(10) == 1);
assert(func0(35) == 1);
return 0;
}
| O3 | c | func0:
endbr64
pxor %xmm1,%xmm1
push %r13
cvtsi2sd %edi,%xmm1
push %r12
push %rbp
push %rbx
movapd %xmm1,%xmm0
sqrtsd %xmm0,%xmm0
sub $0x18,%rsp
cvttsd2si %xmm0,%ebx
pxor %xmm0,%xmm0
ucomisd %xmm1,%xmm0
ja 11c9 <func0+0x69>
lea 0x1(%rbx),%r8d
mov $0x2,%ecx
xor %r12d,%r12d
mov $0x1,%esi
cm... | func0:
endbr64
pxor xmm1, xmm1
push r13
pxor xmm0, xmm0
cvtsi2sd xmm1, edi
push r12
push rbp
push rbx
mov ebx, edi
sub rsp, 18h
ucomisd xmm0, xmm1
ja short loc_11BE
sqrtsd xmm1, xmm1
mov ecx, 2
xor ebp, ebp
mov edi, 1
cvttsd2si esi, xmm1
cmp esi, 1
jle short loc_11B1
... | long long func0(int a1)
{
double v1; // xmm1_8
int v2; // ecx
unsigned int v3; // ebp
int v4; // esi
int v6; // r12d
v1 = (double)a1;
if ( (double)a1 < 0.0 )
{
v6 = 2;
v3 = 0;
while ( v6 <= (int)sqrt(v1) )
{
if ( !(a1 % v6) )
v3 = 1;
++v6;
}
}
else
{
v... | func0:
ENDBR64
PXOR XMM1,XMM1
PUSH R13
PXOR XMM0,XMM0
CVTSI2SD XMM1,EDI
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
SUB RSP,0x18
UCOMISD XMM0,XMM1
JA 0x001011be
SQRTSD XMM1,XMM1
MOV ECX,0x2
XOR EBP,EBP
MOV EDI,0x1
CVTTSD2SI ESI,XMM1
CMP ESI,0x1
JLE 0x001011b1
NOP dword ptr [RAX + RAX*0x1]
LAB_001011a0:
MOV EAX,EBX
CDQ
IDIV ... | int8 func0(int param_1)
{
int iVar1;
int8 uVar2;
double dVar3;
double __x;
__x = (double)param_1;
if (__x < 0.0) {
uVar2 = 0;
for (iVar1 = 2; dVar3 = sqrt(__x), iVar1 <= (int)dVar3; iVar1 = iVar1 + 1) {
if (param_1 % iVar1 == 0) {
uVar2 = 1;
}
}
}
else {
iVar1 = 2... |
3,908 | func0 |
#include <assert.h>
#include <stdlib.h>
int compare(const void * a, const void * b) {
return ( *(int*)b - *(int*)a );
}
| void func0(int nums[], int size, int n, int result[]) {
qsort(nums, size, sizeof(int), compare);
for(int i = 0; i < n; i++) {
result[i] = nums[i];
}
}
| int main() {
int test1[9] = {25, 35, 22, 85, 14, 65, 75, 22, 58};
int result1[3];
func0(test1, 9, 3, result1);
assert(result1[0] == 85 && result1[1] == 75 && result1[2] == 65);
int test2[9] = {25, 35, 22, 85, 14, 65, 75, 22, 58};
int result2[2];
func0(test2, 9, 2, result2);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rsi
mov -0x18(%rbp),%rax
lea -0x4d(%rip),%rcx
mov $0x4,%edx
mov %rax,%rdi
callq 1070 <qsort@plt>
movl $0x0,-0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+base], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
mov eax, [rbp+var_1C]
movsxd rsi, eax; nmemb
mov rax, [rbp+base]
lea rdx, compare
mov rcx, rdx; compar
mov edx, 4; size
mov rdi, rax... | long long func0(void *a1, int a2, int a3, long long a4)
{
long long result; // rax
unsigned int i; // [rsp+2Ch] [rbp-4h]
qsort(a1, a2, 4uLL, compare);
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a3 )
break;
*(_DWORD *)(4LL * (int)i + a4) = *((_DWORD *)a1 + (int)i);
}
return resul... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x101189]
MOV RCX,RDX
MOV EDX,0x4
MOV RDI,RAX
CALL 0x00... | void func0(void *param_1,int param_2,int param_3,long param_4)
{
int local_c;
qsort(param_1,(long)param_2,4,compare);
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
*(int4 *)(param_4 + (long)local_c * 4) =
*(int4 *)((long)param_1 + (long)local_c * 4);
}
return;
} |
3,909 | func0 |
#include <assert.h>
#include <stdlib.h>
int compare(const void * a, const void * b) {
return ( *(int*)b - *(int*)a );
}
| void func0(int nums[], int size, int n, int result[]) {
qsort(nums, size, sizeof(int), compare);
for(int i = 0; i < n; i++) {
result[i] = nums[i];
}
}
| int main() {
int test1[9] = {25, 35, 22, 85, 14, 65, 75, 22, 58};
int result1[3];
func0(test1, 9, 3, result1);
assert(result1[0] == 85 && result1[1] == 75 && result1[2] == 65);
int test2[9] = {25, 35, 22, 85, 14, 65, 75, 22, 58};
int result2[2];
func0(test2, 9, 2, result2);
... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %edx,%r12d
mov %rcx,%rbp
movslq %esi,%rsi
lea -0x24(%rip),%rcx
mov $0x4,%edx
callq 1070 <qsort@plt>
test %r12d,%r12d
jle 11d9 <func0+0x47>
lea -0x1(%r12),%ecx
mov $0x0,%eax
mov (%rbx,%rax,4),%edx
mov %edx,0x0(%rbp,%rax... | func0:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov ebx, edx
mov r12, rcx
movsxd rsi, esi
lea rcx, compare
mov edx, 4
call _qsort
test ebx, ebx
jle short loc_11D2
mov ecx, ebx
mov eax, 0
loc_11C1:
mov edx, [rbp+rax*4+0]
mov [r12+rax*4], edx
add rax, 1
c... | long long func0(long long a1, int a2, int a3, long long a4)
{
long long result; // rax
result = qsort(a1, a2, 4LL, compare);
if ( a3 > 0 )
{
result = 0LL;
do
{
*(_DWORD *)(a4 + 4 * result) = *(_DWORD *)(a1 + 4 * result);
++result;
}
while ( result != a3 );
}
return result;
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV EBX,EDX
MOV R12,RCX
MOVSXD RSI,ESI
LEA RCX,[0x101189]
MOV EDX,0x4
CALL 0x00101070
TEST EBX,EBX
JLE 0x001011d2
MOV ECX,EBX
MOV EAX,0x0
LAB_001011c1:
MOV EDX,dword ptr [RBP + RAX*0x4]
MOV dword ptr [R12 + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x001011c1
LAB_001... | void func0(void *param_1,int param_2,uint param_3,long param_4)
{
ulong uVar1;
qsort(param_1,(long)param_2,4,compare);
if (0 < (int)param_3) {
uVar1 = 0;
do {
*(int4 *)(param_4 + uVar1 * 4) = *(int4 *)((long)param_1 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
}
ret... |
3,910 | func0 |
#include <assert.h>
#include <stdlib.h>
int compare(const void * a, const void * b) {
return ( *(int*)b - *(int*)a );
}
| void func0(int nums[], int size, int n, int result[]) {
qsort(nums, size, sizeof(int), compare);
for(int i = 0; i < n; i++) {
result[i] = nums[i];
}
}
| int main() {
int test1[9] = {25, 35, 22, 85, 14, 65, 75, 22, 58};
int result1[3];
func0(test1, 9, 3, result1);
assert(result1[0] == 85 && result1[1] == 75 && result1[2] == 65);
int test2[9] = {25, 35, 22, 85, 14, 65, 75, 22, 58};
int result2[2];
func0(test2, 9, 2, result2);
... | O2 | c | func0:
endbr64
push %r12
movslq %esi,%rsi
mov %edx,%r12d
mov $0x4,%edx
push %rbp
mov %rcx,%rbp
lea -0x2c(%rip),%rcx
push %rbx
mov %rdi,%rbx
callq 1070 <qsort@plt>
test %r12d,%r12d
jle 13db <func0+0x4b>
lea -0x1(%r12),%ecx
xor %eax,%eax
nopl 0x0(%rax)
mov (%rbx,%rax,4),%edx
mov %... | func0:
endbr64
push r12
movsxd rsi, esi
mov r12, rcx
lea rcx, compare
push rbp
mov rbp, rdi
push rbx
mov ebx, edx
mov edx, 4
call _qsort
test ebx, ebx
jle short loc_13D1
movsxd rdx, ebx
xor eax, eax
nop dword ptr [rax]
loc_13C0:
mov ecx, [rbp+rax*4+0]
mov [r12+ra... | long long func0(long long a1, int a2, int a3, long long a4)
{
long long result; // rax
result = qsort(a1, a2, 4LL, compare);
if ( a3 > 0 )
{
result = 0LL;
do
{
*(_DWORD *)(a4 + 4 * result) = *(_DWORD *)(a1 + 4 * result);
++result;
}
while ( result != a3 );
}
return result;
... | func0:
ENDBR64
PUSH R12
MOVSXD RSI,ESI
MOV R12,RCX
LEA RCX,[0x101380]
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV EBX,EDX
MOV EDX,0x4
CALL 0x00101070
TEST EBX,EBX
JLE 0x001013d1
MOVSXD RDX,EBX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001013c0:
MOV ECX,dword ptr [RBP + RAX*0x4]
MOV dword ptr [R12 + RAX*0x4],ECX
ADD RAX,0x1
CMP RAX,RDX... | void func0(void *param_1,int param_2,int param_3,long param_4)
{
long lVar1;
qsort(param_1,(long)param_2,4,compare);
if (0 < param_3) {
lVar1 = 0;
do {
*(int4 *)(param_4 + lVar1 * 4) = *(int4 *)((long)param_1 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (lVar1 != param_3);
}
return;
} |
3,911 | func0 |
#include <assert.h>
#include <stdlib.h>
int compare(const void * a, const void * b) {
return ( *(int*)b - *(int*)a );
}
| void func0(int nums[], int size, int n, int result[]) {
qsort(nums, size, sizeof(int), compare);
for(int i = 0; i < n; i++) {
result[i] = nums[i];
}
}
| int main() {
int test1[9] = {25, 35, 22, 85, 14, 65, 75, 22, 58};
int result1[3];
func0(test1, 9, 3, result1);
assert(result1[0] == 85 && result1[1] == 75 && result1[2] == 65);
int test2[9] = {25, 35, 22, 85, 14, 65, 75, 22, 58};
int result2[2];
func0(test2, 9, 2, result2);
... | O3 | c | func0:
endbr64
push %r12
movslq %esi,%rsi
mov %edx,%r12d
mov $0x4,%edx
push %rbp
mov %rcx,%rbp
lea -0x2c(%rip),%rcx
push %rbx
mov %rdi,%rbx
callq 1070 <qsort@plt>
test %r12d,%r12d
jle 13fb <func0+0x9b>
lea 0xf(%rbx),%rdx
lea -0x1(%r12),%eax
sub %rbp,%rdx
cmp $0x1e,%rdx
jbe 1400... | func0:
endbr64
push r12
movsxd rsi, esi; nmemb
mov r12, rcx
lea rcx, compare; compar
push rbp
mov rbp, rdi
push rbx
movsxd rbx, edx
mov edx, 4; size
call _qsort
test ebx, ebx
jle short loc_13C1
lea eax, [rbx-1]
cmp eax, 2
jbe short loc_13A1
lea rdx, [rbp+4]
mov r... | void func0(char *a1, int a2, int a3, long long a4)
{
long long v5; // rbx
long long v6; // rbx
long long v7; // rax
long long v8; // rax
unsigned int v9; // eax
long long v10; // rdx
v5 = a3;
qsort(a1, a2, 4uLL, compare);
if ( (int)v5 > 0 )
{
if ( (unsigned int)(v5 - 1) > 2 && (unsigned long l... | func0:
ENDBR64
PUSH R12
MOVSXD RSI,ESI
MOV R12,RCX
LEA RCX,[0x101350]
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOVSXD RBX,EDX
MOV EDX,0x4
CALL 0x00101070
TEST EBX,EBX
JLE 0x001013c1
LEA EAX,[RBX + -0x1]
CMP EAX,0x2
JBE 0x001013a1
LEA RDX,[RBP + 0x4]
MOV RAX,R12
SUB RAX,RDX
CMP RAX,0x8
JA 0x001013d0
LAB_001013a1:
SHL RBX,0x2
XOR E... | void func0(void *param_1,int param_2,uint param_3,long param_4)
{
int8 uVar1;
uint uVar2;
long lVar3;
ulong uVar4;
qsort(param_1,(long)param_2,4,compare);
if (0 < (int)param_3) {
if ((param_3 - 1 < 3) || ((ulong)(param_4 - ((long)param_1 + 4)) < 9)) {
lVar3 = 0;
do {
*(int4 *)(pa... |
3,912 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int func0(int n) {
int *A = (int*)malloc((n + 1) * sizeof(int));
int *B = (int*)malloc((n + 1) * sizeof(int));
if (A == NULL || B == NULL) {
fprintf(stderr, "Memory allocation failed\n");
exit(EXIT_FAILURE);
}
A[0] = 1;
A[1] = 0;
B[0] = 0;
B[1] = 1;
for (... | int main() {
assert(func0(2) == 3);
assert(func0(8) == 153);
assert(func0(12) == 2131);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
mov -0x24(%rbp),%eax
add $0x1,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x10(%rbp)
mov -0x24(%rbp),%eax
add $0x1,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov eax, [rbp+var_24]
add eax, 1
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+ptr], rax
mov eax, [rbp+var_24]
add eax, 1
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [r... | long long func0(int a1)
{
int i; // [rsp+18h] [rbp-18h]
unsigned int v3; // [rsp+1Ch] [rbp-14h]
_DWORD *ptr; // [rsp+20h] [rbp-10h]
_DWORD *v5; // [rsp+28h] [rbp-8h]
ptr = malloc(4LL * (a1 + 1));
v5 = malloc(4LL * (a1 + 1));
if ( !ptr || !v5 )
{
fwrite("Memory allocation failed\n", 1uLL, 0x19uLL, ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RA... | int4 func0(int param_1)
{
int4 uVar1;
int4 *__ptr;
int4 *__ptr_00;
int local_20;
__ptr = (int4 *)malloc((long)(param_1 + 1) << 2);
__ptr_00 = (int4 *)malloc((long)(param_1 + 1) << 2);
if ((__ptr != (int4 *)0x0) && (__ptr_00 != (int4 *)0x0)) {
*__ptr = 1;
__ptr[1] = 0;
*__ptr_00 = 0;
__... |
3,913 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int func0(int n) {
int *A = (int*)malloc((n + 1) * sizeof(int));
int *B = (int*)malloc((n + 1) * sizeof(int));
if (A == NULL || B == NULL) {
fprintf(stderr, "Memory allocation failed\n");
exit(EXIT_FAILURE);
}
A[0] = 1;
A[1] = 0;
B[0] = 0;
B[1] = 1;
for (... | int main() {
assert(func0(2) == 3);
assert(func0(8) == 153);
assert(func0(12) == 2131);
return 0;
}
| O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%r13d
lea 0x1(%rdi),%ebp
movslq %ebp,%rbp
shl $0x2,%rbp
mov %rbp,%rdi
callq 10b0 <malloc@plt>
mov %rax,%rbx
mov %rbp,%rdi
callq 10b0 <malloc@plt>
test %rbx,%rbx
je 1274 <func0+0xab>
mov %rax,%r12
test ... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13d, edi
lea ebp, [rdi+1]
movsxd rbp, ebp
shl rbp, 2
mov rdi, rbp
call _malloc
mov rbx, rax
mov rdi, rbp
call _malloc
test rbx, rbx
jz short loc_1273
mov r12, rax
test rax, rax
jz short ... | long long func0(int a1, long long a2)
{
long long v2; // rbp
_DWORD *v3; // rbx
_DWORD *v4; // rax
_DWORD *v5; // rdx
_DWORD *v6; // r12
_DWORD *v7; // rax
unsigned int v8; // ebp
long long v9; // rdx
v2 = 4LL * (a1 + 1);
v3 = (_DWORD *)malloc(v2);
v4 = (_DWORD *)malloc(v2);
if ( !v3 || (v6 = ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13D,EDI
LEA EBP,[RDI + 0x1]
MOVSXD RBP,EBP
SHL RBP,0x2
MOV RDI,RBP
CALL 0x001010b0
MOV RBX,RAX
MOV RDI,RBP
CALL 0x001010b0
TEST RBX,RBX
JZ 0x00101273
MOV R12,RAX
TEST RAX,RAX
JZ 0x00101273
MOV dword ptr [RBX],0x1
MOV dword ptr [RBX + 0x4],0x0
MOV dword... | int func0(int param_1)
{
int iVar1;
int *__ptr;
int *__ptr_00;
int *piVar2;
int *piVar3;
size_t __size;
__size = (long)(param_1 + 1) * 4;
__ptr = (int *)malloc(__size);
__ptr_00 = (int *)malloc(__size);
if ((__ptr != (int *)0x0) && (__ptr_00 != (int *)0x0)) {
*__ptr = 1;
__ptr[1] = 0;
... |
3,914 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int func0(int n) {
int *A = (int*)malloc((n + 1) * sizeof(int));
int *B = (int*)malloc((n + 1) * sizeof(int));
if (A == NULL || B == NULL) {
fprintf(stderr, "Memory allocation failed\n");
exit(EXIT_FAILURE);
}
A[0] = 1;
A[1] = 0;
B[0] = 0;
B[1] = 1;
for (... | int main() {
assert(func0(2) == 3);
assert(func0(8) == 153);
assert(func0(12) == 2131);
return 0;
}
| O2 | c | func0:
endbr64
push %r13
push %r12
mov %edi,%r12d
push %rbp
push %rbx
lea 0x1(%rdi),%ebx
movslq %ebx,%rbx
shl $0x2,%rbx
sub $0x8,%rsp
mov %rbx,%rdi
callq 10b0 <malloc@plt>
mov %rbx,%rdi
mov %rax,%r13
callq 10b0 <malloc@plt>
test %r13,%r13
je 1334 <func0+0xc4>
mov %rax,%rbp
test ... | func0:
endbr64
push r13
push r12
mov r12d, edi
push rbp
push rbx
lea ebx, [rdi+1]
movsxd rbx, ebx
shl rbx, 2
sub rsp, 8
mov rdi, rbx
call _malloc
mov rdi, rbx
mov r13, rax
call _malloc
test r13, r13
jz loc_1334
mov rbp, rax
test rax, rax
jz loc_1334
mov... | long long func0(int a1)
{
long long v2; // rbx
_QWORD *v3; // r13
_QWORD *v4; // rax
_QWORD *v5; // rbp
int *v6; // rdx
int v7; // ecx
int v8; // edi
int *i; // rsi
int v10; // r8d
unsigned int v11; // r12d
v2 = 4LL * (a1 + 1);
v3 = (_QWORD *)malloc(v2);
v4 = (_QWORD *)malloc(v2);
if ( !v3... | func0:
ENDBR64
PUSH R13
PUSH R12
MOV R12D,EDI
PUSH RBP
PUSH RBX
LEA EBX,[RDI + 0x1]
MOVSXD RBX,EBX
SHL RBX,0x2
SUB RSP,0x8
MOV RDI,RBX
CALL 0x001010b0
MOV RDI,RBX
MOV R13,RAX
CALL 0x001010b0
TEST R13,R13
JZ 0x00101334
MOV RBP,RAX
TEST RAX,RAX
JZ 0x00101334
MOV RAX,0x100000000
MOV qword ptr [R13],0x1
MOV qword ptr [RBP]... | int func0(int param_1)
{
int iVar1;
int *piVar2;
int *piVar3;
int *__ptr;
int *__ptr_00;
int iVar4;
int *piVar5;
size_t __size;
int iVar6;
__size = (long)(param_1 + 1) * 4;
__ptr = (int *)malloc(__size);
__ptr_00 = (int *)malloc(__size);
if ((__ptr != (int *)0x0) && (__ptr_00 != (int *)0x0... |
3,915 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
| int func0(int n) {
int *A = (int*)malloc((n + 1) * sizeof(int));
int *B = (int*)malloc((n + 1) * sizeof(int));
if (A == NULL || B == NULL) {
fprintf(stderr, "Memory allocation failed\n");
exit(EXIT_FAILURE);
}
A[0] = 1;
A[1] = 0;
B[0] = 0;
B[1] = 1;
for (... | int main() {
assert(func0(2) == 3);
assert(func0(8) == 153);
assert(func0(12) == 2131);
return 0;
}
| O3 | c | func0:
endbr64
push %r13
lea 0x1(%rdi),%r13d
push %r12
movslq %r13d,%r13
push %rbp
shl $0x2,%r13
push %rbx
mov %edi,%ebx
mov %r13,%rdi
sub $0x8,%rsp
callq 10b0 <malloc@plt>
mov %r13,%rdi
mov %rax,%rbp
callq 10b0 <malloc@plt>
test %rbp,%rbp
je 136f <func0+0xff>
mov %rax,%r12
test ... | func0:
endbr64
push r13
mov r13d, edi
push r12
push rbp
lea ebp, [rdi+1]
push rbx
movsxd rbp, ebp
shl rbp, 2
mov rdi, rbp; size
sub rsp, 8
call _malloc
mov rdi, rbp; size
mov rbx, rax
call _malloc
test rbx, rbx
jz loc_136D
mov r12, rax
test rax, rax
jz ... | long long func0(int a1)
{
size_t v1; // rbp
_QWORD *v2; // rbx
_QWORD *v3; // rax
_DWORD *v4; // r12
long long v5; // rdx
int v6; // esi
int v7; // ecx
long long v8; // rax
unsigned int v9; // ebp
v1 = 4LL * (a1 + 1);
v2 = malloc(v1);
v3 = malloc(v1);
if ( !v2 || (v4 = v3) == 0LL )
{
f... | func0:
ENDBR64
PUSH R13
MOV R13D,EDI
PUSH R12
PUSH RBP
LEA EBP,[RDI + 0x1]
PUSH RBX
MOVSXD RBP,EBP
SHL RBP,0x2
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010b0
MOV RDI,RBP
MOV RBX,RAX
CALL 0x001010b0
TEST RBX,RBX
JZ 0x0010136d
MOV R12,RAX
TEST RAX,RAX
JZ 0x0010136d
MOV RAX,qword ptr [0x00102078]
MOV qword ptr [RBX],0x1
MOV qwor... | int4 func0(int param_1)
{
int4 uVar1;
int8 uVar2;
int iVar3;
int8 *__ptr;
int8 *__ptr_00;
int iVar4;
long lVar5;
size_t __size;
int iVar6;
__size = (long)(param_1 + 1) * 4;
__ptr = (int8 *)malloc(__size);
__ptr_00 = (int8 *)malloc(__size);
uVar2 = DAT_00102078;
if ((__ptr != (int8 *)0x0)... |
3,916 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int a, int b) {
return (a ^ b) && !((a ^ b) & ((a ^ b) - 1));
}
| int main() {
assert(func0(13,9) == true);
assert(func0(15,8) == false);
assert(func0(2,4) == false);
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
je 117d <func0+0x34>
mov -0x4(%rbp),%eax
xor -0x8(%rbp),%eax
mov %eax,%edx
mov -0x4(%rbp),%eax
xor -0x8(%rbp),%eax
sub $0x1,%eax
and %edx,%eax
test %eax,%eax... | 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]
jz short loc_117D
mov eax, [rbp+var_4]
xor eax, [rbp+var_8]
mov edx, eax
mov eax, [rbp+var_4]
xor eax, [rbp+var_8]
sub eax, 1
and eax, edx
test... | _BOOL8 func0(int a1, int a2)
{
return a1 != a2 && ((a2 ^ a1) & ((a2 ^ a1) - 1)) == 0;
} | 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]
JZ 0x0010117d
MOV EAX,dword ptr [RBP + -0x4]
XOR EAX,dword ptr [RBP + -0x8]
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
XOR EAX,dword ptr [RBP + -0x8]
SUB EAX,0x... | int4 func0(uint param_1,uint param_2)
{
int4 uVar1;
if ((param_1 == param_2) || (((param_1 ^ param_2) - 1 & (param_1 ^ param_2)) != 0)) {
uVar1 = 0;
}
else {
uVar1 = 1;
}
return uVar1;
} |
3,917 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int a, int b) {
return (a ^ b) && !((a ^ b) & ((a ^ b) - 1));
}
| int main() {
assert(func0(13,9) == true);
assert(func0(15,8) == false);
assert(func0(2,4) == false);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
cmp %esi,%edi
je 1143 <func0+0x1a>
xor %esi,%edi
lea -0x1(%rdi),%eax
test %edi,%eax
sete %al
movzbl %al,%eax
and $0x1,%eax
retq
| func0:
endbr64
mov eax, 0
cmp edi, esi
jz short loc_1143
xor edi, esi
lea eax, [rdi-1]
test eax, edi
setz al
movzx eax, al
loc_1143:
and eax, 1
retn | _BOOL8 func0(int a1, int a2)
{
bool v2; // al
v2 = 0;
if ( a1 != a2 )
return ((a2 ^ a1) & ((a2 ^ a1) - 1)) == 0;
return v2;
} | func0:
ENDBR64
MOV EAX,0x0
CMP EDI,ESI
JZ 0x00101143
XOR EDI,ESI
LEA EAX,[RDI + -0x1]
TEST EAX,EDI
SETZ AL
MOVZX EAX,AL
LAB_00101143:
AND EAX,0x1
RET | bool func0(uint param_1,uint param_2)
{
bool bVar1;
bVar1 = false;
if (param_1 != param_2) {
bVar1 = ((param_1 ^ param_2) - 1 & (param_1 ^ param_2)) == 0;
}
return bVar1;
} |
3,918 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int a, int b) {
return (a ^ b) && !((a ^ b) & ((a ^ b) - 1));
}
| int main() {
assert(func0(13,9) == true);
assert(func0(15,8) == false);
assert(func0(2,4) == false);
return 0;
}
| O2 | c | func0:
endbr64
xor %eax,%eax
cmp %esi,%edi
je 1154 <func0+0x14>
xor %esi,%edi
lea -0x1(%rdi),%eax
test %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
xor eax, eax
cmp edi, esi
jz short locret_1154
xor edi, esi
lea eax, [rdi-1]
test eax, edi
setz al
locret_1154:
retn | bool func0(int a1, int a2)
{
bool result; // al
result = 0;
if ( a1 != a2 )
return ((a2 ^ a1) & ((a2 ^ a1) - 1)) == 0;
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,ESI
JZ 0x00101154
XOR EDI,ESI
LEA EAX,[RDI + -0x1]
TEST EAX,EDI
SETZ AL
LAB_00101154:
RET | int4 func0(uint param_1,uint param_2)
{
uint uVar1;
int4 uVar2;
uVar2 = 0;
if (param_1 != param_2) {
uVar1 = (param_1 ^ param_2) - 1;
uVar2 = CONCAT31((int3)(uVar1 >> 8),(uVar1 & (param_1 ^ param_2)) == 0);
}
return uVar2;
} |
3,919 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int a, int b) {
return (a ^ b) && !((a ^ b) & ((a ^ b) - 1));
}
| int main() {
assert(func0(13,9) == true);
assert(func0(15,8) == false);
assert(func0(2,4) == false);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
cmp %esi,%edi
je 1154 <func0+0x14>
xor %esi,%edi
lea -0x1(%rdi),%eax
test %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
xor eax, eax
cmp edi, esi
jz short locret_1154
xor edi, esi
lea eax, [rdi-1]
test eax, edi
setz al
locret_1154:
retn | bool func0(int a1, int a2)
{
bool result; // al
result = 0;
if ( a1 != a2 )
return ((a2 ^ a1) & ((a2 ^ a1) - 1)) == 0;
return result;
} | func0:
ENDBR64
XOR EAX,EAX
CMP EDI,ESI
JZ 0x00101154
XOR EDI,ESI
LEA EAX,[RDI + -0x1]
TEST EAX,EDI
SETZ AL
LAB_00101154:
RET | int4 func0(uint param_1,uint param_2)
{
uint uVar1;
int4 uVar2;
uVar2 = 0;
if (param_1 != param_2) {
uVar1 = (param_1 ^ param_2) - 1;
uVar2 = CONCAT31((int3)(uVar1 >> 8),(uVar1 & (param_1 ^ param_2)) == 0);
}
return uVar2;
} |
3,920 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char **func0(const char *text) {
// Allocate memory for maximum possible words
char **result = malloc(sizeof(char*) * (strlen(text) / 2 + 1));
int count = 0;
char *copy = strdup(text);
char *token = strtok(copy, " ");
while(token != NULL) {
// Remove punctuation if any
ch... | int main() {
// First assert
{
char **result = func0("Please move back to stream");
assert(strcmp(result[0], "Please") == 0);
assert(strcmp(result[1], "move") == 0);
assert(strcmp(result[2], "back") == 0);
assert(strcmp(result[3], "stream") == 0);
assert(r... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 10c0 <strlen@plt>
shr %rax
add $0x1,%rax
shl $0x3,%rax
mov %rax,%rdi
callq 10f0 <malloc@plt>
mov %rax,-0x20(%rbp)
movl $0x0,-0x34(%rbp)
mov -0x48(%rbp),%... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
shr rax, 1
add rax, 1
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_20], rax
mov [rbp+var_34], 0
mov rax, [rbp+s]
mov rdi, r... | _QWORD * func0(const char *a1)
{
size_t v1; // rax
int v2; // eax
int v4; // [rsp+1Ch] [rbp-34h]
const char *i; // [rsp+20h] [rbp-30h]
const char *j; // [rsp+28h] [rbp-28h]
_QWORD *v7; // [rsp+30h] [rbp-20h]
char *v8; // [rsp+38h] [rbp-18h]
v1 = strlen(a1);
v7 = malloc(8 * ((v1 >> 1) + 1));
v4 = 0;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001010c0
SHR RAX,0x1
ADD RAX,0x1
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x34],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RA... | void * func0(char *param_1)
{
size_t sVar1;
void *pvVar2;
char *__s;
char *pcVar3;
int local_3c;
char *local_38;
char *local_30;
sVar1 = strlen(param_1);
pvVar2 = malloc(((sVar1 >> 1) + 1) * 8);
local_3c = 0;
__s = strdup(param_1);
local_38 = strtok(__s," ");
while (local_38 != (char *)0x0... |
3,921 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char **func0(const char *text) {
// Allocate memory for maximum possible words
char **result = malloc(sizeof(char*) * (strlen(text) / 2 + 1));
int count = 0;
char *copy = strdup(text);
char *token = strtok(copy, " ");
while(token != NULL) {
// Remove punctuation if any
ch... | int main() {
// First assert
{
char **result = func0("Please move back to stream");
assert(strcmp(result[0], "Please") == 0);
assert(strcmp(result[1], "move") == 0);
assert(strcmp(result[2], "back") == 0);
assert(strcmp(result[3], "stream") == 0);
assert(r... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
shr %rax
lea 0x8(,%rax,8),%rdi
callq 10b0 <malloc@plt>
mov %rax,%r1... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
call _strlen
shr rax, 1
lea rdi, ds:8[rax*8]
call _malloc
mov r14, rax
mov rdi, rbx
call _strdup
mov [rsp+48h+var_40], rax
lea rsi, unk_2004
mov rdi, rax
call ... | long long func0(long long a1)
{
unsigned long long v1; // rax
long long v2; // r14
long long v3; // rax
unsigned long long v4; // rbx
int v5; // r12d
unsigned long long v6; // rbp
_BYTE *v7; // rax
unsigned long long v8; // rdx
long long v10; // [rsp+8h] [rbp-40h]
v1 = ((long long (*)(void))strlen... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
CALL 0x001010c0
SHR RAX,0x1
LEA RDI,[0x8 + RAX*0x8]
CALL 0x001010f0
MOV R14,RAX
MOV RDI,RBX
CALL 0x00101110
MOV qword ptr [RSP + 0x8],RAX
LEA RSI,[0x102004]
MOV RDI,RAX
CALL 0x00101100
TEST RAX,RAX
JZ 0x001012eb
MOV RBX,RAX
MO... | void * func0(char *param_1)
{
byte bVar1;
size_t sVar2;
void *pvVar3;
char *__s;
byte *__s_00;
byte *pbVar4;
char *pcVar5;
int iVar6;
sVar2 = strlen(param_1);
pvVar3 = malloc((sVar2 >> 1) * 8 + 8);
__s = strdup(param_1);
__s_00 = (byte *)strtok(__s," ");
if (__s_00 == (byte *)0x0) {
iV... |
3,922 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char **func0(const char *text) {
// Allocate memory for maximum possible words
char **result = malloc(sizeof(char*) * (strlen(text) / 2 + 1));
int count = 0;
char *copy = strdup(text);
char *token = strtok(copy, " ");
while(token != NULL) {
// Remove punctuation if any
ch... | int main() {
// First assert
{
char **result = func0("Please move back to stream");
assert(strcmp(result[0], "Please") == 0);
assert(strcmp(result[1], "move") == 0);
assert(strcmp(result[2], "back") == 0);
assert(strcmp(result[3], "stream") == 0);
assert(r... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x18,%rsp
callq 10b0 <strlen@plt>
shr %rax
lea 0x8(,%rax,8),%rdi
callq 10d0 <malloc@plt>
mov %rbp,%rdi
mov %rax,%r12
callq 10f0 <strdup@plt>
lea 0xa28(%rip),%rsi
mov %rax,%rdi
mov %rax... | func0:
endbr64
push r15
push r14
push r13
push r12
lea r12, unk_2004
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
call _strlen
shr rax, 1
lea rdi, ds:8[rax*8]
call _malloc
mov rdi, rbp
mov r13, rax
call _strdup
mov rsi, r12
mov rdi, rax
mov [rsp+48h+var_... | long long func0(long long a1)
{
unsigned long long v1; // rax
long long v2; // r13
long long v3; // rax
unsigned long long v4; // rbx
unsigned long long v5; // r14
long long v6; // rbp
unsigned long long v7; // rax
_BYTE *v8; // rdx
unsigned long long v9; // rcx
_QWORD *v10; // rax
long long v12;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
LEA R12,[0x102004]
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
CALL 0x001010c0
SHR RAX,0x1
LEA RDI,[0x8 + RAX*0x8]
CALL 0x001010f0
MOV RDI,RBP
MOV R13,RAX
CALL 0x00101110
MOV RSI,R12
MOV RDI,RAX
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00101100
TEST RAX,RAX
JZ 0x0010167e
MO... | int8 * func0(char *param_1)
{
byte bVar1;
size_t sVar2;
int8 *puVar3;
char *__s;
byte *__s_00;
ulong uVar4;
char *pcVar5;
int8 *puVar6;
byte *pbVar7;
long lVar8;
sVar2 = strlen(param_1);
puVar3 = (int8 *)malloc((sVar2 >> 1) * 8 + 8);
__s = strdup(param_1);
__s_00 = (byte *)strtok(__s," "... |
3,923 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
| char **func0(const char *text) {
// Allocate memory for maximum possible words
char **result = malloc(sizeof(char*) * (strlen(text) / 2 + 1));
int count = 0;
char *copy = strdup(text);
char *token = strtok(copy, " ");
while(token != NULL) {
// Remove punctuation if any
ch... | int main() {
// First assert
{
char **result = func0("Please move back to stream");
assert(strcmp(result[0], "Please") == 0);
assert(strcmp(result[1], "move") == 0);
assert(strcmp(result[2], "back") == 0);
assert(strcmp(result[3], "stream") == 0);
assert(r... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x18,%rsp
callq 10b0 <strlen@plt>
shr %rax
lea 0x8(,%rax,8),%rdi
callq 10d0 <malloc@plt>
mov %rbp,%rdi
mov %rax,%r12
callq 10f0 <strdup@plt>
lea 0xa28(%rip),%rsi
mov %rax,%rdi
mov %rax... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
lea rbp, delim; " "
push rbx
mov rbx, rdi
sub rsp, 18h
call _strlen
shr rax, 1
lea rdi, ds:8[rax*8]; size
call _malloc
mov rdi, rbx; s
mov r12, rax
call _strdup
mov rsi, rbp; delim
mov rdi, rax; s
... | _QWORD * func0(char *s)
{
size_t v1; // rax
_QWORD *v2; // r12
char *v3; // rax
unsigned long long v4; // r13
char *v5; // r14
long long v6; // rbx
size_t v7; // rax
char *v8; // rdx
unsigned long long v9; // rcx
_QWORD *v10; // rax
char *ptr; // [rsp+8h] [rbp-40h]
v1 = strlen(s);
v2 = malloc... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
LEA RBP,[0x102004]
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
CALL 0x001010c0
SHR RAX,0x1
LEA RDI,[0x8 + RAX*0x8]
CALL 0x001010f0
MOV RDI,RBX
MOV R12,RAX
CALL 0x00101110
MOV RSI,RBP
MOV RDI,RAX
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00101100
TEST RAX,RAX
JZ 0x00101683
MO... | int8 * func0(char *param_1)
{
size_t sVar1;
int8 *puVar2;
char *__s;
byte *__s_00;
ulong uVar3;
int8 *puVar4;
char *pcVar5;
byte *pbVar6;
long lVar7;
sVar1 = strlen(param_1);
puVar2 = (int8 *)malloc((sVar1 >> 1) * 8 + 8);
__s = strdup(param_1);
__s_00 = (byte *)strtok(__s," ");
puVar4 = ... |
3,924 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int nums[], int result[], int size) {
for (int i = 0; i < size; i++) {
result[i] = nums[i] * nums[i];
}
}
| int main() {
int nums1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int result1[10];
func0(nums1, result1, size1);
int expected1[] = {1, 4, 9, 16, 25, 36, 49, 64, 81, 100};
for(int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ef <func0+0x66>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%ra... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_4], 0
jmp short loc_11EF
loc_11A5:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
... | long long func0(long long a1, long long a2, int a3)
{
long long result; // rax
unsigned int i; // [rsp+20h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a3 )
break;
*(_DWORD *)(4LL * (int)i + a2) = *(_DWORD *)(4LL * (int)i + a1) * *(_DWORD *)(4LL * (int)i + a1);
}
return re... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ef
LAB_001011a5:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EA... | void func0(long param_1,long param_2,int param_3)
{
int4 local_c;
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
*(int *)(param_2 + (long)local_c * 4) =
*(int *)(param_1 + (long)local_c * 4) * *(int *)(param_1 + (long)local_c * 4);
}
return;
} |
3,925 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int nums[], int result[], int size) {
for (int i = 0; i < size; i++) {
result[i] = nums[i] * nums[i];
}
}
| int main() {
int nums1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int result1[10];
func0(nums1, result1, size1);
int expected1[] = {1, 4, 9, 16, 25, 36, 49, 64, 81, 100};
for(int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
... | O1 | c | func0:
endbr64
test %edx,%edx
jle 11ae <func0+0x25>
lea -0x1(%rdx),%ecx
mov $0x0,%eax
mov (%rdi,%rax,4),%edx
imul %edx,%edx
mov %edx,(%rsi,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rcx,%rdx
jne 1199 <func0+0x10>
retq
| func0:
endbr64
test edx, edx
jle short locret_11AA
mov edx, edx
mov eax, 0
loc_1198:
mov ecx, [rdi+rax*4]
imul ecx, ecx
mov [rsi+rax*4], ecx
add rax, 1
cmp rax, rdx
jnz short loc_1198
locret_11AA:
retn | void func0(long long a1, long long a2, int a3)
{
long long i; // rax
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a2 + 4 * i) = *(_DWORD *)(a1 + 4 * i) * *(_DWORD *)(a1 + 4 * i);
}
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001011aa
MOV EDX,EDX
MOV EAX,0x0
LAB_00101198:
MOV ECX,dword ptr [RDI + RAX*0x4]
IMUL ECX,ECX
MOV dword ptr [RSI + RAX*0x4],ECX
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x00101198
LAB_001011aa:
RET | void func0(long param_1,long param_2,uint param_3)
{
int iVar1;
ulong uVar2;
if (0 < (int)param_3) {
uVar2 = 0;
do {
iVar1 = *(int *)(param_1 + uVar2 * 4);
*(int *)(param_2 + uVar2 * 4) = iVar1 * iVar1;
uVar2 = uVar2 + 1;
} while (uVar2 != param_3);
}
return;
} |
3,926 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int nums[], int result[], int size) {
for (int i = 0; i < size; i++) {
result[i] = nums[i] * nums[i];
}
}
| int main() {
int nums1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int result1[10];
func0(nums1, result1, size1);
int expected1[] = {1, 4, 9, 16, 25, 36, 49, 64, 81, 100};
for(int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
... | O2 | c | func0:
endbr64
test %edx,%edx
jle 1305 <func0+0x25>
lea -0x1(%rdx),%ecx
xor %eax,%eax
nopl (%rax)
mov (%rdi,%rax,4),%edx
imul %edx,%edx
mov %edx,(%rsi,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%rcx
jne 12f0 <func0+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
test edx, edx
jle short locret_12F2
movsxd rdx, edx
xor eax, eax
nop dword ptr [rax]
loc_12E0:
mov ecx, [rdi+rax*4]
imul ecx, ecx
mov [rsi+rax*4], ecx
add rax, 1
cmp rdx, rax
jnz short loc_12E0
locret_12F2:
retn | void func0(long long a1, long long a2, int a3)
{
long long i; // rax
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a2 + 4 * i) = *(_DWORD *)(a1 + 4 * i) * *(_DWORD *)(a1 + 4 * i);
}
} | func0:
ENDBR64
TEST EDX,EDX
JLE 0x001012f2
MOVSXD RDX,EDX
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001012e0:
MOV ECX,dword ptr [RDI + RAX*0x4]
IMUL ECX,ECX
MOV dword ptr [RSI + RAX*0x4],ECX
ADD RAX,0x1
CMP RDX,RAX
JNZ 0x001012e0
LAB_001012f2:
RET | void func0(long param_1,long param_2,int param_3)
{
int iVar1;
long lVar2;
if (0 < param_3) {
lVar2 = 0;
do {
iVar1 = *(int *)(param_1 + lVar2 * 4);
*(int *)(param_2 + lVar2 * 4) = iVar1 * iVar1;
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return;
} |
3,927 | func0 |
#include <assert.h>
#include <stdio.h>
| void func0(int nums[], int result[], int size) {
for (int i = 0; i < size; i++) {
result[i] = nums[i] * nums[i];
}
}
| int main() {
int nums1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int result1[10];
func0(nums1, result1, size1);
int expected1[] = {1, 4, 9, 16, 25, 36, 49, 64, 81, 100};
for(int i = 0; i < size1; i++) {
assert(result1[i] == expected1[i]);
... | O3 | c | func0:
endbr64
test %edx,%edx
jle 137d <func0+0xcd>
lea 0xf(%rdi),%rcx
lea -0x1(%rdx),%eax
sub %rsi,%rcx
cmp $0x1e,%rcx
jbe 1360 <func0+0xb0>
cmp $0x3,%eax
jbe 1360 <func0+0xb0>
mov %edx,%ecx
xor %eax,%eax
shr $0x2,%ecx
shl $0x4,%rcx
nopl 0x0(%rax)
movdqu (%rdi,%rax,1),%xmm0
movd... | func0:
endbr64
movsxd rax, edx
test eax, eax
jle short locret_11B2
lea edx, [rax-1]
cmp edx, 2
jbe short loc_1193
lea rcx, [rdi+4]
mov rdx, rsi
sub rdx, rcx
cmp rdx, 8
ja short loc_11B8
loc_1193:
lea rcx, ds:0[rax*4]
xor eax, eax
nop dword ptr [rax]
loc_11A0:
mov ... | long long func0(long long a1, long long a2, int a3)
{
long long result; // rax
long long v4; // rdx
__m128i v5; // xmm0
__m128i v6; // xmm1
__m128i v7; // xmm0
unsigned int v8; // edx
long long v9; // r8
result = a3;
if ( a3 > 0 )
{
if ( (unsigned int)(a3 - 1) > 2 && (unsigned long long)(a2 - ... | func0:
ENDBR64
MOVSXD RAX,EDX
TEST EAX,EAX
JLE 0x001011b2
LEA EDX,[RAX + -0x1]
CMP EDX,0x2
JBE 0x00101193
LEA RCX,[RDI + 0x4]
MOV RDX,RSI
SUB RDX,RCX
CMP RDX,0x8
JA 0x001011b8
LAB_00101193:
LEA RCX,[RAX*0x4]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001011a0:
MOV EDX,dword ptr [RDI + RAX*0x1]
IMUL EDX,EDX
MOV dword ptr [RSI ... | void func0(long param_1,long param_2,uint param_3)
{
int8 *puVar1;
int auVar2 [16];
int iVar3;
long lVar4;
uint uVar5;
ulong uVar6;
if (0 < (int)param_3) {
if ((param_3 - 1 < 3) || ((ulong)(param_2 - (param_1 + 4)) < 9)) {
lVar4 = 0;
do {
*(int *)(param_2 + lVar4) = *(int *)(pa... |
3,928 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char* str) {
int n = strlen(str);
char tmp[2 * n + 1];
strcpy(tmp, str);
strcat(tmp, str);
for (int i = 1; i <= n; i++) {
int equal = 1;
for (int j = 0; j < n; j++) {
if (str[j] != tmp[i + j]) {
equal = 0;
br... | int main() {
assert(func0("aaaa") == 1);
assert(func0("ab") == 2);
assert(func0("abc") == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x48,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rbx
mov -0x68(%rbp),%rax
mov %rax,%rdi
callq 10a0 <strlen@plt>
mov %eax,... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
add eax, eax
add... | long long func0(char *a1)
{
int v1; // eax
unsigned long long v2; // rax
void *v3; // rsp
char v5[8]; // [rsp+8h] [rbp-50h] BYREF
char *s; // [rsp+10h] [rbp-48h]
int i; // [rsp+20h] [rbp-38h]
int v8; // [rsp+24h] [rbp-34h]
int j; // [rsp+28h] [rbp-30h]
int v10; // [rsp+2Ch] [rbp-2Ch]
long long v11;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001010a0
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,EA... | int func0(char *param_1)
{
long lVar1;
char *pcVar2;
char *__dest;
int iVar3;
size_t sVar4;
ulong uVar5;
int *puVar6;
long in_FS_OFFSET;
int auStack_58 [8];
char *local_50;
int local_40;
int local_3c;
int local_38;
int local_34;
long local_30;
char *local_28;
long local_20;
local... |
3,929 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char* str) {
int n = strlen(str);
char tmp[2 * n + 1];
strcpy(tmp, str);
strcat(tmp, str);
for (int i = 1; i <= n; i++) {
int equal = 1;
for (int j = 0; j < n; j++) {
if (str[j] != tmp[i + j]) {
equal = 0;
br... | int main() {
assert(func0("aaaa") == 1);
assert(func0("ab") == 2);
assert(func0("abc") == 3);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
sub $0x10,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%r12
mov %r12d,%r13d
le... | func0:
endbr64
push rbp
mov rbp, rsp
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call _strlen
mov r13, rax
mov r12d, eax
lea eax, [rax+rax+1]
cdqe
add rax, 0Fh
mov rcx, rax
and rcx, 0FF... | long long func0(long long a1)
{
int v2; // r13d
signed long long v3; // rax
void *v4; // rsp
_BYTE *v5; // rcx
int v6; // edi
long long i; // rax
long long v9; // [rsp+0h] [rbp-38h]
char v10; // [rsp+8h] [rbp-30h] BYREF
_BYTE v11[47]; // [rsp+9h] [rbp-2Fh] BYREF
*(_QWORD *)&v11[7] = __readfsqword(... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001010a0
MOV R13,RAX
MOV R12D,EAX
LEA EAX,[RAX + RAX*0x1 + 0x1]
CDQE
ADD RAX,0xf
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,R... | ulong func0(char *param_1)
{
int iVar1;
long lVar2;
size_t sVar3;
ulong uVar4;
ulong uVar5;
int1 *puVar6;
int1 *puVar7;
uint uVar8;
long in_FS_OFFSET;
bool bVar9;
int1 auStack_38 [8];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
iVar1 = (int)sVar3;... |
3,930 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char* str) {
int n = strlen(str);
char tmp[2 * n + 1];
strcpy(tmp, str);
strcat(tmp, str);
for (int i = 1; i <= n; i++) {
int equal = 1;
for (int j = 0; j < n; j++) {
if (str[j] != tmp[i + j]) {
equal = 0;
br... | int main() {
assert(func0("aaaa") == 1);
assert(func0("ab") == 2);
assert(func0("abc") == 3);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
mov %rdi,%rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
callq 1080 <strlen@plt>
mov %rsp,%rsi
mov %rax,%r13
mov %eax,%r12d
lea 0x1(%rax,%rax,1),%eax
cltq
add $0xf,%rax
mov %rax,%rd... | func0:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
mov rbx, rdi
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call _strlen
mov rcx, rsp
mov r13, rax
mov r12d, eax
lea eax, [rax+rax+1]
cdqe
add rax, 0Fh
mov rdx, rax
and rax... | long long func0(long long a1)
{
long long v1; // r13
char *v2; // rcx
signed long long v3; // rdx
void *v4; // rsp
char *v5; // rcx
int v6; // r8d
long long i; // rax
long long v9; // [rsp+0h] [rbp-1038h]
char v10; // [rsp+8h] [rbp-1030h] BYREF
char v11; // [rsp+9h] [rbp-102Fh] BYREF
_QWORD v12[6... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x00101080
MOV RCX,RSP
MOV R13,RAX
MOV R12D,EAX
LEA EAX,[RAX + RAX*0x1 + 0x1]
CDQE
ADD RAX,0xf
MOV RDX,RAX
AND RAX,-0x1000
SUB RCX,RAX
AND RDX,-0x10
CMP RS... | ulong func0(char *param_1)
{
int iVar1;
long lVar2;
size_t __n;
ulong uVar3;
ulong uVar4;
int1 *puVar5;
int1 *puVar6;
uint uVar8;
long in_FS_OFFSET;
bool bVar9;
int1 auStack_38 [8];
long local_30;
int1 *puVar7;
puVar6 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__n = str... |
3,931 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| int func0(const char* str) {
int n = strlen(str);
char tmp[2 * n + 1];
strcpy(tmp, str);
strcat(tmp, str);
for (int i = 1; i <= n; i++) {
int equal = 1;
for (int j = 0; j < n; j++) {
if (str[j] != tmp[i + j]) {
equal = 0;
br... | int main() {
assert(func0("aaaa") == 1);
assert(func0("ab") == 2);
assert(func0("abc") == 3);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
mov %rdi,%rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
callq 1080 <strlen@plt>
mov %rsp,%rsi
mov %rax,%r13
mov %eax,%r12d
lea 0x1(%rax,%rax,1),%eax
cltq
add $0xf,%rax
mov %rax,%rd... | func0:
endbr64
push rbp
mov rbp, rsp
push r14
push r13
push r12
push rbx
mov rbx, rdi
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call _strlen
mov rcx, rsp
lea r14d, [rax+rax+1]
mov r13, rax
mov r12d, eax
movsxd r14, r14d
lea rax, [r14+0... | long long func0(const char *a1)
{
size_t v2; // r13
long long v3; // r14
char *v4; // rcx
signed long long v5; // rdx
void *v6; // rsp
char *v7; // rcx
int v8; // edi
long long i; // rax
long long v11; // [rsp+0h] [rbp-1038h]
char v12; // [rsp+8h] [rbp-1030h] BYREF
char v13; // [rsp+9h] [rbp-102F... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x00101080
MOV RCX,RSP
LEA R14D,[RAX + RAX*0x1 + 0x1]
MOV R13,RAX
MOV R12D,EAX
MOVSXD R14,R14D
LEA RAX,[R14 + 0xf]
MOV RDX,RAX
AND RAX,-0x1000
SUB... | ulong func0(char *param_1)
{
int iVar1;
long lVar2;
size_t sVar3;
ulong uVar4;
int *puVar5;
int *puVar6;
uint uVar8;
ulong uVar9;
long lVar10;
long in_FS_OFFSET;
bool bVar11;
int auStack_38 [8];
long local_30;
int *puVar7;
puVar6 = auStack_38;
local_30 = *(long *)(in_FS_OFFSET + 0x28... |
3,932 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int arr[], int size, int n, int result[]) {
int i, j, temp;
// First copy elements to result and perform an initial sort
for (i = 0; i < n; i++) {
result[i] = arr[i];
}
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (result[i] > result... | int main() {
int arr1[] = {10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100};
int size1 = sizeof(arr1) / sizeof(arr1[0]);
int result1[2], result2[5], result3[3];
func0(arr1, size1, 2, result1);
func0(arr1, size1, 5, result2);
func0(arr1, size1, 3, result3);
assert(result1[0] == 10 ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11d9 <func0+0x50>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0xc(%rbp),%edx
movslq %edx,%rd... | 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_28], rcx
mov [rbp+var_C], 0
jmp short loc_11D9
loc_11A8:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+... | long long func0(long long a1, int a2, int a3, long long a4)
{
long long result; // rax
int i; // [rsp+1Ch] [rbp-Ch]
int j; // [rsp+1Ch] [rbp-Ch]
unsigned int m; // [rsp+1Ch] [rbp-Ch]
int k; // [rsp+20h] [rbp-8h]
int n; // [rsp+20h] [rbp-8h]
int v10; // [rsp+24h] [rbp-4h]
int v11; // [rsp+24h] [rbp-4h]
... | 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 qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011d9
LAB_001011a8:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RD... | void func0(long param_1,int param_2,int param_3,long param_4)
{
int4 uVar1;
int iVar2;
int local_14;
int local_10;
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
*(int4 *)(param_4 + (long)local_14 * 4) = *(int4 *)(param_1 + (long)local_14 * 4);
}
for (local_14 = 0; iVar2 = param... |
3,933 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int arr[], int size, int n, int result[]) {
int i, j, temp;
// First copy elements to result and perform an initial sort
for (i = 0; i < n; i++) {
result[i] = arr[i];
}
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (result[i] > result... | int main() {
int arr1[] = {10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100};
int size1 = sizeof(arr1) / sizeof(arr1[0]);
int result1[2], result2[5], result3[3];
func0(arr1, size1, 2, result1);
func0(arr1, size1, 5, result2);
func0(arr1, size1, 3, result3);
assert(result1[0] == 10 ... | O1 | c | func0:
endbr64
push %rbx
test %edx,%edx
jle 11ed <func0+0x64>
lea -0x1(%rdx),%r9d
lea 0x1(%r9),%rbx
mov $0x0,%eax
mov (%rdi,%rax,4),%r8d
mov %r8d,(%rcx,%rax,4)
mov %rax,%r8
add $0x1,%rax
cmp %r9,%r8
jne 119f <func0+0x16>
mov %rcx,%r10
mov $0x1,%r11d
jmp 11e3 <func0+0x5a>
add ... | func0:
endbr64
push r13
push r12
push rbp
push rbx
mov r11, rdi
mov ebx, esi
mov r9d, edx
mov rbp, rcx
test edx, edx
jle short loc_120A
lea r12d, [rdx-1]
mov r10d, edx
mov eax, 0
loc_11AE:
mov edx, [r11+rax*4]
mov [rbp+rax*4+0], edx
add rax, 1
cmp rax, r10
... | void func0(long long a1, int a2, int a3, long long a4)
{
int v8; // r12d
long long v9; // r10
long long i; // rax
_DWORD *v11; // rsi
long long j; // r8
_DWORD *v13; // rax
int v14; // edx
long long v15; // rdx
_DWORD *v16; // r8
_DWORD *v17; // rsi
long long v18; // rdi
int *v19; // rax
int ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R11,RDI
MOV EBX,ESI
MOV R9D,EDX
MOV RBP,RCX
TEST EDX,EDX
JLE 0x0010120a
LEA R12D,[RDX + -0x1]
MOV R10D,EDX
MOV EAX,0x0
LAB_001011ae:
MOV EDX,dword ptr [R11 + RAX*0x4]
MOV dword ptr [RBP + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,R10
JNZ 0x001011ae
LEA RSI,[RBP + 0x4]
MOV R... | void func0(long param_1,int param_2,uint param_3,long param_4)
{
long lVar1;
int iVar2;
ulong uVar3;
int *piVar4;
int *piVar5;
int *piVar6;
if (0 < (int)param_3) {
uVar3 = 0;
do {
*(int4 *)(param_4 + uVar3 * 4) = *(int4 *)(param_1 + uVar3 * 4);
uVar3 = uVar3 + 1;
} while (uVar3... |
3,934 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int arr[], int size, int n, int result[]) {
int i, j, temp;
// First copy elements to result and perform an initial sort
for (i = 0; i < n; i++) {
result[i] = arr[i];
}
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (result[i] > result... | int main() {
int arr1[] = {10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100};
int size1 = sizeof(arr1) / sizeof(arr1[0]);
int result1[2], result2[5], result3[3];
func0(arr1, size1, 2, result1);
func0(arr1, size1, 5, result2);
func0(arr1, size1, 3, result3);
assert(result1[0] == 10 ... | O2 | c | func0:
endbr64
push %rbx
test %edx,%edx
jle 1390 <func0+0x70>
lea -0x1(%rdx),%r9d
xor %eax,%eax
lea 0x1(%r9),%rbx
nopl 0x0(%rax,%rax,1)
mov (%rdi,%rax,4),%r8d
mov %r8d,(%rcx,%rax,4)
mov %rax,%r8
add $0x1,%rax
cmp %r9,%r8
jne 1338 <func0+0x18>
mov $0x1,%r11d
mov %rcx,%r10
cmp ... | func0:
endbr64
push r13
mov r11, rdi
mov r9d, edx
push r12
push rbp
mov rbp, rcx
push rbx
mov ebx, esi
test edx, edx
jle short loc_13AC
lea r12d, [rdx-1]
mov r10d, edx
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1348:
mov edx, [r11+rax*4]
mov [rbp+rax*4+0], edx... | void func0(long long a1, int a2, int a3, long long a4)
{
int v7; // r12d
long long v8; // r10
long long i; // rax
long long v10; // r8
_DWORD *v11; // rsi
_DWORD *v12; // rax
int v13; // edx
long long v14; // rdx
_DWORD *v15; // rsi
long long v16; // r10
_DWORD *v17; // r8
long long v18; // rdi... | func0:
ENDBR64
PUSH R13
MOV R11,RDI
MOV R9D,EDX
PUSH R12
PUSH RBP
MOV RBP,RCX
PUSH RBX
MOV EBX,ESI
TEST EDX,EDX
JLE 0x001013ac
LEA R12D,[RDX + -0x1]
MOV R10D,EDX
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101348:
MOV EDX,dword ptr [R11 + RAX*0x4]
MOV dword ptr [RBP + RAX*0x4],EDX
ADD RAX,0x1
CMP RAX,R10
JNZ 0x00101... | void func0(long param_1,int param_2,uint param_3,long param_4)
{
long lVar1;
int iVar2;
ulong uVar3;
int *piVar4;
int *piVar5;
int *piVar6;
ulong uVar7;
if (0 < (int)param_3) {
uVar7 = (ulong)param_3;
uVar3 = 0;
do {
*(int4 *)(param_4 + uVar3 * 4) = *(int4 *)(param_1 + uVar3 * 4);
... |
3,935 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| void func0(int arr[], int size, int n, int result[]) {
int i, j, temp;
// First copy elements to result and perform an initial sort
for (i = 0; i < n; i++) {
result[i] = arr[i];
}
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (result[i] > result... | int main() {
int arr1[] = {10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100};
int size1 = sizeof(arr1) / sizeof(arr1[0]);
int result1[2], result2[5], result3[3];
func0(arr1, size1, 2, result1);
func0(arr1, size1, 5, result2);
func0(arr1, size1, 3, result3);
assert(result1[0] == 10 ... | O3 | c | func0:
endbr64
push %rbx
test %edx,%edx
jle 13d0 <func0+0xd0>
lea 0xf(%rdi),%rax
lea -0x1(%rdx),%r8d
sub %rcx,%rax
cmp $0x1e,%rax
jbe 1461 <func0+0x161>
cmp $0x3,%r8d
jbe 1461 <func0+0x161>
mov %edx,%r8d
xor %eax,%eax
shr $0x2,%r8d
shl $0x4,%r8
nopl 0x0(%rax)
movdqu (%rdi,%rax,... | func0:
endbr64
mov r10, rdi
push rbx
mov r11d, esi
mov r8d, edx
mov rdi, rcx
test edx, edx
jle short loc_1394
lea eax, [rdx-1]
cmp eax, 2
jbe short loc_1331
lea rdx, [r10+4]
mov rax, rcx
sub rax, rdx
cmp rax, 8
ja loc_1432
loc_1331:
movsxd rcx, r8d
xor eax... | void func0(long long a1, int a2, int a3, int *a4)
{
long long i; // rax
int *v9; // rsi
long long v10; // r9
long long v11; // rax
int v12; // edx
int v13; // ecx
long long v14; // rsi
int *v15; // r9
int *v16; // rsi
int *v17; // r10
long long v18; // rax
long long v19; // r11
long long v20;... | func0:
ENDBR64
MOV R10,RDI
PUSH RBX
MOV R11D,ESI
MOV R8D,EDX
MOV RDI,RCX
TEST EDX,EDX
JLE 0x00101394
LEA EAX,[RDX + -0x1]
CMP EAX,0x2
JBE 0x00101331
LEA RDX,[R10 + 0x4]
MOV RAX,RCX
SUB RAX,RDX
CMP RAX,0x8
JA 0x00101432
LAB_00101331:
MOVSXD RCX,R8D
XOR EAX,EAX
SHL RCX,0x2
NOP word ptr [RAX + RAX*0x1]
LAB_00101340:
MOV E... | void func0(long param_1,int param_2,uint param_3,int *param_4)
{
int8 uVar1;
uint uVar2;
long lVar3;
ulong uVar4;
int *piVar5;
int iVar6;
int *piVar7;
ulong uVar8;
int iVar9;
int iVar10;
if (0 < (int)param_3) {
if ((param_3 - 1 < 3) || ((ulong)((long)param_4 - (param_1 + 4)) < 9)) {
... |
3,936 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char *str, char ch) {
int len = strlen(str);
int first = -1, last = -1;
// Find the first and last occurrence of the character
for (int i = 0; i < len; i++) {
if (str[i] == ch) {
if (first == -1) {
first = i; // First occurrence
... | int main() {
assert(strcmp(func0("hello",'l'), "heo") == 0);
assert(strcmp(func0("abcda",'a'), "bcd") == 0);
assert(strcmp(func0("PHP",'P'), "H") == 0);
assert(strcmp(func0("hellolloll",'l'), "helollol") == 0);
assert(strcmp(func0("",'l'), "") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,%eax
mov %al,-0x3c(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10a0 <strlen@plt>
mov %eax,-0x14(%rbp)
movl $0xffffffff,-0x30(%rbp)
movl $0xffffffff,-0x2c(%rbp)
movl $0x0,-0x28(%rbp)
jmp 122f <func0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+s], rdi
mov eax, esi
mov [rbp+var_3C], al
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_14], eax
mov [rbp+var_30], 0FFFFFFFFh
mov [rbp+var_2C], 0FFFFFFFFh
mov [rbp+var_28], 0
jmp short loc_122F
... | char * func0(const char *a1, char a2)
{
int v2; // eax
int v3; // eax
int v4; // eax
int v6; // [rsp+10h] [rbp-30h]
int v7; // [rsp+14h] [rbp-2Ch]
int i; // [rsp+18h] [rbp-28h]
int v9; // [rsp+1Ch] [rbp-24h]
int j; // [rsp+20h] [rbp-20h]
int k; // [rsp+24h] [rbp-1Ch]
int m; // [rsp+28h] [rbp-18h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV EAX,ESI
MOV byte ptr [RBP + -0x3c],AL
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010a0
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0x30],0xffffffff
MOV dword ptr [RBP + -0x2c],0xffffffff
MOV dword ptr [RBP + -0x28]... | char * func0(char *param_1,char param_2)
{
int iVar1;
size_t sVar2;
char *__dest;
int local_38;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_24;
int local_20;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
local_38 = -1;
local_34 = -1;
for (local_30 = 0; local_30 < i... |
3,937 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char *str, char ch) {
int len = strlen(str);
int first = -1, last = -1;
// Find the first and last occurrence of the character
for (int i = 0; i < len; i++) {
if (str[i] == ch) {
if (first == -1) {
first = i; // First occurrence
... | int main() {
assert(strcmp(func0("hello",'l'), "heo") == 0);
assert(strcmp(func0("abcda",'a'), "bcd") == 0);
assert(strcmp(func0("PHP",'P'), "H") == 0);
assert(strcmp(func0("hellolloll",'l'), "helollol") == 0);
assert(strcmp(func0("",'l'), "") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
test %ebp,%ebp
jle 120d <func0+0x84>
mov %ebp,%r15d
lea -0x1(%rbp),%eax
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov ebp, esi
call _strlen
mov r12, rax
test eax, eax
jle short loc_1242
mov r15d, eax
lea eax, [rax-1]
mov [rsp+48h+var_3C], eax
mov ecx, eax
mov eax, 0
mov ... | long long func0(long long a1, char a2)
{
int v2; // eax
int v3; // r12d
int v4; // r15d
long long v5; // rcx
long long v6; // rax
int v7; // r13d
int v8; // r14d
long long v9; // rbp
long long i; // rax
int v12; // esi
long long v13; // rax
long long v14; // rax
int v15; // [rsp+Ch] [rbp-3Ch]... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV EBP,ESI
CALL 0x001010a0
MOV R12,RAX
TEST EAX,EAX
JLE 0x00101242
MOV R15D,EAX
LEA EAX,[RAX + -0x1]
MOV dword ptr [RSP + 0xc],EAX
MOV ECX,EAX
MOV EAX,0x0
MOV R13D,0xffffffff
MOV R14D,0xffffffff
JMP 0x00101217
LAB_0010120b:
L... | char * func0(char *param_1,char param_2)
{
int iVar1;
size_t sVar2;
char *pcVar3;
ulong uVar4;
long lVar5;
uint uVar6;
uint uVar7;
ulong uVar8;
uint uVar9;
bool bVar10;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (0 < iVar1) {
uVar8 = 0xffffffff;
uVar9 = 0xffffffff;
uVar4 =... |
3,938 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char *str, char ch) {
int len = strlen(str);
int first = -1, last = -1;
// Find the first and last occurrence of the character
for (int i = 0; i < len; i++) {
if (str[i] == ch) {
if (first == -1) {
first = i; // First occurrence
... | int main() {
assert(strcmp(func0("hello",'l'), "heo") == 0);
assert(strcmp(func0("abcda",'a'), "bcd") == 0);
assert(strcmp(func0("PHP",'P'), "H") == 0);
assert(strcmp(func0("hellolloll",'l'), "helollol") == 0);
assert(strcmp(func0("",'l'), "") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %esi,%r12d
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x18,%rsp
callq 1080 <strlen@plt>
mov %rax,%r13
test %eax,%eax
jle 1392 <func0+0x72>
lea -0x1(%rax),%esi
mov %eax,%edx
mov $0xffffffff,%r14d
xor %eax,%eax
mov %rsi,%r... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12d, esi
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
call _strlen
mov r13, rax
test eax, eax
jle short loc_13A2
lea ecx, [rax-1]
mov r14d, 0FFFFFFFFh
xor eax, eax
mov ebx, 0FFFFFFFFh
mov r15, rcx
jmp ... | long long func0(long long a1, char a2)
{
int v2; // eax
int v3; // r13d
long long v4; // rcx
int v5; // r14d
long long v6; // rax
int v7; // ebx
int v8; // r15d
long long v9; // r12
_BYTE *v11; // rax
int v12; // r8d
int v13; // [rsp+8h] [rbp-40h]
int v14; // [rsp+8h] [rbp-40h]
v2 = strlen()... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
CALL 0x00101090
MOV R13,RAX
TEST EAX,EAX
JLE 0x001013a2
LEA ECX,[RAX + -0x1]
MOV R14D,0xffffffff
XOR EAX,EAX
MOV EBX,0xffffffff
MOV R15,RCX
JMP 0x00101373
LAB_00101370:
MOV RAX,RDX
LAB_00101373:
CMP byte ptr [RBP ... | int1 * func0(char *param_1,char param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
int1 *puVar4;
int1 *puVar5;
uint uVar6;
int iVar7;
int iVar8;
int iVar9;
ulong uVar10;
bool bVar11;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (0 < iVar1) {
uVar6 = iVar1 - 1;
uVar10 = 0xfffffff... |
3,939 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
| char* func0(const char *str, char ch) {
int len = strlen(str);
int first = -1, last = -1;
// Find the first and last occurrence of the character
for (int i = 0; i < len; i++) {
if (str[i] == ch) {
if (first == -1) {
first = i; // First occurrence
... | int main() {
assert(strcmp(func0("hello",'l'), "heo") == 0);
assert(strcmp(func0("abcda",'a'), "bcd") == 0);
assert(strcmp(func0("PHP",'P'), "H") == 0);
assert(strcmp(func0("hellolloll",'l'), "helollol") == 0);
assert(strcmp(func0("",'l'), "") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %esi,%r12d
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x18,%rsp
callq 1080 <strlen@plt>
mov %rax,%r13
test %eax,%eax
jle 1392 <func0+0x72>
lea -0x1(%rax),%ecx
mov $0xffffffff,%r14d
xor %eax,%eax
mov $0xffffffff,%ebx
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12d, esi
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
call _strlen
mov r13, rax
test eax, eax
jle short loc_13C1
lea ecx, [rax-1]
mov r14d, 0FFFFFFFFh
xor eax, eax
mov ebp, 0FFFFFFFFh
mov r15, rcx
jmp ... | char * func0(const char *src, char a2)
{
size_t v2; // rax
size_t v3; // r13
long long v4; // rcx
int v5; // r14d
long long v6; // rax
int v7; // ebp
int v8; // r15d
char *v9; // r12
char *v11; // rax
int v12; // r8d
int v13; // [rsp+Ch] [rbp-3Ch]
int v14; // [rsp+Ch] [rbp-3Ch]
v2 = strlen(sr... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
CALL 0x001010a0
MOV R13,RAX
TEST EAX,EAX
JLE 0x001013c1
LEA ECX,[RAX + -0x1]
MOV R14D,0xffffffff
XOR EAX,EAX
MOV EBP,0xffffffff
MOV R15,RCX
JMP 0x00101393
LAB_00101390:
MOV RAX,RDX
LAB_00101393:
CMP byte ptr [RBX ... | int * func0(char *param_1,char param_2)
{
int iVar1;
size_t sVar2;
ulong uVar3;
int *puVar4;
int *puVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
ulong uVar10;
bool bVar11;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (0 < iVar1) {
uVar6 = iVar1 - 1;
uVar10 = 0xfffffff... |
3,940 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int sum(const int *row, int cols) {
int total = 0;
for (int i = 0; i < cols; i++) {
total += row[i];
}
return total;
}
int compare(const void *a, const void *b, void *cols) {
int sum_a = sum(*(const int **)a, *(int *... | void func0(int **M, int rows, int cols) {
qsort_r(M, rows, sizeof(int *), compare, &cols);
}
| int main() {
int rows1 = 3, cols1 =3;
int row1[] = {1, 2, 3}, row2[] = {2, 4, 5}, row3[] = {1, 1, 1};
int *matrix1[] = {row1, row2, row3};
func0(matrix1, rows1, cols1);
assert(matrix1[0][0] == 1 && matrix1[0][1] == 1 && matrix1[0][2] == 1);
assert(matrix1[1][0] == 1 && matrix1[1][1] == 2 &... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov %edx,-0x10(%rbp)
lea -0x10(%rbp),%rdx
mov -0xc(%rbp),%esi
mov -0x8(%rbp),%rax
mov %rdx,%r8
lea -0x95(%rip),%rcx
mov $0x8,%edx
mov %rax,%rdi
mov $0x0,%eax
callq 1090 <qsort_r@plt>
l... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+nmemb+4], rdi
mov dword ptr [rbp+nmemb], esi
mov [rbp+arg], edx
lea rdx, [rbp+arg]
mov esi, dword ptr [rbp+nmemb]; nmemb
mov rax, [rbp+nmemb+4]
mov r8, rdx; arg
lea rdx, compare
mov rcx, rdx; compar
mov edx, 8;... | void func0(void *a1, unsigned int a2, int a3)
{
_DWORD arg[2]; // [rsp+0h] [rbp-10h] BYREF
void *nmemb_4; // [rsp+8h] [rbp-8h]
nmemb_4 = a1;
arg[1] = a2;
arg[0] = a3;
qsort_r(a1, a2, 8uLL, compare, arg);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
LEA RDX,[RBP + -0x10]
MOV ESI,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV R8,RDX
LEA RDX,[0x1011d2]
MOV RCX,RDX
MOV EDX,0x8
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101090... | void func0(void *param_1,uint param_2,int4 param_3)
{
int4 local_18;
uint local_14;
void *local_10;
local_18 = param_3;
local_14 = param_2;
local_10 = param_1;
qsort_r(param_1,(ulong)param_2,8,compare,&local_18);
return;
} |
3,941 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int sum(const int *row, int cols) {
int total = 0;
for (int i = 0; i < cols; i++) {
total += row[i];
}
return total;
}
int compare(const void *a, const void *b, void *cols) {
int sum_a = sum(*(const int **)a, *(int *... | void func0(int **M, int rows, int cols) {
qsort_r(M, rows, sizeof(int *), compare, &cols);
}
| int main() {
int rows1 = 3, cols1 =3;
int row1[] = {1, 2, 3}, row2[] = {2, 4, 5}, row3[] = {1, 1, 1};
int *matrix1[] = {row1, row2, row3};
func0(matrix1, rows1, cols1);
assert(matrix1[0][0] == 1 && matrix1[0][1] == 1 && matrix1[0][2] == 1);
assert(matrix1[1][0] == 1 && matrix1[1][1] == 2 &... | O1 | c | func0:
endbr64
sub $0x18,%rsp
mov %edx,0xc(%rsp)
lea 0xc(%rsp),%r8
lea -0x56(%rip),%rcx
mov $0x8,%edx
mov $0x0,%eax
callq 1090 <qsort_r@plt>
add $0x18,%rsp
retq
| func0:
endbr64
sub rsp, 18h
mov [rsp+18h+var_C], edx
lea r8, [rsp+18h+var_C]
lea rcx, compare
mov edx, 8
mov eax, 0
call _qsort_r
add rsp, 18h
retn | long long func0(long long a1, long long a2, int a3)
{
_DWORD v4[3]; // [rsp+Ch] [rbp-Ch] BYREF
v4[0] = a3;
return qsort_r(a1, a2, 8LL, compare, v4);
} | func0:
ENDBR64
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],EDX
LEA R8,[RSP + 0xc]
LEA RCX,[0x1011b6]
MOV EDX,0x8
MOV EAX,0x0
CALL 0x00101090
ADD RSP,0x18
RET | void func0(void *param_1,size_t param_2,int4 param_3)
{
int4 local_c [3];
local_c[0] = param_3;
qsort_r(param_1,param_2,8,compare,local_c);
return;
} |
3,942 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int sum(const int *row, int cols) {
int total = 0;
for (int i = 0; i < cols; i++) {
total += row[i];
}
return total;
}
int compare(const void *a, const void *b, void *cols) {
int sum_a = sum(*(const int **)a, *(int *... | void func0(int **M, int rows, int cols) {
qsort_r(M, rows, sizeof(int *), compare, &cols);
}
| int main() {
int rows1 = 3, cols1 =3;
int row1[] = {1, 2, 3}, row2[] = {2, 4, 5}, row3[] = {1, 1, 1};
int *matrix1[] = {row1, row2, row3};
func0(matrix1, rows1, cols1);
assert(matrix1[0][0] == 1 && matrix1[0][1] == 1 && matrix1[0][2] == 1);
assert(matrix1[1][0] == 1 && matrix1[1][1] == 2 &... | O2 | c | func0:
endbr64
sub $0x18,%rsp
lea -0xaf(%rip),%rcx
xor %eax,%eax
mov %edx,0xc(%rsp)
lea 0xc(%rsp),%r8
mov $0x8,%edx
callq 1090 <qsort_r@plt>
add $0x18,%rsp
retq
nopl 0x0(%rax)
| func0:
endbr64
sub rsp, 18h
lea rcx, compare
xor eax, eax
mov [rsp+18h+var_C], edx
lea r8, [rsp+18h+var_C]
mov edx, 8
call _qsort_r
add rsp, 18h
retn | long long func0(long long a1, long long a2, int a3)
{
_DWORD v4[3]; // [rsp+Ch] [rbp-Ch] BYREF
v4[0] = a3;
return qsort_r(a1, a2, 8LL, compare, v4);
} | func0:
ENDBR64
SUB RSP,0x18
LEA RCX,[0x1015e0]
XOR EAX,EAX
MOV dword ptr [RSP + 0xc],EDX
LEA R8,[RSP + 0xc]
MOV EDX,0x8
CALL 0x00101090
ADD RSP,0x18
RET | void func0(void *param_1,size_t param_2,int4 param_3)
{
int4 local_c [3];
local_c[0] = param_3;
qsort_r(param_1,param_2,8,compare,local_c);
return;
} |
3,943 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int sum(const int *row, int cols) {
int total = 0;
for (int i = 0; i < cols; i++) {
total += row[i];
}
return total;
}
int compare(const void *a, const void *b, void *cols) {
int sum_a = sum(*(const int **)a, *(int *... | void func0(int **M, int rows, int cols) {
qsort_r(M, rows, sizeof(int *), compare, &cols);
}
| int main() {
int rows1 = 3, cols1 =3;
int row1[] = {1, 2, 3}, row2[] = {2, 4, 5}, row3[] = {1, 1, 1};
int *matrix1[] = {row1, row2, row3};
func0(matrix1, rows1, cols1);
assert(matrix1[0][0] == 1 && matrix1[0][1] == 1 && matrix1[0][2] == 1);
assert(matrix1[1][0] == 1 && matrix1[1][1] == 2 &... | O3 | c | func0:
endbr64
sub $0x18,%rsp
lea -0x22f(%rip),%rcx
xor %eax,%eax
mov %edx,0xc(%rsp)
lea 0xc(%rsp),%r8
mov $0x8,%edx
callq 1090 <qsort_r@plt>
add $0x18,%rsp
retq
nopl 0x0(%rax)
| func0:
endbr64
sub rsp, 18h
lea rcx, compare; compar
xor eax, eax
mov [rsp+18h+arg], edx
lea r8, [rsp+18h+arg]; arg
mov edx, 8; size
call _qsort_r
add rsp, 18h
retn | void func0(void *a1, size_t a2, int a3)
{
_DWORD arg[3]; // [rsp+Ch] [rbp-Ch] BYREF
arg[0] = a3;
qsort_r(a1, a2, 8uLL, compare, arg);
} | func0:
ENDBR64
SUB RSP,0x18
LEA RCX,[0x101620]
XOR EAX,EAX
MOV dword ptr [RSP + 0xc],EDX
LEA R8,[RSP + 0xc]
MOV EDX,0x8
CALL 0x00101090
ADD RSP,0x18
RET | void func0(void *param_1,size_t param_2,int4 param_3)
{
int4 local_c [3];
local_c[0] = param_3;
qsort_r(param_1,param_2,8,compare,local_c);
return;
} |
3,944 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#define MAX_WORDS 100
#define MAX_WORD_LENGTH 50
typedef struct {
char word[MAX_WORD_LENGTH];
int count;
} WordCount;
| void func0(char words[][MAX_WORD_LENGTH], int num_words, WordCount result[], int *result_size) {
WordCount counts[MAX_WORDS] = {0};
int unique_words = 0;
// Count each word
for (int i = 0; i < num_words; i++) {
int found = 0;
for (int j = 0; j < unique_words; j++) {
... | int main() {
WordCount result[4];
int result_size;
char data1[][MAX_WORD_LENGTH] = {"red","green","black","pink","black","white","black","eyes","white","black","orange","pink","pink","red","red","white","orange","white","black","pink","green","green","pink","green","pink","white","orange","orange","red... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x678,%rsp
mov %rdi,-0x1668(%rbp)
mov %esi,-0x166c(%rbp)
mov %rdx,-0x1678(%rbp)
mov %rcx,-0x1680(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x1600(%rbp),%rdx
mov $0x0,%e... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 1000h
or [rsp+1008h+var_1008], 0
sub rsp, 678h
mov [rbp+var_1668], rdi
mov [rbp+var_166C], esi
mov [rbp+var_1678], rdx
mov [rbp+var_1680], rcx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rdx, [rbp+va... | unsigned long long func0(long long a1, int a2, long long a3, int *a4)
{
_QWORD *v4; // rdx
_QWORD *v5; // rax
long long v6; // rbx
long long v7; // rbx
long long v8; // rbx
int v9; // edx
int v13; // [rsp+24h] [rbp-165Ch]
int i; // [rsp+28h] [rbp-1658h]
int v15; // [rsp+2Ch] [rbp-1654h]
int j; // [... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x678
MOV qword ptr [RBP + -0x1668],RDI
MOV dword ptr [RBP + -0x166c],ESI
MOV qword ptr [RBP + -0x1678],RDX
MOV qword ptr [RBP + -0x1680],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RDX,[RBP + ... | void func0(long param_1,int param_2,long param_3,int *param_4)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
bool bVar9;
int iVar10;
long lVar11;
long lVar12;
long lVar13;
long lVar14;
char *pcVar15;
long in_FS_OFFSET;
int local_1664... |
3,945 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#define MAX_WORDS 100
#define MAX_WORD_LENGTH 50
typedef struct {
char word[MAX_WORD_LENGTH];
int count;
} WordCount;
| void func0(char words[][MAX_WORD_LENGTH], int num_words, WordCount result[], int *result_size) {
WordCount counts[MAX_WORDS] = {0};
int unique_words = 0;
// Count each word
for (int i = 0; i < num_words; i++) {
int found = 0;
for (int j = 0; j < unique_words; j++) {
... | int main() {
WordCount result[4];
int result_size;
char data1[][MAX_WORD_LENGTH] = {"red","green","black","pink","black","white","black","eyes","white","black","orange","pink","pink","red","red","white","orange","white","black","pink","green","green","pink","green","pink","white","orange","orange","red... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x658,%rsp
mov %rdi,%r8
mov %rdx,0x10(%rsp)
mov %rcx,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x1648(%rsp)
xor %eax,%eax
lea 0x60(%rsp),%rdi
mov $0x2bc,%ecx
rep stos... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1000h
or [rsp+1030h+var_1030], 0
sub rsp, 658h
mov r8, rdi
mov [rsp+1688h+var_1678], rdx
mov [rsp+1688h+var_1670], rcx
mov rax, fs:28h
mov [rsp+1688h+var_40], rax
xor eax, eax
lea rdi... | unsigned long long func0(long long a1, int a2, long long a3, int *a4)
{
long long v4; // r13
int v5; // r15d
_OWORD *v6; // rbp
int v7; // ebx
__m128i *v8; // r12
long long v9; // r14
int v10; // r13d
int i; // ebx
int v12; // edx
__m128i *v13; // rcx
long long v14; // r10
long long v15; // r8
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x658
MOV R8,RDI
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x18],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1648],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x60]
MOV ECX,0x2bc
STOSQ.REP RDI
TEST... | void func0(char *param_1,int param_2,long param_3,int *param_4)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
bool bVar6;
int8 uVar7;
int8 uVar8;
int8 uVar9;
int iVar10;
long lVar11;
int iVar12;
long lVar13;
int iVar14;
int iVar15;
char *pcVar16;
char *pcVar17;
int i... |
3,946 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#define MAX_WORDS 100
#define MAX_WORD_LENGTH 50
typedef struct {
char word[MAX_WORD_LENGTH];
int count;
} WordCount;
| void func0(char words[][MAX_WORD_LENGTH], int num_words, WordCount result[], int *result_size) {
WordCount counts[MAX_WORDS] = {0};
int unique_words = 0;
// Count each word
for (int i = 0; i < num_words; i++) {
int found = 0;
for (int j = 0; j < unique_words; j++) {
... | int main() {
WordCount result[4];
int result_size;
char data1[][MAX_WORD_LENGTH] = {"red","green","black","pink","black","white","black","eyes","white","black","orange","pink","pink","red","red","white","orange","white","black","pink","green","green","pink","green","pink","white","orange","orange","red... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x648,%rsp
mov %rcx,0x8(%rsp)
lea 0x50(%rsp),%r12
mov %rdi,%rbp
mov $0x2bc,%ecx
mov %rdx,(%rsp)
mov %r12,%rdi
mov %fs:0x28,%rax
mov %rax,0x1638(%rsp)
xor %eax,... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1000h
or [rsp+1030h+var_1030], 0
sub rsp, 648h
mov [rsp+1678h+var_1670], rcx
lea r12, [rsp+1678h+var_1628]
mov rbp, rdi
mov ecx, 2BCh
mov [rsp+1678h+var_1678], rdx
mov rdi, r12
mov ra... | unsigned long long func0(long long a1, int a2, long long a3, int *a4)
{
long long v4; // rbp
int v5; // ebx
_OWORD *v6; // r14
int v7; // r15d
long long v8; // rdi
__m128i *v9; // r13
int v10; // ebp
long long v11; // rax
__m128i *v12; // rsi
int v13; // edx
__m128i v14; // xmm0
__m128i *v15; /... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x648
MOV qword ptr [RSP + 0x8],RCX
LEA R12,[RSP + 0x50]
MOV RBP,RDI
MOV ECX,0x2bc
MOV qword ptr [RSP],RDX
MOV RDI,R12
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1638],RAX
XOR EAX,EAX
STOSQ.REP RDI... | void func0(char *param_1,int param_2,long param_3,int *param_4)
{
int *piVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
int8 uVar9;
long lVar10;
long lVar11;
int iVar12;
int iVar13;
int iVar14;
char *pcVar15;
char *pcVar16;
long in_FS_OFFSET;... |
3,947 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#define MAX_WORDS 100
#define MAX_WORD_LENGTH 50
typedef struct {
char word[MAX_WORD_LENGTH];
int count;
} WordCount;
| void func0(char words[][MAX_WORD_LENGTH], int num_words, WordCount result[], int *result_size) {
WordCount counts[MAX_WORDS] = {0};
int unique_words = 0;
// Count each word
for (int i = 0; i < num_words; i++) {
int found = 0;
for (int j = 0; j < unique_words; j++) {
... | int main() {
WordCount result[4];
int result_size;
char data1[][MAX_WORD_LENGTH] = {"red","green","black","pink","black","white","black","eyes","white","black","orange","pink","pink","red","red","white","orange","white","black","pink","green","green","pink","green","pink","white","orange","orange","red... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1000,%rsp
orq $0x0,(%rsp)
sub $0x648,%rsp
mov %rcx,0x8(%rsp)
lea 0x50(%rsp),%r12
mov %rdi,%rbp
mov $0x2bc,%ecx
mov %rdx,(%rsp)
mov %r12,%rdi
mov %fs:0x28,%rax
mov %rax,0x1638(%rsp)
xor %eax,... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1000h
or [rsp+1030h+var_1030], 0
sub rsp, 648h
mov [rsp+1678h+var_1670], rcx
lea r12, [rsp+1678h+s2]
mov rbp, rdi
mov ecx, 2BCh
mov [rsp+1678h+var_1678], rdx
mov rdi, r12
mov rax, fs:... | unsigned long long func0(char *s1, int a2, long long a3, int *a4)
{
const char *v4; // rbp
int v5; // ebx
char *v6; // r13
char *v7; // r15
int v8; // r14d
long long v9; // r8
__m128i *v10; // rbp
int v11; // r13d
long long v12; // rdi
__int32 v13; // esi
__m128i *v14; // rdx
int v15; // eax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1000
OR qword ptr [RSP],0x0
SUB RSP,0x648
MOV qword ptr [RSP + 0x8],RCX
LEA R12,[RSP + 0x50]
MOV RBP,RDI
MOV ECX,0x2bc
MOV qword ptr [RSP],RDX
MOV RDI,R12
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1638],RAX
XOR EAX,EAX
STOSQ.REP RDI... | void func0(char *param_1,int param_2,long param_3,int *param_4)
{
int *piVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
int8 uVar9;
int iVar10;
int iVar11;
long lVar12;
char *pcVar13;
int iVar14;
char *pcVar15;
long lVar16;
int iVar17;
long... |
3,948 | func0 |
#include <assert.h>
| float func0(float l, float b, float h) {
return ((l * b * h) / 2);
}
| int main() {
assert(func0(10, 8, 6) == 240);
assert(func0(3, 2, 2) == 6);
assert(func0(1, 2, 1) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movss %xmm0,-0x4(%rbp)
movss %xmm1,-0x8(%rbp)
movss %xmm2,-0xc(%rbp)
movss -0x4(%rbp),%xmm0
mulss -0x8(%rbp),%xmm0
mulss -0xc(%rbp),%xmm0
movss 0xf11(%rip),%xmm1
divss %xmm1,%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movss [rbp+var_4], xmm0
movss [rbp+var_8], xmm1
movss [rbp+var_C], xmm2
movss xmm0, [rbp+var_4]
mulss xmm0, [rbp+var_8]
mulss xmm0, [rbp+var_C]
movss xmm1, cs:dword_2068
divss xmm0, xmm1
pop rbp
retn | float func0(float a1, float a2, float a3)
{
return (float)((float)(a1 * a2) * a3) / 2.0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS dword ptr [RBP + -0x8],XMM1
MOVSS dword ptr [RBP + -0xc],XMM2
MOVSS XMM0,dword ptr [RBP + -0x4]
MULSS XMM0,dword ptr [RBP + -0x8]
MULSS XMM0,dword ptr [RBP + -0xc]
MOVSS XMM1,dword ptr [0x00102068]
DIVSS XMM0,XMM1
POP RBP
RET | float func0(float param_1,float param_2,float param_3)
{
return (param_1 * param_2 * param_3) / DAT_00102068;
} |
3,949 | func0 |
#include <assert.h>
| float func0(float l, float b, float h) {
return ((l * b * h) / 2);
}
| int main() {
assert(func0(10, 8, 6) == 240);
assert(func0(3, 2, 2) == 6);
assert(func0(1, 2, 1) == 1);
return 0;
}
| O1 | c | func0:
endbr64
mulss %xmm1,%xmm0
mulss %xmm2,%xmm0
mulss 0xec7(%rip),%xmm0
retq
| func0:
endbr64
mulss xmm0, xmm1
mulss xmm0, xmm2
mulss xmm0, cs:dword_2004
retn | float func0(float a1, float a2, float a3)
{
return (float)((float)(a1 * a2) * a3) * 0.5;
} | func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,XMM2
MULSS XMM0,dword ptr [0x00102004]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2,float param_3)
{
return param_1 * param_2 * param_3 * _DAT_00102004;
} |
3,950 | func0 |
#include <assert.h>
| float func0(float l, float b, float h) {
return ((l * b * h) / 2);
}
| int main() {
assert(func0(10, 8, 6) == 240);
assert(func0(3, 2, 2) == 6);
assert(func0(1, 2, 1) == 1);
return 0;
}
| O2 | c | func0:
endbr64
mulss %xmm1,%xmm0
mulss %xmm2,%xmm0
mulss 0xeb0(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mulss xmm0, xmm1
mulss xmm0, xmm2
mulss xmm0, cs:dword_2004
retn | float func0(float a1, float a2, float a3)
{
return (float)((float)(a1 * a2) * a3) * 0.5;
} | func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,XMM2
MULSS XMM0,dword ptr [0x00102004]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2,float param_3)
{
return param_1 * param_2 * param_3 * _DAT_00102004;
} |
3,951 | func0 |
#include <assert.h>
| float func0(float l, float b, float h) {
return ((l * b * h) / 2);
}
| int main() {
assert(func0(10, 8, 6) == 240);
assert(func0(3, 2, 2) == 6);
assert(func0(1, 2, 1) == 1);
return 0;
}
| O3 | c | func0:
endbr64
mulss %xmm1,%xmm0
mulss %xmm2,%xmm0
mulss 0xeb0(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mulss xmm0, xmm1
mulss xmm0, xmm2
mulss xmm0, cs:dword_2004
retn | float func0(float a1, float a2, float a3)
{
return (float)((float)(a1 * a2) * a3) * 0.5;
} | func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,XMM2
MULSS XMM0,dword ptr [0x00102004]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float func0(float param_1,float param_2,float param_3)
{
return param_1 * param_2 * param_3 * _DAT_00102004;
} |
3,952 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* text, int* count) {
char** result = NULL;
*count = 0;
int len = strlen(text);
int i = 0;
while (i < len) {
if (islower((unsigned char)text[i])) {
int start = i;
i++;
while (i < len && !islower((unsigned char)text[i])) {
... | int main() {
// Test case 1
int count1;
char** res1 = func0("AbCd", &count1);
assert(count1 == 2);
assert(strcmp(res1[0], "bC") == 0);
assert(strcmp(res1[1], "d") == 0);
for(int i = 0; i < count1; i++) free(res1[i]);
free(res1);
// Test case 2
int count2;
char** ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
movq $0x0,-0x10(%rbp)
mov -0x40(%rbp),%rax
movl $0x0,(%rax)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %eax,-0x20(%rbp)
movl $0x0,-0x24(%rbp)
jmpq 13b4 <func0+0x16b>
cal... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+s], rdi
mov [rbp+var_40], rsi
mov [rbp+ptr], 0
mov rax, [rbp+var_40]
mov dword ptr [rax], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_20], eax
mov [rbp+var_24], 0
jmp loc_13B4
loc_128A:
call... | void * func0(const char *a1, _DWORD *a2)
{
int v3; // [rsp+1Ch] [rbp-24h]
int v4; // [rsp+20h] [rbp-20h]
int v5; // [rsp+24h] [rbp-1Ch]
void *ptr; // [rsp+30h] [rbp-10h]
char *dest; // [rsp+38h] [rbp-8h]
ptr = 0LL;
*a2 = 0;
v4 = strlen(a1);
v3 = 0;
while ( v3 < v4 )
{
if ( ((*__ctype_b_loc())... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010f0
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr [RBP + -0x24]... | void * func0(char *param_1,int *param_2)
{
int iVar1;
int iVar2;
size_t sVar3;
ushort **ppuVar4;
char *__dest;
int local_2c;
void *local_18;
local_18 = (void *)0x0;
*param_2 = 0;
sVar3 = strlen(param_1);
local_2c = 0;
do {
while( true ) {
iVar1 = local_2c;
if ((int)sVar3 <= l... |
3,953 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* text, int* count) {
char** result = NULL;
*count = 0;
int len = strlen(text);
int i = 0;
while (i < len) {
if (islower((unsigned char)text[i])) {
int start = i;
i++;
while (i < len && !islower((unsigned char)text[i])) {
... | int main() {
// Test case 1
int count1;
char** res1 = func0("AbCd", &count1);
assert(count1 == 2);
assert(strcmp(res1[0], "bC") == 0);
assert(strcmp(res1[1], "d") == 0);
for(int i = 0; i < count1; i++) free(res1[i]);
free(res1);
// Test case 2
int count2;
char** ... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r12
movl $0x0,(%rsi)
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
test %eax,%eax
jle 130e <func0+0x105>
mov %rsi,%r1... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_48], rdi
mov r15, rsi
mov dword ptr [rsi], 0
call _strlen
test eax, eax
jle loc_1338
mov r12d, eax
call ___ctype_b_loc
mov r14, rax
mov esi, 0
mov [rsp+48h+va... | long long func0(long long a1, int *a2)
{
int v3; // eax
int v4; // r12d
_QWORD *v5; // r14
int v6; // esi
int v7; // ebx
unsigned __int8 *v8; // rax
long long v9; // rbp
int v10; // eax
long long v12; // [rsp+8h] [rbp-40h]
*a2 = 0;
v3 = strlen();
if ( v3 <= 0 )
return 0LL;
v4 = v3;
v5 ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RDI
MOV R15,RSI
MOV dword ptr [RSI],0x0
CALL 0x001010f0
TEST EAX,EAX
JLE 0x00101338
MOV R12D,EAX
CALL 0x00101150
MOV R14,RAX
MOV ESI,0x0
MOV qword ptr [RSP + 0x8],0x0
JMP 0x0010131a
LAB_00101293:
LEA EBX,[RSI + 0x1]
CM... | void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
ushort **ppuVar3;
byte *pbVar4;
char *__dest;
int iVar5;
int iVar6;
int iVar7;
void *local_40;
*param_2 = 0;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
if (iVar1 < 1) {
local_40 = (void *)0x0;
}
else {
ppuVar... |
3,954 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* text, int* count) {
char** result = NULL;
*count = 0;
int len = strlen(text);
int i = 0;
while (i < len) {
if (islower((unsigned char)text[i])) {
int start = i;
i++;
while (i < len && !islower((unsigned char)text[i])) {
... | int main() {
// Test case 1
int count1;
char** res1 = func0("AbCd", &count1);
assert(count1 == 2);
assert(strcmp(res1[0], "bC") == 0);
assert(strcmp(res1[1], "d") == 0);
for(int i = 0; i < count1; i++) free(res1[i]);
free(res1);
// Test case 2
int count2;
char** ... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
movl $0x0,(%rsi)
mov %rsi,0x8(%rsp)
callq 10e0 <strlen@plt>
test %eax,%eax
jle 1802 <func0+0x162>
mov %eax,%r14d
xor %ebx,%ebx
callq 1130 <__ctype_b_loc@plt>
mov 0x8(%rsp),%rcx
... | func0:
endbr64
push r15
mov r15, rsi
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 28h
mov dword ptr [rsi], 0
call _strlen
test eax, eax
jle loc_17E9
mov ebp, eax
xor ebx, ebx
call ___ctype_b_loc
xor r8d, r8d
mov r12, [rax]
jmp shor... | long long func0(long long a1, int *a2)
{
int v4; // eax
int v5; // ebp
int v6; // ebx
long long *v7; // rax
long long v8; // r8
long long v9; // r12
int v10; // eax
unsigned __int8 *v11; // rsi
unsigned __int8 *v12; // rdx
long long v13; // r14
int v14; // eax
int v16; // r14d
long long v17; ... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RSI],0x0
CALL 0x001010e0
TEST EAX,EAX
JLE 0x001017e9
MOV EBP,EAX
XOR EBX,EBX
CALL 0x00101130
XOR R8D,R8D
MOV R12,qword ptr [RAX]
JMP 0x001016ea
LAB_001016e0:
MOV EBX,EAX
CMP EBX,EBP
JGE 0x001017a1
LA... | void * func0(char *param_1,int *param_2)
{
ushort *puVar1;
int iVar2;
int iVar3;
size_t sVar4;
ushort **ppuVar5;
char *__dest;
void *__ptr;
byte *pbVar6;
int iVar7;
size_t local_50;
*param_2 = 0;
sVar4 = strlen(param_1);
iVar2 = (int)sVar4;
if (iVar2 < 1) {
__ptr = (void *)0x0;
}
... |
3,955 | func0 |
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* text, int* count) {
char** result = NULL;
*count = 0;
int len = strlen(text);
int i = 0;
while (i < len) {
if (islower((unsigned char)text[i])) {
int start = i;
i++;
while (i < len && !islower((unsigned char)text[i])) {
... | int main() {
// Test case 1
int count1;
char** res1 = func0("AbCd", &count1);
assert(count1 == 2);
assert(strcmp(res1[0], "bC") == 0);
assert(strcmp(res1[1], "d") == 0);
for(int i = 0; i < count1; i++) free(res1[i]);
free(res1);
// Test case 2
int count2;
char** ... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
movl $0x0,(%rsi)
mov %rsi,0x8(%rsp)
callq 10e0 <strlen@plt>
test %eax,%eax
jle 1802 <func0+0x162>
mov %eax,%r14d
xor %ebx,%ebx
callq 1130 <__ctype_b_loc@plt>
mov 0x8(%rsp),%rcx
... | func0:
endbr64
push r15
mov r15, rsi
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 28h
mov dword ptr [rsi], 0
call _strlen
test eax, eax
jle loc_17EF
mov ebp, eax
xor ebx, ebx
call ___ctype_b_loc
xor r8d, r8d
mov r12, [rax]
jmp shor... | void * func0(const char *a1, int *a2)
{
int v3; // eax
int v4; // ebp
int v5; // ebx
const unsigned __int16 **v6; // rax
void *v7; // r8
const unsigned __int16 *v8; // r12
int v9; // eax
const char *v10; // rsi
const char *v11; // rdx
int v12; // r14d
_BYTE *v13; // r14
int v14; // eax
int v16... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RSI],0x0
CALL 0x001010d0
TEST EAX,EAX
JLE 0x001017ef
MOV EBP,EAX
XOR EBX,EBX
CALL 0x00101130
XOR R8D,R8D
MOV R12,qword ptr [RAX]
JMP 0x001016ea
LAB_001016e0:
MOV EBX,EAX
CMP EBX,EBP
JGE 0x001017ab
LA... | void * func0(char *param_1,int *param_2)
{
ushort *puVar1;
int iVar2;
int iVar3;
size_t sVar4;
ushort **ppuVar5;
void *pvVar6;
void *__ptr;
byte *pbVar7;
int iVar8;
long local_58;
*param_2 = 0;
sVar4 = strlen(param_1);
iVar2 = (int)sVar4;
if (iVar2 < 1) {
__ptr = (void *)0x0;
}
e... |
3,956 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char* text) {
regex_t regex;
char* pattern = "^[a-z]+_[a-z]+$";
regcomp(®ex, pattern, REG_EXTENDED);
int reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!reti)
return "Found a match!";
else
return "Not matched!";
}
| int main() {
assert(strcmp(func0("aab_cbbbc"), "Found a match!") == 0);
assert(strcmp(func0("aab_Abbbc"), "Not matched!") == 0);
assert(strcmp(func0("Aaab_abbbc"), "Not matched!") == 0);
assert(strcmp(func0("aab-cbbbc"), "Not matched!") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 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, aAZAZ; "^[a-z]+_[a-z]+$"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern
mov ... | 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);
regcomp(&preg, "^[a-z]+_[a-z]+$", 1);
v2 = regexec(&preg, a1, 0LL, 0LL, 0);
regfree(&preg);
if ( v2 )
return "Not ma... | 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 RSI,qwo... | 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);
regcomp(&local_58,"^[a-z]+_[a-z]+$",1);
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
regfree(&local_58);
if (iVar1 == 0) {
pcVar2... |
3,957 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char* text) {
regex_t regex;
char* pattern = "^[a-z]+_[a-z]+$";
regcomp(®ex, pattern, REG_EXTENDED);
int reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!reti)
return "Found a match!";
else
return "Not matched!";
}
| int main() {
assert(strcmp(func0("aab_cbbbc"), "Found a match!") == 0);
assert(strcmp(func0("aab_Abbbc"), "Not matched!") == 0);
assert(strcmp(func0("Aaab_abbbc"), "Not matched!") == 0);
assert(strcmp(func0("aab-cbbbc"), "Not matched!") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov $0x1,%edx
lea 0xe2b(%rip),%rsi
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %rbp,%rdi... | func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov edx, 1
lea rsi, aAZAZ; "^[a-z]+_[a-z]+$"
mov rdi, rbp
call _regcomp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
mov rdi, rbp
... | const char * func0(long long a1)
{
int v1; // ebx
const char *result; // rax
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "^[a-z]+_[a-z]+$", 1LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
result = "Found a match!";
if ( v1 )
return "Not matched!";
... | 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 RBP,RSP
MOV EDX,0x1
LEA RSI,[0x102020]
MOV RDI,RBP
CALL 0x001010d0
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010f0
MOV EBX,EAX
MOV RDI,RBP
CALL 0x001010a0
TEST... | 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);
regcomp(&rStack_68,"^[a-z]+_[a-z]+$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Found a match!... |
3,958 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char* text) {
regex_t regex;
char* pattern = "^[a-z]+_[a-z]+$";
regcomp(®ex, pattern, REG_EXTENDED);
int reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!reti)
return "Found a match!";
else
return "Not matched!";
}
| int main() {
assert(strcmp(func0("aab_cbbbc"), "Found a match!") == 0);
assert(strcmp(func0("aab_Abbbc"), "Not matched!") == 0);
assert(strcmp(func0("Aaab_abbbc"), "Not matched!") == 0);
assert(strcmp(func0("aab-cbbbc"), "Not matched!") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xd1b(%rip),%rsi
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %ecx,%ecx
xor %edx,%edx
xor %r8d,%r8d
mov %r12,%rsi
mov ... | func0:
endbr64
push r12
mov edx, 1
mov r12, rdi
lea rsi, aAZAZ; "^[a-z]+_[a-z]+$"
push rbp
push rbx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
xor edx, edx
xor r8d, r8d
xor ecx, ecx
mov rsi, r12... | const char * func0(long long a1)
{
int v1; // ebx
const char *result; // rax
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "^[a-z]+_[a-z]+$", 1LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
regfree(_0);
result = "Found a match!";
if ( v1 )
return "Not matched!";
... | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
MOV R12,RDI
LEA RSI,[0x102020]
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010d0
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,R12
MOV RDI,RBP
CALL 0x001010f0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x0010... | 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);
regcomp(&rStack_68,"^[a-z]+_[a-z]+$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Found a match!... |
3,959 | func0 |
#include <stdio.h>
#include <string.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char* text) {
regex_t regex;
char* pattern = "^[a-z]+_[a-z]+$";
regcomp(®ex, pattern, REG_EXTENDED);
int reti = regexec(®ex, text, 0, NULL, 0);
regfree(®ex);
if (!reti)
return "Found a match!";
else
return "Not matched!";
}
| int main() {
assert(strcmp(func0("aab_cbbbc"), "Found a match!") == 0);
assert(strcmp(func0("aab_Abbbc"), "Not matched!") == 0);
assert(strcmp(func0("Aaab_abbbc"), "Not matched!") == 0);
assert(strcmp(func0("aab-cbbbc"), "Not matched!") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xd1b(%rip),%rsi
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %ecx,%ecx
xor %edx,%edx
xor %r8d,%r8d
mov %r12,%rsi
mov ... | func0:
endbr64
push rbp
mov edx, 1; cflags
lea rsi, pattern; "^[a-z]+_[a-z]+$"
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
xor edx, edx; nmatch
xor r8d, r8d; eflags
xor ecx, ... | const char * func0(char *string)
{
int v1; // ebx
const char *result; // rax
regex_t _0; // [rsp+0h] [rbp+0h] BYREF
unsigned long long vars48; // [rsp+48h] [rbp+48h]
vars48 = __readfsqword(0x28u);
regcomp(&_0, "^[a-z]+_[a-z]+$", 1);
v1 = regexec(&_0, string, 0LL, 0LL, 0);
regfree(&_0);
result = "Not ... | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
LEA RSI,[0x102020]
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
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010f0
MOV RDI,RBP
MOV EBX,EAX
CALL 0x001010a0
TEST... | 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);
regcomp(&rStack_68,"^[a-z]+_[a-z]+$",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
regfree(&rStack_68);
pcVar2 = "Not matched!";... |
3,960 | func0 | #include <assert.h>
| int func0(int a) {
int perimeter = 4 * a;
return perimeter;
}
| int main() {
assert(func0(10) == 40);
assert(func0(5) == 20);
assert(func0(4) == 16);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
shl $0x2,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
shl eax, 2
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
SHL EAX,0x2
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1)
{
return param_1 << 2;
} |
3,961 | func0 | #include <assert.h>
| int func0(int a) {
int perimeter = 4 * a;
return perimeter;
}
| int main() {
assert(func0(10) == 40);
assert(func0(5) == 20);
assert(func0(4) == 16);
return 0;
}
| O1 | c | func0:
endbr64
lea 0x0(,%rdi,4),%eax
retq
| func0:
endbr64
lea eax, ds:0[rdi*4]
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1);
} | ||
3,962 | func0 | #include <assert.h>
| int func0(int a) {
int perimeter = 4 * a;
return perimeter;
}
| int main() {
assert(func0(10) == 40);
assert(func0(5) == 20);
assert(func0(4) == 16);
return 0;
}
| O2 | c | func0:
endbr64
lea 0x0(,%rdi,4),%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
lea eax, ds:0[rdi*4]
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1);
} | func0:
ENDBR64
LEA EAX,[RDI*0x4]
RET | int func0(int param_1)
{
return param_1 * 4;
} |
3,963 | func0 | #include <assert.h>
| int func0(int a) {
int perimeter = 4 * a;
return perimeter;
}
| int main() {
assert(func0(10) == 40);
assert(func0(5) == 20);
assert(func0(4) == 16);
return 0;
}
| O3 | c | func0:
endbr64
lea 0x0(,%rdi,4),%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
lea eax, ds:0[rdi*4]
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1);
} | func0:
ENDBR64
LEA EAX,[RDI*0x4]
RET | int func0(int param_1)
{
return param_1 * 4;
} |
3,964 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#define NO_OF_CHARS 256
char *str_to_list(char *string) {
static char temp[256];
int i = 0;
while (*string) {
temp[i++] = *string++;
}
temp[i] = '\0';
return temp;
}
char *lst_to_string(char *list, int res_in... | char *func0(char *string, char *second_string) {
int *count = get_char_count_array(second_string);
int ip_ind = 0, res_ind = 0;
char *str_list = str_to_list(string);
while (str_list[ip_ind] != '\0') {
char temp = str_list[ip_ind];
if (count[(int)temp] == 0) {
str... | int main() {
assert(strcmp(func0("probasscurve", "pros"), "bacuve") == 0);
assert(strcmp(func0("digitalindia", "talent"), "digiidi") == 0);
assert(strcmp(func0("exoticmiles", "toxic"), "emles") == 0);
printf("All tests passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 126c <get_char_count_array>
mov %rax,-0x10(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 11c9 <str_to_l... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, [rbp+var_30]
mov rdi, rax
call get_char_count_array
mov [rbp+var_10], rax
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov rax, [rbp+var_28]
mov rdi, rax
call str_to_lis... | long long func0(long long a1, long long a2)
{
int v2; // eax
char v4; // [rsp+17h] [rbp-19h]
int v5; // [rsp+18h] [rbp-18h]
unsigned int v6; // [rsp+1Ch] [rbp-14h]
long long char_count_array; // [rsp+20h] [rbp-10h]
long long v8; // [rsp+28h] [rbp-8h]
char_count_array = get_char_count_array(a2);
v5 = 0... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x0010126f
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x... | void func0(int8 param_1,int8 param_2)
{
long lVar1;
long lVar2;
int4 local_20;
int4 local_1c;
lVar1 = get_char_count_array(param_2);
local_20 = 0;
local_1c = 0;
lVar2 = str_to_list(param_1);
for (; *(char *)(lVar2 + local_20) != '\0'; local_20 = local_20 + 1) {
if (*(int *)(lVar1 + (long)*(cha... |
3,965 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#define NO_OF_CHARS 256
char *str_to_list(char *string) {
static char temp[256];
int i = 0;
while (*string) {
temp[i++] = *string++;
}
temp[i] = '\0';
return temp;
}
char *lst_to_string(char *list, int res_in... | char *func0(char *string, char *second_string) {
int *count = get_char_count_array(second_string);
int ip_ind = 0, res_ind = 0;
char *str_list = str_to_list(string);
while (str_list[ip_ind] != '\0') {
char temp = str_list[ip_ind];
if (count[(int)temp] == 0) {
str... | int main() {
assert(strcmp(func0("probasscurve", "pros"), "bacuve") == 0);
assert(strcmp(func0("digitalindia", "talent"), "digiidi") == 0);
assert(strcmp(func0("exoticmiles", "toxic"), "emles") == 0);
printf("All tests passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%rdi
callq 11f4 <get_char_count_array>
mov %rax,%rbx
mov %rbp,%rdi
callq 1189 <str_to_list>
mov %rax,%rdi
movzbl (%rax),%edx
test %dl,%dl
je 128f <func0+0x58>
lea 0x1(%rax),%rcx
mov $0x0,%r8d
jmp 1279 <func0+0... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rdi, rsi
call get_char_count_array
mov rbx, rax
mov rdi, rbp
call str_to_list
mov rdi, rax
movzx edx, byte ptr [rax]
test dl, dl
jz short loc_12B6
lea rcx, [rax+1]
mov r8d, 0
jmp short loc_12A0
loc_129... | long long func0(long long a1, long long a2)
{
long long char_count_array; // rbx
char *v3; // rax
char v4; // dl
char *v5; // rcx
unsigned int v6; // r8d
char_count_array = get_char_count_array(a2);
v3 = (char *)str_to_list(a1);
v4 = *v3;
if ( *v3 )
{
v5 = v3 + 1;
v6 = 0;
do
{
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RDI,RSI
CALL 0x0010121b
MOV RBX,RAX
MOV RDI,RBP
CALL 0x001011a9
MOV RDI,RAX
MOVZX EDX,byte ptr [RAX]
TEST DL,DL
JZ 0x001012b6
LEA RCX,[RAX + 0x1]
MOV R8D,0x0
JMP 0x001012a0
LAB_00101294:
ADD RCX,0x1
MOVZX EDX,byte ptr [RCX + -0x1]
TEST DL,DL
JZ 0x001012bc
LAB... | void func0(int8 param_1,int8 param_2)
{
long lVar1;
char *pcVar2;
char *pcVar3;
char cVar4;
int iVar5;
lVar1 = get_char_count_array(param_2);
pcVar2 = (char *)str_to_list(param_1);
cVar4 = *pcVar2;
if (cVar4 == '\0') {
iVar5 = 0;
}
else {
iVar5 = 0;
pcVar3 = pcVar2;
do {
... |
3,966 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#define NO_OF_CHARS 256
char *str_to_list(char *string) {
static char temp[256];
int i = 0;
while (*string) {
temp[i++] = *string++;
}
temp[i] = '\0';
return temp;
}
char *lst_to_string(char *list, int res_in... | char *func0(char *string, char *second_string) {
int *count = get_char_count_array(second_string);
int ip_ind = 0, res_ind = 0;
char *str_list = str_to_list(string);
while (str_list[ip_ind] != '\0') {
char temp = str_list[ip_ind];
if (count[(int)temp] == 0) {
str... | int main() {
assert(strcmp(func0("probasscurve", "pros"), "bacuve") == 0);
assert(strcmp(func0("digitalindia", "talent"), "digiidi") == 0);
assert(strcmp(func0("exoticmiles", "toxic"), "emles") == 0);
printf("All tests passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbx
mov %rdi,%r8
mov %rsi,%rdi
callq 1310 <get_char_count_array>
movzbl (%r8),%ecx
test %cl,%cl
je 1410 <func0+0xc0>
mov $0x1,%edx
lea 0x31c7(%rip),%rdi
nopl 0x0(%rax,%rax,1)
mov %cl,(%rdi,%rdx,1)
movslq %edx,%rsi
add $0x1,%rdx
movzbl -0x1(%r8,%rdx,1),%ecx
test %cl,%c... | func0:
endbr64
lea rdx, count_1
xor eax, eax
mov r8, rdi
push rbx
mov ecx, 80h
mov rdi, rdx
rep stosq
movsx rax, byte ptr [rsi]
test al, al
jz short loc_1398
nop dword ptr [rax+00h]
loc_1388:
add rsi, 1
add dword ptr [rdx+rax*4], 1
movsx rax, byte ptr [rsi]
test al, al
... | long long func0(char *a1, char *a2)
{
long long i; // rax
char v3; // cl
long long v4; // rax
long long j; // rsi
char v6; // al
char *v7; // rcx
int v8; // esi
long long v9; // rdi
long long v10; // rbx
long long v11; // rdx
long long result; // rax
memset(count_1, 0, sizeof(count_1));
for ... | func0:
ENDBR64
LEA RDX,[0x104040]
XOR EAX,EAX
MOV R8,RDI
PUSH RBX
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOVSX RAX,byte ptr [RSI]
TEST AL,AL
JZ 0x00101398
NOP dword ptr [RAX]
LAB_00101388:
ADD RSI,0x1
ADD dword ptr [RDX + RAX*0x4],0x1
MOVSX RAX,byte ptr [RSI]
TEST AL,AL
JNZ 0x00101388
LAB_00101398:
MOVZX ECX,byte ptr [... | void func0(char *param_1,char *param_2)
{
char cVar1;
long lVar2;
char *pcVar3;
int iVar4;
long lVar5;
int8 *puVar6;
puVar6 = (int8 *)&count_1;
for (lVar2 = 0x80; lVar2 != 0; lVar2 = lVar2 + -1) {
*puVar6 = 0;
puVar6 = puVar6 + 1;
}
cVar1 = *param_2;
while (cVar1 != '\0') {
param_2... |
3,967 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#define NO_OF_CHARS 256
char *str_to_list(char *string) {
static char temp[256];
int i = 0;
while (*string) {
temp[i++] = *string++;
}
temp[i] = '\0';
return temp;
}
char *lst_to_string(char *list, int res_in... | char *func0(char *string, char *second_string) {
int *count = get_char_count_array(second_string);
int ip_ind = 0, res_ind = 0;
char *str_list = str_to_list(string);
while (str_list[ip_ind] != '\0') {
char temp = str_list[ip_ind];
if (count[(int)temp] == 0) {
str... | int main() {
assert(strcmp(func0("probasscurve", "pros"), "bacuve") == 0);
assert(strcmp(func0("digitalindia", "talent"), "digiidi") == 0);
assert(strcmp(func0("exoticmiles", "toxic"), "emles") == 0);
printf("All tests passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
lea 0x2ce5(%rip),%rdx
xor %eax,%eax
mov %rdi,%r8
push %rbx
mov $0x80,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movsbq (%rsi),%rax
test %al,%al
je 1388 <func0+0x38>
nopl 0x0(%rax)
add $0x1,%rsi
addl $0x1,(%rdx,%rax,4)
movsbq (%rsi),%rax
test %al,%al
jne 1378 <func0+0x2... | func0:
endbr64
lea rdx, count_1
xor eax, eax
mov r8, rdi
push rbx
mov ecx, 80h
mov rdi, rdx
rep stosq
movsx rax, byte ptr [rsi]
test al, al
jz short loc_13A8
nop dword ptr [rax+00h]
loc_1398:
add rsi, 1
add dword ptr [rdx+rax*4], 1
movsx rax, byte ptr [rsi]
test al, al
... | long long func0(char *a1, char *a2)
{
long long i; // rax
char v3; // cl
long long v4; // rax
int j; // esi
char v6; // al
char *v7; // rcx
long long v8; // rsi
long long v9; // rbx
long long v10; // rdx
long long result; // rax
memset(count_1, 0, sizeof(count_1));
for ( i = *a2; (_BYTE)i; i =... | func0:
ENDBR64
LEA RDX,[0x104040]
XOR EAX,EAX
MOV R8,RDI
PUSH RBX
MOV ECX,0x80
MOV RDI,RDX
STOSQ.REP RDI
MOVSX RAX,byte ptr [RSI]
TEST AL,AL
JZ 0x001013a8
NOP dword ptr [RAX]
LAB_00101398:
ADD RSI,0x1
ADD dword ptr [RDX + RAX*0x4],0x1
MOVSX RAX,byte ptr [RSI]
TEST AL,AL
JNZ 0x00101398
LAB_001013a8:
MOVZX ECX,byte ptr [... | void func0(char *param_1,char *param_2)
{
char cVar1;
long lVar2;
long lVar3;
char *pcVar4;
int iVar5;
ulong uVar6;
uint uVar7;
int8 *puVar8;
puVar8 = (int8 *)&count_1;
for (lVar3 = 0x80; lVar3 != 0; lVar3 = lVar3 + -1) {
*puVar8 = 0;
puVar8 = puVar8 + 1;
}
cVar1 = *param_2;
while ... |
3,968 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int arraynums[], int length) {
bool found_duplicate = false;
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (arraynums[i] == arraynums[j]) {
found_duplicate = true;
break;
}
}
if (fo... | int main() {
int array1[] = {1, 2, 3, 4, 5};
int array2[] = {1, 2, 3, 4, 4};
int array3[] = {1, 1, 2, 2, 3, 3, 4, 4, 5};
assert(func0(array1, sizeof(array1)/sizeof(array1[0])) == false);
assert(func0(array2, sizeof(array2)/sizeof(array2[0])) == true);
assert(func0(array3, sizeof(array3)/... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movb $0x0,-0x9(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11dc <func0+0x73>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11ca <func0+0x61>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_9], 0
mov [rbp+var_8], 0
jmp short loc_11DC
loc_1185:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11CA
loc_1190:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0... | long long func0(long long a1, int a2)
{
unsigned __int8 v3; // [rsp+13h] [rbp-9h]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * j + a1) )
{
v3 =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV byte ptr [RBP + -0x9],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011dc
LAB_00101185:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011ca
LAB_00101190:
MOV EAX,dword ptr [RBP + -0... | char func0(long param_1,int param_2)
{
char local_11;
int local_10;
int local_c;
local_11 = '\0';
local_10 = 0;
do {
local_c = local_10;
if (param_2 <= local_10) {
return local_11;
}
do {
local_c = local_c + 1;
if (param_2 <= local_c) goto LAB_001011d2;
} while (*(i... |
3,969 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int arraynums[], int length) {
bool found_duplicate = false;
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (arraynums[i] == arraynums[j]) {
found_duplicate = true;
break;
}
}
if (fo... | int main() {
int array1[] = {1, 2, 3, 4, 5};
int array2[] = {1, 2, 3, 4, 4};
int array3[] = {1, 1, 2, 2, 3, 3, 4, 4, 5};
assert(func0(array1, sizeof(array1)/sizeof(array1[0])) == false);
assert(func0(array2, sizeof(array2)/sizeof(array2[0])) == true);
assert(func0(array3, sizeof(array3)/... | O1 | c | func0:
endbr64
mov $0x1,%ecx
jmp 1178 <func0+0xf>
add $0x1,%rcx
lea -0x1(%rcx),%eax
cmp %eax,%esi
jle 1199 <func0+0x30>
cmp %ecx,%esi
jle 1174 <func0+0xb>
mov -0x4(%rdi,%rcx,4),%edx
movslq %ecx,%rax
cmp (%rdi,%rax,4),%edx
je 119f <func0+0x36>
add $0x1,%rax
cmp %eax,%esi
jg 11... | func0:
endbr64
mov ecx, 1
jmp short loc_1178
loc_1174:
add rcx, 1
loc_1178:
lea eax, [rcx-1]
cmp esi, eax
jle short loc_1199
cmp esi, ecx
jle short loc_1174
mov edx, [rdi+rcx*4-4]
movsxd rax, ecx
loc_118A:
cmp edx, [rdi+rax*4]
jz short loc_119F
add rax, 1
cmp esi, e... | long long func0(long long a1, int a2)
{
long long i; // rcx
long long v3; // rax
for ( i = 1LL; ; ++i )
{
if ( a2 <= (int)i - 1 )
return 0LL;
if ( a2 > (int)i )
break;
LABEL_2:
;
}
v3 = (int)i;
while ( *(_DWORD *)(a1 + 4 * i - 4) != *(_DWORD *)(a1 + 4 * v3) )
{
if ( a2 <= (... | func0:
ENDBR64
MOV ECX,0x1
JMP 0x00101178
LAB_00101174:
ADD RCX,0x1
LAB_00101178:
LEA EAX,[RCX + -0x1]
CMP ESI,EAX
JLE 0x00101199
CMP ESI,ECX
JLE 0x00101174
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOVSXD RAX,ECX
LAB_0010118a:
CMP EDX,dword ptr [RDI + RAX*0x4]
JZ 0x0010119f
ADD RAX,0x1
CMP ESI,EAX
JG 0x0010118a
JMP 0x0... | int8 func0(long param_1,int param_2)
{
int iVar1;
long lVar2;
long lVar3;
lVar3 = 1;
do {
iVar1 = (int)lVar3;
if (param_2 <= iVar1 + -1) {
return 0;
}
if (iVar1 < param_2) {
lVar2 = (long)iVar1;
do {
if (*(int *)(param_1 + -4 + lVar3 * 4) == *(int *)(param_1 + lVa... |
3,970 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int arraynums[], int length) {
bool found_duplicate = false;
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (arraynums[i] == arraynums[j]) {
found_duplicate = true;
break;
}
}
if (fo... | int main() {
int array1[] = {1, 2, 3, 4, 5};
int array2[] = {1, 2, 3, 4, 4};
int array3[] = {1, 1, 2, 2, 3, 3, 4, 4, 5};
assert(func0(array1, sizeof(array1)/sizeof(array1[0])) == false);
assert(func0(array2, sizeof(array2)/sizeof(array2[0])) == true);
assert(func0(array3, sizeof(array3)/... | O2 | c | func0:
endbr64
test %esi,%esi
jle 12e1 <func0+0x51>
lea -0x1(%rsi),%r8d
mov $0x1,%ecx
add $0x1,%r8
cmp %r8,%rcx
je 12e1 <func0+0x51>
nopw 0x0(%rax,%rax,1)
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
jmp 12c8 <func0+0x38>
nopl 0x0(%rax)
add $0x1,%rax
cmp %eax,%esi
jle 12d8 <func0+... | func0:
endbr64
test esi, esi
jle short loc_1309
movsxd r8, esi
mov ecx, 1
cmp rcx, r8
jz short loc_1309
nop dword ptr [rax]
loc_12D8:
mov edx, [rdi+rcx*4-4]
mov rax, rcx
jmp short loc_12F0
loc_12E8:
add rax, 1
cmp esi, eax
jle short loc_1300
loc_12F0:
cmp edx, [rdi+r... | long long func0(long long a1, int a2)
{
long long i; // rcx
long long v3; // rax
if ( a2 > 0 )
{
for ( i = 1LL; i != a2; ++i )
{
v3 = i;
do
{
if ( *(_DWORD *)(a1 + 4 * i - 4) == *(_DWORD *)(a1 + 4 * v3) )
return 1LL;
++v3;
}
while ( a2 > (int)v3 ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101309
MOVSXD R8,ESI
MOV ECX,0x1
CMP RCX,R8
JZ 0x00101309
NOP dword ptr [RAX]
LAB_001012d8:
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
JMP 0x001012f0
LAB_001012e8:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101300
LAB_001012f0:
CMP EDX,dword ptr [RDI + RAX*0x4]
JNZ 0x001012e8
MOV EAX,... | int8 func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
if (0 < param_2) {
lVar2 = 1;
if ((long)param_2 != 1) {
do {
lVar1 = lVar2;
do {
if (*(int *)(param_1 + -4 + lVar2 * 4) == *(int *)(param_1 + lVar1 * 4)) {
return 1;
}
lVar1 =... |
3,971 | func0 | #include <assert.h>
#include <stdbool.h>
| bool func0(int arraynums[], int length) {
bool found_duplicate = false;
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (arraynums[i] == arraynums[j]) {
found_duplicate = true;
break;
}
}
if (fo... | int main() {
int array1[] = {1, 2, 3, 4, 5};
int array2[] = {1, 2, 3, 4, 4};
int array3[] = {1, 1, 2, 2, 3, 3, 4, 4, 5};
assert(func0(array1, sizeof(array1)/sizeof(array1[0])) == false);
assert(func0(array2, sizeof(array2)/sizeof(array2[0])) == true);
assert(func0(array3, sizeof(array3)/... | O3 | c | func0:
endbr64
test %esi,%esi
jle 12e1 <func0+0x51>
lea -0x1(%rsi),%r8d
mov $0x1,%ecx
add $0x1,%r8
cmp %rcx,%r8
je 12e1 <func0+0x51>
nopw 0x0(%rax,%rax,1)
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
jmp 12c8 <func0+0x38>
nopl 0x0(%rax)
add $0x1,%rax
cmp %eax,%esi
jle 12d8 <func0+... | func0:
endbr64
mov ecx, 1
lea eax, [rcx-1]
cmp esi, eax
jle short loc_1183
loc_1150:
cmp esi, ecx
jle short loc_1178
mov edx, [rdi+rcx*4-4]
mov rax, rcx
jmp short loc_1168
loc_1160:
add rax, 1
cmp esi, eax
jle short loc_1178
loc_1168:
cmp edx, [rdi+rax*4]
jnz shor... | long long func0(long long a1, int a2)
{
long long v2; // rcx
long long v3; // rax
v2 = 1LL;
if ( a2 <= 0 )
return 0LL;
while ( a2 <= (int)v2 )
{
LABEL_7:
if ( a2 <= (int)++v2 - 1 )
return 0LL;
}
v3 = v2;
while ( *(_DWORD *)(a1 + 4 * v2 - 4) != *(_DWORD *)(a1 + 4 * v3) )
{
if ( a2... | func0:
ENDBR64
MOV ECX,0x1
LEA EAX,[RCX + -0x1]
CMP ESI,EAX
JLE 0x00101183
LAB_00101150:
CMP ESI,ECX
JLE 0x00101178
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
JMP 0x00101168
LAB_00101160:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101178
LAB_00101168:
CMP EDX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101160
MOV EAX,0x1
RET
LAB_... | int8 func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
long lVar3;
lVar3 = 1;
if (0 < param_2) {
do {
iVar2 = (int)lVar3;
if (iVar2 < param_2) {
lVar1 = lVar3;
do {
if (*(int *)(param_1 + -4 + lVar3 * 4) == *(int *)(param_1 + lVar1 * 4)) {
retur... |
3,972 | func0 | #include <stdbool.h>
#include <assert.h>
| bool func0(long long x) {
if (x % 2 == 0) {
return false;
}
if (x == 1) {
return true;
}
x = x + 1;
long long p = 0;
while (x % 2 == 0) {
x = x / 2;
p = p + 1;
if (p == x) {
return true;
}
}
return false;
}
... | int main() {
assert(func0(383) == true);
assert(func0(254) == false);
assert(func0(200) == false);
assert(func0(32212254719) == true);
assert(func0(32212254718) == false);
assert(func0(159) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
and $0x1,%eax
test %rax,%rax
jne 1168 <func0+0x1f>
mov $0x0,%eax
jmp 11c1 <func0+0x78>
cmpq $0x1,-0x18(%rbp)
jne 1176 <func0+0x2d>
mov $0x1,%eax
jmp 11c1 <func0+0x78>
addq $0x1,-0x18(%rbp)
movq $0x0,... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov rax, [rbp+var_18]
and eax, 1
test rax, rax
jnz short loc_1168
mov eax, 0
jmp short loc_11C1
loc_1168:
cmp [rbp+var_18], 1
jnz short loc_1176
mov eax, 1
jmp short loc_11C1
loc_1176:
add [rbp+var_18], 1
mo... | long long func0(long long a1)
{
long long v2; // [rsp+0h] [rbp-18h]
long long v3; // [rsp+10h] [rbp-8h]
if ( (a1 & 1) == 0 )
return 0LL;
if ( a1 == 1 )
return 1LL;
v2 = a1 + 1;
v3 = 0LL;
while ( (v2 & 1) == 0 )
{
v2 /= 2LL;
if ( ++v3 == v2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
AND EAX,0x1
TEST RAX,RAX
JNZ 0x00101168
MOV EAX,0x0
JMP 0x001011c1
LAB_00101168:
CMP qword ptr [RBP + -0x18],0x1
JNZ 0x00101176
MOV EAX,0x1
JMP 0x001011c1
LAB_00101176:
ADD qword ptr [RBP + -0x18],0x1
MOV qword ptr [RBP ... | int8 func0(ulong param_1)
{
int8 uVar1;
ulong local_20;
ulong local_10;
if ((param_1 & 1) == 0) {
uVar1 = 0;
}
else if (param_1 == 1) {
uVar1 = 1;
}
else {
local_20 = param_1 + 1;
local_10 = 0;
do {
if ((local_20 & 1) != 0) {
return 0;
}
local_20 = (long... |
3,973 | func0 | #include <stdbool.h>
#include <assert.h>
| bool func0(long long x) {
if (x % 2 == 0) {
return false;
}
if (x == 1) {
return true;
}
x = x + 1;
long long p = 0;
while (x % 2 == 0) {
x = x / 2;
p = p + 1;
if (p == x) {
return true;
}
}
return false;
}
... | int main() {
assert(func0(383) == true);
assert(func0(254) == false);
assert(func0(200) == false);
assert(func0(32212254719) == true);
assert(func0(32212254718) == false);
assert(func0(159) == true);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%eax
test $0x1,%dil
je 118e <func0+0x45>
mov $0x1,%eax
cmp $0x1,%rdi
je 118e <func0+0x45>
lea 0x1(%rdi),%rax
mov $0x0,%edx
test $0x1,%al
jne 118f <func0+0x46>
mov %rax,%rdi
shr $0x3f,%rdi
add %rax,%rdi
sar %rdi
mov %rdi,%rax
add $0x1,%rdx
cmp %r... | func0:
endbr64
mov eax, 0
test dil, 1
jz short locret_1190
mov eax, 1
cmp rdi, 1
jz short locret_1190
add rdi, 1
mov edx, 0
loc_116C:
test dil, 1
jnz short loc_1191
mov rax, rdi
shr rax, 3Fh
add rax, rdi
sar rax, 1
mov rdi, rax
add rdx, 1
cmp rax, rdx
... | long long func0(long long a1)
{
long long result; // rax
long long v2; // rdi
long long v3; // rdx
result = 0LL;
if ( (a1 & 1) != 0 )
{
result = 1LL;
if ( a1 != 1 )
{
v2 = a1 + 1;
v3 = 0LL;
while ( (v2 & 1) == 0 )
{
v2 /= 2LL;
if ( v2 == ++v3 )
... | func0:
ENDBR64
MOV EAX,0x0
TEST DIL,0x1
JZ 0x00101190
MOV EAX,0x1
CMP RDI,0x1
JZ 0x00101190
ADD RDI,0x1
MOV EDX,0x0
LAB_0010116c:
TEST DIL,0x1
JNZ 0x00101191
MOV RAX,RDI
SHR RAX,0x3f
ADD RAX,RDI
SAR RAX,0x1
MOV RDI,RAX
ADD RDX,0x1
CMP RAX,RDX
JNZ 0x0010116c
MOV EAX,0x1
LAB_00101190:
RET
LAB_00101191:
MOV EAX,0x0
RET | int8 func0(ulong param_1)
{
int8 uVar1;
ulong uVar2;
uVar1 = 0;
if (((param_1 & 1) != 0) && (uVar1 = 1, param_1 != 1)) {
param_1 = param_1 + 1;
uVar2 = 0;
do {
if ((param_1 & 1) != 0) {
return 0;
}
param_1 = (long)param_1 / 2;
uVar2 = uVar2 + 1;
} while (param... |
3,974 | func0 | #include <stdbool.h>
#include <assert.h>
| bool func0(long long x) {
if (x % 2 == 0) {
return false;
}
if (x == 1) {
return true;
}
x = x + 1;
long long p = 0;
while (x % 2 == 0) {
x = x / 2;
p = p + 1;
if (p == x) {
return true;
}
}
return false;
}
... | int main() {
assert(func0(383) == true);
assert(func0(254) == false);
assert(func0(200) == false);
assert(func0(32212254719) == true);
assert(func0(32212254718) == false);
assert(func0(159) == true);
return 0;
}
| O2 | c | func0:
endbr64
test $0x1,%dil
je 1248 <func0+0x18>
cmp $0x1,%rdi
je 1250 <func0+0x20>
jmp 11f0 <func0.part.0>
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0_part_0:
add rdi, 1
xor eax, eax
jmp short loc_1216
loc_1200:
mov rdx, rdi
add rax, 1
shr rdx, 3Fh
add rdi, rdx
sar rdi, 1
cmp rdi, rax
jz short loc_1220
loc_1216:
test dil, 1
jz short loc_1200
xor eax, eax
retn
loc_1220:
mov eax, 1
retn | long long func0_part_0(long long a1)
{
long long v1; // rdi
long long v2; // rax
v1 = a1 + 1;
v2 = 0LL;
do
{
if ( (v1 & 1) != 0 )
return 0LL;
++v2;
v1 /= 2LL;
}
while ( v1 != v2 );
return 1LL;
} | func0.part.0:
ADD RDI,0x1
XOR EAX,EAX
JMP 0x00101216
LAB_00101200:
MOV RDX,RDI
ADD RAX,0x1
SHR RDX,0x3f
ADD RDI,RDX
SAR RDI,0x1
CMP RDI,RAX
JZ 0x00101220
LAB_00101216:
TEST DIL,0x1
JZ 0x00101200
XOR EAX,EAX
RET
LAB_00101220:
MOV EAX,0x1
RET | int8 func0_part_0(long param_1)
{
ulong uVar1;
ulong uVar2;
uVar2 = param_1 + 1;
uVar1 = 0;
do {
if ((uVar2 & 1) != 0) {
return 0;
}
uVar1 = uVar1 + 1;
uVar2 = (long)uVar2 / 2;
} while (uVar2 != uVar1);
return 1;
} |
3,975 | func0 | #include <stdbool.h>
#include <assert.h>
| bool func0(long long x) {
if (x % 2 == 0) {
return false;
}
if (x == 1) {
return true;
}
x = x + 1;
long long p = 0;
while (x % 2 == 0) {
x = x / 2;
p = p + 1;
if (p == x) {
return true;
}
}
return false;
}
... | int main() {
assert(func0(383) == true);
assert(func0(254) == false);
assert(func0(200) == false);
assert(func0(32212254719) == true);
assert(func0(32212254718) == false);
assert(func0(159) == true);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
test $0x1,%dil
je 1275 <func0+0x45>
mov $0x1,%eax
cmp $0x1,%rdi
je 1275 <func0+0x45>
add $0x1,%rdi
xor %eax,%eax
jmp 1266 <func0+0x36>
mov %rdi,%rdx
add $0x1,%rax
shr $0x3f,%rdx
add %rdx,%rdi
sar %rdi
cmp %rax,%rdi
je 1270 <func0+0x40>
test ... | func0_part_0:
add rdi, 1
xor eax, eax
jmp short loc_1216
loc_1200:
mov rdx, rdi
add rax, 1
shr rdx, 3Fh
add rdi, rdx
sar rdi, 1
cmp rdi, rax
jz short loc_1220
loc_1216:
test dil, 1
jz short loc_1200
xor eax, eax
retn
loc_1220:
mov eax, 1
retn | long long func0_part_0(long long a1)
{
long long v1; // rdi
long long v2; // rax
v1 = a1 + 1;
v2 = 0LL;
do
{
if ( (v1 & 1) != 0 )
return 0LL;
++v2;
v1 /= 2LL;
}
while ( v1 != v2 );
return 1LL;
} | func0.part.0:
ADD RDI,0x1
XOR EAX,EAX
JMP 0x00101216
LAB_00101200:
MOV RDX,RDI
ADD RAX,0x1
SHR RDX,0x3f
ADD RDI,RDX
SAR RDI,0x1
CMP RDI,RAX
JZ 0x00101220
LAB_00101216:
TEST DIL,0x1
JZ 0x00101200
XOR EAX,EAX
RET
LAB_00101220:
MOV EAX,0x1
RET | int8 func0_part_0(long param_1)
{
ulong uVar1;
ulong uVar2;
uVar2 = param_1 + 1;
uVar1 = 0;
do {
if ((uVar2 & 1) != 0) {
return 0;
}
uVar1 = uVar1 + 1;
uVar2 = (long)uVar2 / 2;
} while (uVar2 != uVar1);
return 1;
} |
3,976 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int m, int n, int* length) {
*length = m;
int* results = malloc(sizeof(int) * m);
if (!results) {
return NULL;
}
for (int i = 0; i < m; i++) {
results[i] = (i + 1) * n;
}
return results;
}
| int main() {
int length, *result;
result = func0(4, 3, &length);
int expected1[] = {3, 6, 9, 12};
for (int i = 0; i < length; i++) {
assert(result[i] == expected1[i]);
}
free(result);
result = func0(2, 5, &length);
int expected2[] = {5, 10};
for (int i =... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %rdx,-0x20(%rbp)
mov -0x20(%rbp),%rax
mov -0x14(%rbp),%edx
mov %edx,(%rax)
mov -0x14(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
mov edx, [rbp+var_14]
mov [rax], edx
mov eax, [rbp+var_14]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
... | _DWORD * func0(int a1, int a2, _DWORD *a3)
{
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v5; // [rsp+18h] [rbp-8h]
*a3 = a1;
v5 = malloc(4LL * a1);
if ( !v5 )
return 0LL;
for ( i = 0; i < a1; ++i )
v5[i] = a2 * (i + 1);
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x14]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ... | void * func0(int param_1,int param_2,int *param_3)
{
void *pvVar1;
int4 local_14;
*param_3 = param_1;
pvVar1 = malloc((long)param_1 << 2);
if (pvVar1 == (void *)0x0) {
pvVar1 = (void *)0x0;
}
else {
for (local_14 = 0; local_14 < param_1; local_14 = local_14 + 1) {
*(int *)((long)pvVar1 +... |
3,977 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int m, int n, int* length) {
*length = m;
int* results = malloc(sizeof(int) * m);
if (!results) {
return NULL;
}
for (int i = 0; i < m; i++) {
results[i] = (i + 1) * n;
}
return results;
}
| int main() {
int length, *result;
result = func0(4, 3, &length);
int expected1[] = {3, 6, 9, 12};
for (int i = 0; i < length; i++) {
assert(result[i] == expected1[i]);
}
free(result);
result = func0(2, 5, &length);
int expected2[] = {5, 10};
for (int i =... | O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebp
mov %esi,%ebx
mov %edi,(%rdx)
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 11ea <func0+0x41>
test %ebp,%ebp
jle 11ea <func0+0x41>
mov %ebx,%edi
mov %rax,%rdx
lea -0x1(%rbp),%ecx
lea 0x4(... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov ebp, edi
mov ebx, esi
mov [rdx], edi
movsxd rdi, edi
shl rdi, 2
call _malloc
test rax, rax
jz short loc_11E6
test ebp, ebp
jle short loc_11E6
mov rdx, rax
mov ebp, ebp
lea rsi, [rax+rbp*4]
mov ecx, ebx
loc_11D9:... | long long func0(int a1, int a2, int *a3)
{
long long result; // rax
_DWORD *v4; // rdx
int v5; // ecx
*a3 = a1;
result = malloc(4LL * a1);
if ( result && a1 > 0 )
{
v4 = (_DWORD *)result;
v5 = a2;
do
{
*v4 = v5;
v5 += a2;
++v4;
}
while ( v4 != (_DWORD *)(result ... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBP,EDI
MOV EBX,ESI
MOV dword ptr [RDX],EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
TEST RAX,RAX
JZ 0x001011e6
TEST EBP,EBP
JLE 0x001011e6
MOV RDX,RAX
MOV EBP,EBP
LEA RSI,[RAX + RBP*0x4]
MOV ECX,EBX
LAB_001011d9:
MOV dword ptr [RDX],ECX
ADD ECX,EBX
ADD RDX,0x4
CMP RDX... | void func0(uint param_1,int param_2,uint *param_3)
{
int *piVar1;
int *piVar2;
int iVar3;
*param_3 = param_1;
piVar2 = (int *)malloc((long)(int)param_1 << 2);
if ((piVar2 != (int *)0x0) && (0 < (int)param_1)) {
piVar1 = piVar2 + param_1;
iVar3 = param_2;
do {
*piVar2 = iVar3;
iVa... |
3,978 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int m, int n, int* length) {
*length = m;
int* results = malloc(sizeof(int) * m);
if (!results) {
return NULL;
}
for (int i = 0; i < m; i++) {
results[i] = (i + 1) * n;
}
return results;
}
| int main() {
int length, *result;
result = func0(4, 3, &length);
int expected1[] = {3, 6, 9, 12};
for (int i = 0; i < length; i++) {
assert(result[i] == expected1[i]);
}
free(result);
result = func0(2, 5, &length);
int expected2[] = {5, 10};
for (int i =... | O2 | c | func0:
endbr64
push %rbp
movslq %edi,%rdi
push %rbx
mov %rdi,%rbp
mov %esi,%ebx
sub $0x8,%rsp
mov %edi,(%rdx)
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 13b5 <func0+0x45>
test %ebp,%ebp
jle 13b5 <func0+0x45>
lea -0x1(%rbp),%ecx
mov %rax,%rdx
lea 0x4(%rax,%rcx,4),%rsi... | func0:
endbr64
push rbp
movsxd rdi, edi
push rbx
mov rbp, rdi
mov ebx, esi
sub rsp, 8
mov [rdx], edi
shl rdi, 2
call _malloc
test rax, rax
jz short loc_13B5
test ebp, ebp
jle short loc_13B5
mov ebp, ebp
mov rdx, rax
mov ecx, ebx
lea rsi, [rax+rbp*4]
nop d... | long long func0(int a1, int a2, int *a3)
{
long long result; // rax
_DWORD *v4; // rdx
int v5; // ecx
*a3 = a1;
result = malloc(4LL * a1);
if ( result && a1 > 0 )
{
v4 = (_DWORD *)result;
v5 = a2;
do
{
*v4++ = v5;
v5 += a2;
}
while ( v4 != (_DWORD *)(result + 4LL * (u... | func0:
ENDBR64
PUSH RBP
MOVSXD RDI,EDI
PUSH RBX
MOV RBP,RDI
MOV EBX,ESI
SUB RSP,0x8
MOV dword ptr [RDX],EDI
SHL RDI,0x2
CALL 0x001010b0
TEST RAX,RAX
JZ 0x001013b5
TEST EBP,EBP
JLE 0x001013b5
MOV EBP,EBP
MOV RDX,RAX
MOV ECX,EBX
LEA RSI,[RAX + RBP*0x4]
NOP dword ptr [RAX]
LAB_001013a8:
MOV dword ptr [RDX],ECX
ADD RDX,0x4... | void func0(uint param_1,int param_2,uint *param_3)
{
int *piVar1;
int *piVar2;
int iVar3;
*param_3 = param_1;
piVar2 = (int *)malloc((long)(int)param_1 << 2);
if ((piVar2 != (int *)0x0) && (0 < (int)param_1)) {
piVar1 = piVar2 + param_1;
iVar3 = param_2;
do {
*piVar2 = iVar3;
piV... |
3,979 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
| int* func0(int m, int n, int* length) {
*length = m;
int* results = malloc(sizeof(int) * m);
if (!results) {
return NULL;
}
for (int i = 0; i < m; i++) {
results[i] = (i + 1) * n;
}
return results;
}
| int main() {
int length, *result;
result = func0(4, 3, &length);
int expected1[] = {3, 6, 9, 12};
for (int i = 0; i < length; i++) {
assert(result[i] == expected1[i]);
}
free(result);
result = func0(2, 5, &length);
int expected2[] = {5, 10};
for (int i =... | O3 | c | func0:
endbr64
push %rbp
movslq %edi,%rdi
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
mov %edi,(%rdx)
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 1493 <func0+0xe3>
test %ebx,%ebx
jle 1493 <func0+0xe3>
lea -0x1(%rbx),%edx
cmp $0x2,%edx
jbe 149a <func0+0xea>
mov... | func0:
endbr64
push rbp
movsxd rdi, edi
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 8
mov [rdx], edi
shl rdi, 2; size
call _malloc
mov rcx, rax
test rax, rax
jz loc_1461
test ebx, ebx
jle loc_1461
lea eax, [rbx-1]
cmp eax, 2
jbe loc_146B
movd xmm7, ebp
mov... | __m128i * func0(int a1, unsigned int a2, int *a3)
{
__m128i *v3; // rcx
__m128i si128; // xmm2
__m128i v5; // xmm6
__m128i v6; // xmm3
__m128i v7; // xmm5
__m128i *v8; // rax
__m128i v9; // xmm4
__m128i v10; // xmm0
__m128i v11; // xmm1
int v12; // eax
long long v13; // r8
int v14; // edx
unsi... | func0:
ENDBR64
PUSH RBP
MOVSXD RDI,EDI
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV dword ptr [RDX],EDI
SHL RDI,0x2
CALL 0x001010b0
MOV RCX,RAX
TEST RAX,RAX
JZ 0x00101461
TEST EBX,EBX
JLE 0x00101461
LEA EAX,[RBX + -0x1]
CMP EAX,0x2
JBE 0x0010146b
MOVD XMM7,EBP
MOV EDX,EBX
MOVDQA XMM2,xmmword ptr [0x00102080]
MOVDQA... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 * func0(uint param_1,uint param_2,uint *param_3)
{
long lVar1;
int auVar2 [16];
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
uint uVar10;
int8 *puVar11;
int8 *puVar12;
in... |
3,980 | func0 |
#include <assert.h>
#include <stdbool.h>
| int func0(int nums[], int length) {
bool exists[1001] = {false}; // Assuming numbers are within 1 to 1000
int no_duplicate = -1;
for (int i = 0; i < length; i++) {
if (exists[nums[i]]) {
return nums[i];
} else {
exists[nums[i]] = true;
}
}
... | int main() {
int arr1[] = {1, 2, 3, 4, 4, 5};
int arr2[] = {1, 2, 3, 4};
int arr3[] = {1, 1, 2, 3, 3, 2, 2};
assert(func0(arr1, 6) == 4);
assert(func0(arr2, 4) == -1);
assert(func0(arr3, 7) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x420,%rsp
mov %rdi,-0x418(%rbp)
mov %esi,-0x41c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x400(%rbp),%rdx
mov $0x0,%eax
mov $0x7d,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
mov %rdi,%rdx
mov %al,(%rdx)
add $0... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 420h
mov [rbp+var_418], rdi
mov [rbp+var_41C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_400]
mov eax, 0
mov ecx, 7Dh ; '}'
mov rdi, rdx
rep stosq
mov rdx, rdi
mov [rdx], al
add rdx, 1
... | long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-408h]
_BYTE v4[1016]; // [rsp+20h] [rbp-400h] BYREF
unsigned long long v5; // [rsp+418h] [rbp-8h]
v5 = __readfsqword(0x28u);
memset(v4, 0, 1001);
for ( i = 0; i < a2; ++i )
{
if ( v4[*(int *)(4LL * i + a1)] )
return *(unsigned in... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x420
MOV qword ptr [RBP + -0x418],RDI
MOV dword ptr [RBP + -0x41c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x400]
MOV EAX,0x0
MOV ECX,0x7d
MOV RDI,RDX
STOSQ.REP RDI
MOV RDX,RDI
MOV byte ptr [RDX],AL
ADD RDX,0x1
MOV dword ptr... | int4 func0(long param_1,int param_2)
{
int4 uVar1;
long lVar2;
char *pcVar3;
long in_FS_OFFSET;
int local_410;
char local_408 [1016];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar3 = local_408;
for (lVar2 = 0x7d; lVar2 != 0; lVar2 = lVar2 + -1) {
pcVar3[0] = '\0';
pcVar... |
3,981 | func0 |
#include <assert.h>
#include <stdbool.h>
| int func0(int nums[], int length) {
bool exists[1001] = {false}; // Assuming numbers are within 1 to 1000
int no_duplicate = -1;
for (int i = 0; i < length; i++) {
if (exists[nums[i]]) {
return nums[i];
} else {
exists[nums[i]] = true;
}
}
... | int main() {
int arr1[] = {1, 2, 3, 4, 4, 5};
int arr2[] = {1, 2, 3, 4};
int arr3[] = {1, 1, 2, 3, 3, 2, 2};
assert(func0(arr1, 6) == 4);
assert(func0(arr2, 4) == -1);
assert(func0(arr3, 7) == 1);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x408,%rsp
mov %rdi,%r8
mov %fs:0x28,%rax
mov %rax,0x3f8(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x7d,%ecx
rep stos %rax,%es:(%rdi)
movb $0x0,(%rdi)
test %esi,%esi
jle 11df <func0+0x76>
mov %r8,%rdx
lea -0x1(%rsi),%eax
lea 0x4(%r8,%rax,4),%rsi
mov (%rdx),%eax
m... | func0:
endbr64
sub rsp, 408h
mov r8, rdi
mov rax, fs:28h
mov [rsp+408h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 7Dh ; '}'
rep stosq
mov byte ptr [rdi], 0
test esi, esi
jle short loc_11DF
mov rdx, r8
lea eax, [rsi-1]
lea rsi, [r8+rax*4+4]
loc_11A7:
mov eax, [... | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // rdx
long long v3; // rsi
long long result; // rax
_BYTE v5[1016]; // [rsp+0h] [rbp-408h] BYREF
unsigned long long v6; // [rsp+3F8h] [rbp-10h]
v6 = __readfsqword(0x28u);
memset(v5, 0, 1001);
if ( a2 <= 0 )
return 0xFFFFFFFFLL;
v2 = ... | func0:
ENDBR64
SUB RSP,0x408
MOV R8,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x3f8],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0x7d
STOSQ.REP RDI
MOV byte ptr [RDI],0x0
TEST ESI,ESI
JLE 0x001011df
MOV RDX,R8
LEA EAX,[RSI + -0x1]
LEA RSI,[R8 + RAX*0x4 + 0x4]
LAB_001011a7:
MOV EAX,dword ptr [RDX]
MOVSXD RCX,EAX
CMP ... | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
long lVar3;
char *pcVar4;
long in_FS_OFFSET;
char local_408 [1016];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar4 = local_408;
for (lVar3 = 0x7d; lVar3 != 0; lVar3 = lVar3 + -1) {
*(int8 *)pcVar4 = 0;
pcVar4... |
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.