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,382 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(std::vector<int> arr, std::vector<int> dep, int n) {
std::sort(arr.begin(), arr.end());
std::sort(dep.begin(), dep.end());
int plat_needed = 1;
int result = 1;
int i = 1;
int j = 0;
while (i < n && j < n) {
if (arr[i] <= dep[j]) {
plat_needed++;... | int main() {
assert(func0({900, 940, 950, 1100, 1500, 1800}, {910, 1200, 1120, 1130, 1900, 2000}, 6) == 3);
assert(func0({100, 200, 300, 400}, {700, 800, 900, 1000}, 4) == 4);
assert(func0({5, 6, 7, 8}, {4, 3, 2, 1}, 4) == 1);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >, int):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
mov 0x8(%rdi),%r14
mov %edx,%ebx
mov (%rdi),%r13
cmp %r13,%r14
je 1605 <_Z5func0St6vectorIiSaIiEES1_i+0x55>
mo... | _Z5func0St6vectorIiSaIiEES1_i:
endbr64
push r14
push r13
push r12
mov r12, rdi
push rbp
mov rbp, rsi
push rbx
mov r14, [rdi+8]
mov ebx, edx
mov r13, [rdi]
cmp r14, r13
jz short loc_1923
mov rax, r14
mov rdx, 0FFFFFFFFFFFFFFFEh
sub rax, r13
sar rax, 2
jz s... | long long func0(_QWORD *a1, _QWORD *a2, int a3)
{
long long v5; // r14
long long v7; // r13
long long v8; // rdx
unsigned long long v9; // rax
long long v10; // r14
long long v11; // r13
long long v12; // rdx
unsigned long long v13; // rax
int v14; // ecx
int v15; // edx
int v16; // edi
int v17... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV R14,qword ptr [RDI + 0x8]
MOV EBX,EDX
MOV R13,qword ptr [RDI]
CMP R14,R13
JZ 0x00101923
MOV RAX,R14
MOV RDX,-0x2
SUB RAX,R13
SAR RAX,0x2
JZ 0x0010190d
BSR RAX,RAX
CDQE
LEA RDX,[RAX + RAX*0x1]
LAB_0010190d:
MOV RSI,R14
MOV RDI,R13
CA... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,vector param_2,int param_3)
{
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
_Iter_less_iter in_ECX;
int iVar5;
_Iter_less_iter extraout_EDX;
_Iter_less_iter extraout_EDX_00;
in... |
3,383 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(std::vector<int> arr, std::vector<int> dep, int n) {
std::sort(arr.begin(), arr.end());
std::sort(dep.begin(), dep.end());
int plat_needed = 1;
int result = 1;
int i = 1;
int j = 0;
while (i < n && j < n) {
if (arr[i] <= dep[j]) {
plat_needed++;... | int main() {
assert(func0({900, 940, 950, 1100, 1500, 1800}, {910, 1200, 1120, 1130, 1900, 2000}, 6) == 3);
assert(func0({100, 200, 300, 400}, {700, 800, 900, 1000}, 4) == 4);
assert(func0({5, 6, 7, 8}, {4, 3, 2, 1}, 4) == 1);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >, int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %edx,%r12d
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
sub $0x18,%rsp
mov 0x8(%rdi),%r15
mov (%rdi),%r14
cmp %r14,%r15
je 167c <_Z5func... | _Z5func0St6vectorIiSaIiEES1_i:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
mov ebx, edx
sub rsp, 18h
mov r15, [rdi+8]
mov rbp, [rdi]
mov [rsp+48h+var_48], rsi
cmp r15, rbp
jz loc_189C
mov r14, r15
lea r13, [rbp+4]
sub r14, rbp... | long long func0(char **a1, char **a2, int a3)
{
char *v5; // r15
char *v6; // rbp
char *v7; // r13
unsigned long long v8; // rdx
char *v9; // r14
int v10; // r9d
char *v11; // rsi
int v12; // edx
char *j; // rax
int v14; // ecx
int v15; // edx
char *v16; // rax
char *v17; // rsi
char *v18; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV EBX,EDX
SUB RSP,0x18
MOV R15,qword ptr [RDI + 0x8]
MOV RBP,qword ptr [RDI]
MOV qword ptr [RSP],RSI
CMP R15,RBP
JZ 0x0010189c
MOV R14,R15
LEA R13,[RBP + 0x4]
SUB R14,RBP
MOV RAX,R14
SAR RAX,0x2
JZ 0x00101a41
BSR RDX,RAX
MOV RSI,R15
MOV ... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,vector param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,int param_10,
int4 param_11)
{
_Iter_less_iter _Var1;
_Iter_less_iter *p_V... |
3,384 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& xs) {
return xs;
}
| int main() {
assert((func0({1, 2, 3}) == std::vector<int>{1, 2, 3}));
assert((func0({4, 8, 2, 10, 15, 18}) == std::vector<int>{4, 8, 2, 10, 15, 18}));
assert((func0({4, 5, 6}) == std::vector<int>{4, 5, 6}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %rsi,-0x10(%rbp)
mov -0x10(%rbp),%rdx
mov -0x8(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 18b0 <_ZNSt6vectorIiSaIiEEC1ERKS1_>
mov -0x8(%rbp),%rax
leaveq
retq
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2ERKS1_; std::vector<int>::vector(std::vector<int> const&)
mov rax, ... | long long func0(long long a1, long long a2)
{
std::vector<int>::vector(a1, a2);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101918
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
vector *in_RSI;
std::vector<int,std::allocator<int>>::vector((vector<int,std::allocator<int>> *)param_1,in_RSI);
return param_1;
} |
3,385 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& xs) {
return xs;
}
| int main() {
assert((func0({1, 2, 3}) == std::vector<int>{1, 2, 3}));
assert((func0({4, 8, 2, 10, 15, 18}) == std::vector<int>{4, 8, 2, 10, 15, 18}));
assert((func0({4, 5, 6}) == std::vector<int>{4, 5, 6}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %rsi,%r13
mov 0x8(%rsi),%r12
sub (%rsi),%r12
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov %r12,%rax
sar $0x2,%rax
je 1304 <_Z5func... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov r13, rsi
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_12FB
mov rax, 7FFFFFFFFFFFFFFCh
cmp ... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
unsigned long long v3; // r12
_DWORD *v4; // rbp
_DWORD *v5; // rsi
long long v6; // r12
v3 = a2[1] - *a2;
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
if ( v3 )
{
if ( v3 <= 0x7FFFFFFFFFFFFFFCLL )
{
v4 = (_DWORD *)operator new(v3);
goto LABEL_4;... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV R13,RSI
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 0x001012fb
MOV RAX,0x7ffffffffffffffc
CMP RAX,R12
JC 0x001012f6
MOV RDI,R12
CALL 0x00101130... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int4 *__src;
int4 *__dest;
long *in_RSI;
ulong uVar1;
size_t __n;
uVar1 = in_RSI[1] - *in_RSI;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
if (uVar1 != 0) {
if (... |
3,386 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& xs) {
return xs;
}
| int main() {
assert((func0({1, 2, 3}) == std::vector<int>{1, 2, 3}));
assert((func0({4, 8, 2, 10, 15, 18}) == std::vector<int>{4, 8, 2, 10, 15, 18}));
assert((func0({4, 5, 6}) == std::vector<int>{4, 5, 6}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
mov 0x8(%rsi),%rbx
sub (%rsi),%rbx
movq $0x0,(%rdi)
mov %rbx,%rax
movq $0x0,0x8(%rdi)
sar $0x2,%rax
movq $0x0,0x10(%rdi)
je 16a8 <_Z5func0RKSt6vectorIiSaIiEE+0x98>
mo... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r12
pxor xmm0, xmm0
mov r12, rsi
push rbp
push rbx
mov rbp, [rsi+8]
mov rbx, rdi
sub rbp, [rsi]
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
jz short loc_1698
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbp
jb short loc_16... | long long func0(long long a1, _QWORD *a2)
{
unsigned long long v3; // rbp
_DWORD *v4; // rcx
_DWORD *v5; // rsi
long long v6; // rax
size_t v7; // rbp
long long result; // rax
v3 = a2[1] - *a2;
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
if ( v3 )
{
if ( v3 > 0x7FFFFFFFFFFFFFFCLL )
... | func0:
ENDBR64
PUSH R12
PXOR XMM0,XMM0
MOV R12,RSI
PUSH RBP
PUSH RBX
MOV RBP,qword ptr [RSI + 0x8]
MOV RBX,RDI
SUB RBP,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
JZ 0x00101698
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBP
JC 0x001016b0
MOV RDI,RBP
CALL 0x00101130
MOV RCX,RAX
LAB_00101650:
MOV... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int4 *__src;
uint *__src_00;
int4 *__dest;
size_t __n;
vector *pvVar1;
vector *__n_00;
vector *pvVar2;
vector *extraout_RAX;
ulong uVar3;
long *in_RSI;
uVar3 = in_RSI[1] - *in_RSI;
*(int8 *)(param_1... |
3,387 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& xs) {
return xs;
}
| int main() {
assert((func0({1, 2, 3}) == std::vector<int>{1, 2, 3}));
assert((func0({4, 8, 2, 10, 15, 18}) == std::vector<int>{4, 8, 2, 10, 15, 18}));
assert((func0({4, 5, 6}) == std::vector<int>{4, 5, 6}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r12
pxor %xmm0,%xmm0
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
mov 0x8(%rsi),%rbx
sub (%rsi),%rbx
movq $0x0,0x10(%rdi)
mov %rbx,%rax
movups %xmm0,(%rdi)
sar $0x2,%rax
je 1680 <_Z5func0RKSt6vectorIiSaIiEE+0x90>
mova... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r12
pxor xmm0, xmm0
mov r12, rsi
push rbp
push rbx
mov rbp, [rsi+8]
mov rbx, rdi
sub rbp, [rsi]
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
jz short loc_1698
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbp
jb short loc_16... | long long func0(long long a1, _QWORD *a2)
{
unsigned long long v3; // rbp
_DWORD *v4; // rcx
_DWORD *v5; // rsi
long long v6; // rax
size_t v7; // rbp
long long result; // rax
v3 = a2[1] - *a2;
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
if ( v3 )
{
if ( v3 > 0x7FFFFFFFFFFFFFFCLL )
... | func0:
ENDBR64
PUSH R12
PXOR XMM0,XMM0
MOV R12,RSI
PUSH RBP
PUSH RBX
MOV RBP,qword ptr [RSI + 0x8]
MOV RBX,RDI
SUB RBP,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
JZ 0x00101698
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBP
JC 0x001016b0
MOV RDI,RBP
CALL 0x00101130
MOV RCX,RAX
LAB_00101650:
MOV... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int4 *__src;
uint *__src_00;
int4 *__dest;
size_t __n;
vector *pvVar1;
vector *__n_00;
vector *pvVar2;
vector *extraout_RAX;
ulong uVar3;
long *in_RSI;
uVar3 = in_RSI[1] - *in_RSI;
*(int8 *)(param_1... |
3,388 | func0 |
#include <cassert>
| double func0(double base1, double base2, double height) {
double area = 0.5 * (base1 + base2) * height;
return area;
}
| int main() {
assert(func0(6, 9, 4) == 30);
assert(func0(10, 20, 30) == 450);
assert(func0(15, 25, 35) == 700);
return 0;
}
| O0 | cpp | func0(double, double, double):
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd %xmm2,-0x28(%rbp)
movsd -0x18(%rbp),%xmm0
movapd %xmm0,%xmm1
addsd -0x20(%rbp),%xmm1
movsd 0xf32(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd -0x28(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%r... | _Z5func0ddd:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd [rbp+var_20], xmm1
movsd [rbp+var_28], xmm2
movsd xmm0, [rbp+var_18]
movapd xmm1, xmm0
addsd xmm1, [rbp+var_20]
movsd xmm0, cs:qword_2080
mulsd xmm0, xmm1
movsd xmm1, [rbp+var_28]
mulsd xmm0, xmm1
movsd [rbp+var_8], xm... | double func0(double a1, double a2, double a3)
{
return 0.5 * (a1 + a2) * a3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD qword ptr [RBP + -0x28],XMM2
MOVSD XMM0,qword ptr [RBP + -0x18]
MOVAPD XMM1,XMM0
ADDSD XMM1,qword ptr [RBP + -0x20]
MOVSD XMM0,qword ptr [0x00102080]
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [RBP + -0x28]
MULSD X... | /* func0(double, double, double) */
double func0(double param_1,double param_2,double param_3)
{
return DAT_00102080 * (param_1 + param_2) * param_3;
} |
3,389 | func0 |
#include <cassert>
| double func0(double base1, double base2, double height) {
double area = 0.5 * (base1 + base2) * height;
return area;
}
| int main() {
assert(func0(6, 9, 4) == 30);
assert(func0(10, 20, 30) == 450);
assert(func0(15, 25, 35) == 700);
return 0;
}
| O1 | cpp | func0(double, double, double):
endbr64
addsd %xmm1,%xmm0
mulsd 0xecf(%rip),%xmm0
mulsd %xmm2,%xmm0
retq
| _Z5func0ddd:
endbr64
addsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm2
retn | double func0(double a1, double a2, double a3)
{
return (a1 + a2) * 0.5 * a3;
} | func0:
ENDBR64
ADDSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double, double) */
double func0(double param_1,double param_2,double param_3)
{
return (param_1 + param_2) * _DAT_00102008 * param_3;
} |
3,390 | func0 |
#include <cassert>
| double func0(double base1, double base2, double height) {
double area = 0.5 * (base1 + base2) * height;
return area;
}
| int main() {
assert(func0(6, 9, 4) == 30);
assert(func0(10, 20, 30) == 450);
assert(func0(15, 25, 35) == 700);
return 0;
}
| O2 | cpp | func0(double, double, double):
endbr64
addsd %xmm1,%xmm0
mulsd 0xeb8(%rip),%xmm0
mulsd %xmm2,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0ddd:
endbr64
addsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm2
retn | double func0(double a1, double a2, double a3)
{
return (a1 + a2) * 0.5 * a3;
} | func0:
ENDBR64
ADDSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double, double) */
double func0(double param_1,double param_2,double param_3)
{
return (param_1 + param_2) * _DAT_00102008 * param_3;
} |
3,391 | func0 |
#include <cassert>
| double func0(double base1, double base2, double height) {
double area = 0.5 * (base1 + base2) * height;
return area;
}
| int main() {
assert(func0(6, 9, 4) == 30);
assert(func0(10, 20, 30) == 450);
assert(func0(15, 25, 35) == 700);
return 0;
}
| O3 | cpp | func0(double, double, double):
endbr64
addsd %xmm1,%xmm0
mulsd 0xeb8(%rip),%xmm0
mulsd %xmm2,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0ddd:
endbr64
addsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm2
retn | double func0(double a1, double a2, double a3)
{
return (a1 + a2) * 0.5 * a3;
} | func0:
ENDBR64
ADDSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double, double) */
double func0(double param_1,double param_2,double param_3)
{
return (param_1 + param_2) * _DAT_00102008 * param_3;
} |
3,392 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(int N) {
std::vector<int> SumOfPrimeDivisors(N + 1, 0);
for (int i = 2; i <= N; i++) {
if (SumOfPrimeDivisors[i] == 0) {
for (int j = i; j <= N; j += i) {
SumOfPrimeDivisors[j] += i;
}
}
}
return SumOfPrimeDivisors[N];
}
| int main() {
assert(func0(60) == 10);
assert(func0(39) == 16);
assert(func0(40) == 7);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x3d(%rbp),%rax
mov %rax,%rdi
callq 146c <_ZNSaIiEC1Ev>
movl $0x0,-0x3c(%rbp)
mov -0x44(%rbp),%eax
add $0x1,%eax
movslq %eax,%rsi
lea ... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_54], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_45]
mov [rbp+var_38], rax
nop
nop
mov [rbp+var_44], 0
mov eax, [rbp+var_54]
add eax, 1
movsxd rsi, eax
lea rcx,... | long long func0(int a1)
{
_DWORD *v1; // rax
unsigned int v2; // ebx
char v4; // [rsp+1Bh] [rbp-45h] BYREF
int v5; // [rsp+1Ch] [rbp-44h] BYREF
int i; // [rsp+20h] [rbp-40h]
int j; // [rsp+24h] [rbp-3Ch]
char *v8; // [rsp+28h] [rbp-38h]
_BYTE v9[24]; // [rsp+30h] [rbp-30h] BYREF
unsigned long long v1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RBP + -0x54],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x45]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV dword ptr [RBP + -0x44],0x0
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,0x1
MOVSXD RSI,EAX
LEA R... | /* func0(int) */
int4 func0(int param_1)
{
int4 uVar1;
int *piVar2;
int4 *puVar3;
long in_FS_OFFSET;
allocator local_4d;
int local_4c;
int local_48;
int local_44;
allocator *local_40;
vector<int,std::allocator<int>> local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
... |
3,393 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(int N) {
std::vector<int> SumOfPrimeDivisors(N + 1, 0);
for (int i = 2; i <= N; i++) {
if (SumOfPrimeDivisors[i] == 0) {
for (int j = i; j <= N; j += i) {
SumOfPrimeDivisors[j] += i;
}
}
}
return SumOfPrimeDivisors[N];
}
| int main() {
assert(func0(60) == 10);
assert(func0(39) == 16);
assert(func0(40) == 7);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
lea 0x1(%rdi),%edx
movslq %edx,%rdx
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rdx
ja 1248 <_Z5func0i+0x5f>
mov %edi,%ebx
test %rdx,%rdx
je 128c <_Z5func0i+0xa3>
lea 0x0(,%rdx,4),%rbp
mov %rbp,%rdi
callq 10e0 <_Znwm@plt>
mov %rax,%... | _Z5func0i:
endbr64
push rbp
push rbx
sub rsp, 8
lea ebp, [rdi+1]
movsxd rbp, ebp
mov rax, rbp
shr rax, 3Dh
jnz short loc_11FA
mov ebx, edi
test rbp, rbp
jz short loc_122A
shl rbp, 2
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; void *... | long long func0(int a1)
{
unsigned long long v2; // rbp
_DWORD *v3; // rax
_DWORD *v4; // rdi
_DWORD *v5; // rdx
long long v6; // rcx
long long v7; // rdx
unsigned int v8; // ebx
if ( (unsigned long long)(a1 + 1) >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()")... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
LEA EBP,[RDI + 0x1]
MOVSXD RBP,EBP
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x001011fa
MOV EBX,EDI
TEST RBP,RBP
JZ 0x0010122a
SHL RBP,0x2
MOV RDI,RBP
CALL 0x001010a0
MOV RDI,RAX
LEA RDX,[RAX + RBP*0x1]
LAB_001011dc:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001011dc
CMP EBX,... | /* func0(int) */
int4 func0(int param_1)
{
int4 uVar1;
char *pcVar2;
char *pcVar3;
ulong in_RCX;
int iVar4;
int unaff_EBX;
ulong uVar5;
ulong uVar6;
ulong in_RSI;
uVar5 = (ulong)(param_1 + 1);
if (uVar5 >> 0x3d == 0) {
if (uVar5 == 0) {
return *(int4 *)((long)param_1 * 4);
}
... |
3,394 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(int N) {
std::vector<int> SumOfPrimeDivisors(N + 1, 0);
for (int i = 2; i <= N; i++) {
if (SumOfPrimeDivisors[i] == 0) {
for (int j = i; j <= N; j += i) {
SumOfPrimeDivisors[j] += i;
}
}
}
return SumOfPrimeDivisors[N];
}
| int main() {
assert(func0(60) == 10);
assert(func0(39) == 16);
assert(func0(40) == 7);
return 0;
}
| O2 | cpp | func0(int):
endbr64
movabs $0x1fffffffffffffff,%rdx
lea 0x1(%rdi),%eax
push %r12
cltq
push %rbp
push %rbx
cmp %rdx,%rax
ja 13a0 <_Z5func0i+0xd0>
test %rax,%rax
je 1390 <_Z5func0i+0xc0>
lea 0x0(,%rax,4),%rbp
mov %edi,%ebx
mov %rbp,%rdi
callq 10e0 <_Znwm@plt>
mov %rax,%rdi
lea (%rax,... | _Z5func0i:
endbr64
push r13
push r12
lea r12d, [rdi+1]
push rbp
movsxd rax, r12d
push rbx
mov rsi, rax
sub rsp, 8
shr rsi, 3Dh
jnz loc_133C
test rax, rax
jz loc_1328
movsxd r13, edi
mov ebx, edi
shl r13, 2
lea rbp, [r13+4]
mov rdi, rbp; unsigned __int64
call ... | long long func0(int a1)
{
int v1; // r12d
long long v3; // r13
unsigned long long v4; // rbp
void *v5; // rax
_DWORD *v6; // rdi
unsigned int *v7; // r13
long long v8; // rdx
long long v9; // rax
unsigned int v10; // ebx
v1 = a1 + 1;
if ( (unsigned long long)(a1 + 1) >> 61 )
std::__throw_len... | func0:
ENDBR64
PUSH R13
PUSH R12
LEA R12D,[RDI + 0x1]
PUSH RBP
MOVSXD RAX,R12D
PUSH RBX
MOV RSI,RAX
SUB RSP,0x8
SHR RSI,0x3d
JNZ 0x0010133c
TEST RAX,RAX
JZ 0x00101328
MOVSXD R13,EDI
MOV EBX,EDI
SHL R13,0x2
LEA RBP,[R13 + 0x4]
MOV RDI,RBP
CALL 0x001010c0
MOV RDX,RBP
XOR ESI,ESI
MOV RDI,RAX
CALL 0x001010a0
MOV RDI,RAX
AD... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
ulong func0(int param_1)
{
int *piVar1;
void *pvVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
uint uVar6;
uVar6 = param_1 + 1;
if ((ulong)(long)(int)uVar6 >> 0x3d != 0) {
uVar4 = std::__throw_le... |
3,395 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(int N) {
std::vector<int> SumOfPrimeDivisors(N + 1, 0);
for (int i = 2; i <= N; i++) {
if (SumOfPrimeDivisors[i] == 0) {
for (int j = i; j <= N; j += i) {
SumOfPrimeDivisors[j] += i;
}
}
}
return SumOfPrimeDivisors[N];
}
| int main() {
assert(func0(60) == 10);
assert(func0(39) == 16);
assert(func0(40) == 7);
return 0;
}
| O3 | cpp | func0(int):
endbr64
movabs $0x1fffffffffffffff,%rdx
lea 0x1(%rdi),%eax
push %r12
cltq
push %rbp
push %rbx
cmp %rdx,%rax
ja 13a0 <_Z5func0i+0xb0>
test %rax,%rax
je 1390 <_Z5func0i+0xa0>
lea 0x0(,%rax,4),%rbp
mov %edi,%ebx
mov %rbp,%rdi
callq 1100 <_Znwm@plt>
mov %rbp,%rdx
xor %esi,%... | _Z5func0i:
endbr64
push r13
push r12
lea r12d, [rdi+1]
push rbp
movsxd rax, r12d
push rbx
mov rsi, rax
sub rsp, 8
shr rsi, 3Dh
jnz loc_132C
test rax, rax
jz loc_1318
movsxd r13, edi
mov ebx, edi
shl r13, 2
lea rbp, [r13+4]
mov rdi, rbp; unsigned __int64
call ... | long long func0(int a1)
{
int v1; // r12d
long long v3; // r13
unsigned long long v4; // rbp
void *v5; // rax
_DWORD *v6; // rdi
unsigned int *v7; // r13
long long v8; // rdx
unsigned int v9; // ebx
long long v11; // rax
v1 = a1 + 1;
if ( (unsigned long long)(a1 + 1) >> 61 )
std::__throw_len... | func0:
ENDBR64
PUSH R13
PUSH R12
LEA R12D,[RDI + 0x1]
PUSH RBP
MOVSXD RAX,R12D
PUSH RBX
MOV RSI,RAX
SUB RSP,0x8
SHR RSI,0x3d
JNZ 0x0010132c
TEST RAX,RAX
JZ 0x00101318
MOVSXD R13,EDI
MOV EBX,EDI
SHL R13,0x2
LEA RBP,[R13 + 0x4]
MOV RDI,RBP
CALL 0x001010c0
MOV RDX,RBP
XOR ESI,ESI
MOV RDI,RAX
CALL 0x001010a0
MOV RDI,RAX
AD... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
ulong func0(int param_1)
{
int *piVar1;
void *pvVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
uint uVar6;
uVar6 = param_1 + 1;
if ((ulong)(long)(int)uVar6 >> 0x3d != 0) {
uVar4 = std::__throw_le... |
3,396 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int a, int b, int c) {
if(a != 0 && b != 0 && c != 0 && (a + b + c) == 180) {
if((a + b) >= c || (b + c) >= a || (a + c) >= b) {
return true;
} else {
return false;
}
} else {
return false;
}
}
| int main() {
assert(func0(50, 60, 70) == true);
assert(func0(90, 45, 45) == true);
assert(func0(150, 30, 70) == false);
return 0;
}
| O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
cmpl $0x0,-0x4(%rbp)
je 11f5 <_Z5func0iii+0x6c>
cmpl $0x0,-0x8(%rbp)
je 11f5 <_Z5func0iii+0x6c>
cmpl $0x0,-0xc(%rbp)
je 11f5 <_Z5func0iii+0x6c>
mov -0x4(%rbp),%edx
mov ... | _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
cmp [rbp+var_4], 0
jz short loc_11B5
cmp [rbp+var_8], 0
jz short loc_11B5
cmp [rbp+var_C], 0
jz short loc_11B5
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
add ... | _BOOL8 func0(int a1, int a2, int a3)
{
if ( !a1 || !a2 || !a3 || a2 + a1 + a3 != 180 )
return 0LL;
return a3 <= a1 + a2 || a1 <= a2 + a3 || a2 <= a1 + a3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
CMP dword ptr [RBP + -0x4],0x0
JZ 0x001011b5
CMP dword ptr [RBP + -0x8],0x0
JZ 0x001011b5
CMP dword ptr [RBP + -0xc],0x0
JZ 0x001011b5
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + ... | /* func0(int, int, int) */
int8 func0(int param_1,int param_2,int param_3)
{
int8 uVar1;
if ((((param_1 == 0) || (param_2 == 0)) || (param_3 == 0)) ||
(param_3 + param_1 + param_2 != 0xb4)) {
uVar1 = 0;
}
else if (((param_2 + param_1 < param_3) && (param_3 + param_2 < param_1)) &&
(param... |
3,397 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int a, int b, int c) {
if(a != 0 && b != 0 && c != 0 && (a + b + c) == 180) {
if((a + b) >= c || (b + c) >= a || (a + c) >= b) {
return true;
} else {
return false;
}
} else {
return false;
}
}
| int main() {
assert(func0(50, 60, 70) == true);
assert(func0(90, 45, 45) == true);
assert(func0(150, 30, 70) == false);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
test %esi,%esi
setne %al
test %edx,%edx
setne %cl
and %ecx,%eax
test %edi,%edi
setne %cl
and %cl,%al
jne 1183 <_Z5func0iii+0x1a>
retq
lea (%rdi,%rsi,1),%ecx
lea (%rcx,%rdx,1),%r8d
cmp $0xb4,%r8d
jne 11a6 <_Z5func0iii+0x3d>
cmp %edx,%ecx
jge 1182 <_Z5func... | _Z5func0iii:
endbr64
test esi, esi
setnz al
test edx, edx
setnz cl
and eax, ecx
test edi, edi
setnz cl
and al, cl
jnz short loc_1143
locret_1142:
retn
loc_1143:
lea ecx, [rdi+rsi]
lea r8d, [rcx+rdx]
cmp r8d, 0B4h
jnz short loc_1166
cmp ecx, edx
jge short locret_1142
le... | bool func0(int a1, int a2, int a3)
{
bool result; // al
result = a1 != 0 && a3 != 0 && a2 != 0;
if ( result )
{
if ( a1 + a2 + a3 == 180 )
{
if ( a1 + a2 < a3 && a2 + a3 < a1 )
return a3 + a1 >= a2;
}
else
{
return 0;
}
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
SETNZ AL
TEST EDX,EDX
SETNZ CL
AND EAX,ECX
TEST EDI,EDI
SETNZ CL
AND AL,CL
JNZ 0x00101143
LAB_00101142:
RET
LAB_00101143:
LEA ECX,[RDI + RSI*0x1]
LEA R8D,[RCX + RDX*0x1]
CMP R8D,0xb4
JNZ 0x00101166
CMP ECX,EDX
JGE 0x00101142
LEA ECX,[RSI + RDX*0x1]
CMP ECX,EDI
JGE 0x00101142
ADD EDI,EDX
CMP ... | /* func0(int, int, int) */
int4 func0(int param_1,int param_2,int param_3)
{
int3 uVar1;
byte bVar2;
uint uVar3;
int8 in_RAX;
int8 in_RCX;
uVar3 = (uint)CONCAT71((int7)((ulong)in_RAX >> 8),param_2 != 0) &
(uint)CONCAT71((int7)((ulong)in_RCX >> 8),param_3 != 0);
uVar1 = (int3)(uVar3 >> 8);
... |
3,398 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int a, int b, int c) {
if(a != 0 && b != 0 && c != 0 && (a + b + c) == 180) {
if((a + b) >= c || (b + c) >= a || (a + c) >= b) {
return true;
} else {
return false;
}
} else {
return false;
}
}
| int main() {
assert(func0(50, 60, 70) == true);
assert(func0(90, 45, 45) == true);
assert(func0(150, 30, 70) == false);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
test %esi,%esi
setne %al
test %edx,%edx
setne %cl
and %ecx,%eax
test %edi,%edi
setne %cl
and %cl,%al
jne 11e0 <_Z5func0iii+0x20>
retq
nopw 0x0(%rax,%rax,1)
lea (%rdi,%rsi,1),%ecx
lea (%rcx,%rdx,1),%r8d
cmp $0xb4,%r8d
jne 1208 <_Z5func0iii+0x48>
cmp %edx,%... | _Z5func0iii:
endbr64
test esi, esi
setnz al
test edx, edx
setnz cl
and eax, ecx
test edi, edi
setnz cl
and al, cl
jnz short loc_1160
locret_1159:
retn
loc_1160:
lea ecx, [rdi+rsi]
lea r8d, [rcx+rdx]
cmp r8d, 0B4h
jnz short loc_1188
cmp ecx, edx
jge short locret_1159
le... | bool func0(int a1, int a2, int a3)
{
bool result; // al
result = a1 != 0 && a3 != 0 && a2 != 0;
if ( result )
{
if ( a1 + a2 + a3 == 180 )
{
if ( a1 + a2 < a3 && a2 + a3 < a1 )
return a3 + a1 >= a2;
}
else
{
return 0;
}
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
SETNZ AL
TEST EDX,EDX
SETNZ CL
AND EAX,ECX
TEST EDI,EDI
SETNZ CL
AND AL,CL
JNZ 0x00101160
LAB_00101159:
RET
LAB_00101160:
LEA ECX,[RDI + RSI*0x1]
LEA R8D,[RCX + RDX*0x1]
CMP R8D,0xb4
JNZ 0x00101188
CMP ECX,EDX
JGE 0x00101159
LEA ECX,[RSI + RDX*0x1]
CMP ECX,EDI
JGE 0x00101159
ADD EDI,EDX
CMP ... | /* func0(int, int, int) */
int4 func0(int param_1,int param_2,int param_3)
{
int3 uVar1;
byte bVar2;
uint uVar3;
int8 in_RAX;
int8 in_RCX;
uVar3 = (uint)CONCAT71((int7)((ulong)in_RAX >> 8),param_2 != 0) &
(uint)CONCAT71((int7)((ulong)in_RCX >> 8),param_3 != 0);
uVar1 = (int3)(uVar3 >> 8);
... |
3,399 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int a, int b, int c) {
if(a != 0 && b != 0 && c != 0 && (a + b + c) == 180) {
if((a + b) >= c || (b + c) >= a || (a + c) >= b) {
return true;
} else {
return false;
}
} else {
return false;
}
}
| int main() {
assert(func0(50, 60, 70) == true);
assert(func0(90, 45, 45) == true);
assert(func0(150, 30, 70) == false);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
test %esi,%esi
setne %al
test %edx,%edx
setne %cl
and %ecx,%eax
test %edi,%edi
setne %cl
and %cl,%al
jne 11e0 <_Z5func0iii+0x20>
retq
nopw 0x0(%rax,%rax,1)
lea (%rdi,%rsi,1),%ecx
lea (%rcx,%rdx,1),%r8d
cmp $0xb4,%r8d
jne 1208 <_Z5func0iii+0x48>
cmp %edx,%... | _Z5func0iii:
endbr64
test esi, esi
setnz al
test edx, edx
setnz cl
and eax, ecx
test edi, edi
setnz cl
and al, cl
jnz short loc_1160
locret_1159:
retn
loc_1160:
lea ecx, [rdi+rsi]
lea r8d, [rcx+rdx]
cmp r8d, 0B4h
jnz short loc_1188
cmp ecx, edx
jge short locret_1159
le... | bool func0(int a1, int a2, int a3)
{
bool result; // al
result = a1 != 0 && a3 != 0 && a2 != 0;
if ( result )
{
if ( a1 + a2 + a3 == 180 )
{
if ( a1 + a2 < a3 && a2 + a3 < a1 )
return a3 + a1 >= a2;
}
else
{
return 0;
}
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
SETNZ AL
TEST EDX,EDX
SETNZ CL
AND EAX,ECX
TEST EDI,EDI
SETNZ CL
AND AL,CL
JNZ 0x00101160
LAB_00101159:
RET
LAB_00101160:
LEA ECX,[RDI + RSI*0x1]
LEA R8D,[RCX + RDX*0x1]
CMP R8D,0xb4
JNZ 0x00101188
CMP ECX,EDX
JGE 0x00101159
LEA ECX,[RSI + RDX*0x1]
CMP ECX,EDI
JGE 0x00101159
ADD EDI,EDX
CMP ... | /* func0(int, int, int) */
int4 func0(int param_1,int param_2,int param_3)
{
int3 uVar1;
byte bVar2;
uint uVar3;
int8 in_RAX;
int8 in_RCX;
uVar3 = (uint)CONCAT71((int7)((ulong)in_RAX >> 8),param_2 != 0) &
(uint)CONCAT71((int7)((ulong)in_RCX >> 8),param_3 != 0);
uVar1 = (int3)(uVar3 >> 8);
... |
3,400 | func0 |
#include <cmath>
#include <cassert>
| double func0(int N, int Sum) {
double ans = static_cast<double>(Sum) / static_cast<double>(N);
return round(ans * 100) / 100;
}
| int main() {
assert(func0(6, 12) == 2);
assert(func0(9, 13) == 1.44);
assert(func0(1, 4) == 4);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm1
movsd 0xefd(%rip),%xmm0
mulsd %xmm1,%xmm0
callq 1060 <round@plt>
movsd 0x... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_18]
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_14]
divsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm1, [rbp+var_8]
movsd xmm0, cs:qword_2078
mulsd x... | __int128 __usercall func0@<xmm0>(int a1@<edi>, int a2@<esi>)
{
double v2; // rax
__int128 v3; // xmm1
v2 = round((double)a2 / (double)a1 * 100.0);
v3 = *(unsigned long long *)&v2;
*(double *)&v3 = v2 / 100.0;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x18]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x14]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM1,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ... | /* func0(int, int) */
double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = round(((double)param_2 / (double)param_1) * DAT_00102078);
return dVar1 / DAT_00102078;
} |
3,401 | func0 |
#include <cmath>
#include <cassert>
| double func0(int N, int Sum) {
double ans = static_cast<double>(Sum) / static_cast<double>(N);
return round(ans * 100) / 100;
}
| int main() {
assert(func0(6, 12) == 2);
assert(func0(9, 13) == 1.44);
assert(func0(1, 4) == 4);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
sub $0x8,%rsp
pxor %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
mulsd 0xe9b(%rip),%xmm0
callq 1050 <round@plt>
divsd 0xe8e(%rip),%xmm0
add $0x8,%rsp
retq
| _Z5func0ii:
endbr64
sub rsp, 8
pxor xmm0, xmm0
cvtsi2sd xmm0, esi
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
mulsd xmm0, cs:qword_2008; x
call _round
divsd xmm0, cs:qword_2008
add rsp, 8
retn | double func0(int a1, int a2)
{
return round((double)a2 / (double)a1 * 100.0) / 100.0;
} | func0:
ENDBR64
SUB RSP,0x8
PXOR XMM0,XMM0
CVTSI2SD XMM0,ESI
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
CALL 0x00101050
DIVSD XMM0,qword ptr [0x00102008]
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int) */
double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = round(((double)param_2 / (double)param_1) * _DAT_00102008);
return dVar1 / _DAT_00102008;
} |
3,402 | func0 |
#include <cmath>
#include <cassert>
| double func0(int N, int Sum) {
double ans = static_cast<double>(Sum) / static_cast<double>(N);
return round(ans * 100) / 100;
}
| int main() {
assert(func0(6, 12) == 2);
assert(func0(9, 13) == 1.44);
assert(func0(1, 4) == 4);
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
sub $0x8,%rsp
cvtsi2sd %esi,%xmm0
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
mulsd 0xe84(%rip),%xmm0
callq 1050 <round@plt>
divsd 0xe77(%rip),%xmm0
add $0x8,%rsp
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
pxor xmm0, xmm0
pxor xmm1, xmm1
sub rsp, 8
cvtsi2sd xmm0, esi
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
mulsd xmm0, cs:qword_2008; x
call _round
divsd xmm0, cs:qword_2008
add rsp, 8
retn | double func0(int a1, int a2)
{
return round((double)a2 / (double)a1 * 100.0) / 100.0;
} | func0:
ENDBR64
PXOR XMM0,XMM0
PXOR XMM1,XMM1
SUB RSP,0x8
CVTSI2SD XMM0,ESI
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
CALL 0x00101050
DIVSD XMM0,qword ptr [0x00102008]
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int) */
double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = round(((double)param_2 / (double)param_1) * _DAT_00102008);
return dVar1 / _DAT_00102008;
} |
3,403 | func0 |
#include <cmath>
#include <cassert>
| double func0(int N, int Sum) {
double ans = static_cast<double>(Sum) / static_cast<double>(N);
return round(ans * 100) / 100;
}
| int main() {
assert(func0(6, 12) == 2);
assert(func0(9, 13) == 1.44);
assert(func0(1, 4) == 4);
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
sub $0x8,%rsp
cvtsi2sd %esi,%xmm0
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
mulsd 0xe84(%rip),%xmm0
callq 1050 <round@plt>
divsd 0xe77(%rip),%xmm0
add $0x8,%rsp
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
pxor xmm0, xmm0
pxor xmm1, xmm1
sub rsp, 8
cvtsi2sd xmm0, esi
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
mulsd xmm0, cs:qword_2008; x
call _round
divsd xmm0, cs:qword_2008
add rsp, 8
retn | double func0(int a1, int a2)
{
return round((double)a2 / (double)a1 * 100.0) / 100.0;
} | func0:
ENDBR64
PXOR XMM0,XMM0
PXOR XMM1,XMM1
SUB RSP,0x8
CVTSI2SD XMM0,ESI
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
CALL 0x00101050
DIVSD XMM0,qword ptr [0x00102008]
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int) */
double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = round(((double)param_2 / (double)param_1) * _DAT_00102008);
return dVar1 / _DAT_00102008;
} |
3,404 | func0 | #include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> num_list) {
for (auto it = num_list.begin(); it != num_list.end(); ) {
if (*it < 0) {
it = num_list.erase(it);
} else {
++it;
}
}
return num_list;
}
| int main() {
assert((func0({1,-2,3,-4}) == std::vector<int>{1,3}));
assert((func0({1,2,3,-4}) == std::vector<int>{1,2,3}));
assert((func0({4,5,-6,7,-8}) == std::vector<int>{4,5,7}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 1994 <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x18(%rbp)
m... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+v... | long long func0(long long a1, long long a2)
{
long long v3; // [rsp+18h] [rbp-18h] BYREF
_QWORD v4[2]; // [rsp+20h] [rbp-10h] BYREF
v4[1] = __readfsqword(0x28u);
v3 = std::vector<int>::begin(a2);
while ( 1 )
{
v4[0] = std::vector<int>::end(a2);
if ( !(unsigned __int8)__gnu_cxx::operator!=<int *,st... | 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 FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x00101a04
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001012eb
LAB_0010129e:
LEA RAX,[RBP + ... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
bool bVar1;
int *piVar2;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
long in_FS_OFFSET;
int8 local_20;
int8 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFF... |
3,405 | func0 | #include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> num_list) {
for (auto it = num_list.begin(); it != num_list.end(); ) {
if (*it < 0) {
it = num_list.erase(it);
} else {
++it;
}
}
return num_list;
}
| int main() {
assert((func0({1,-2,3,-4}) == std::vector<int>{1,3}));
assert((func0({1,2,3,-4}) == std::vector<int>{1,2,3}));
assert((func0({4,5,-6,7,-8}) == std::vector<int>{4,5,7}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %rsi,%rbp
mov (%rsi),%rbx
mov 0x8(%rsi),%rdx
cmp %rdx,%rbx
jne 12a9 <_Z5func0St6vectorIiSaIiEE+0x60>
mov %rdx,%rbx
mov 0x0(%rbp),%rax
mov %rax,(%r12)
mov %rbx,0x8(%r12)
mov 0x10(... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r12
push rbp
push rbx
mov r12, rdi
mov rbp, rsi
mov rbx, [rsi]
mov rdx, [rsi+8]
cmp rbx, rdx
jnz short loc_12C4
mov rbx, rdx
loc_1266:
mov rax, [rbp+0]
mov [r12], rax
mov [r12+8], rbx
mov rax, [rbp+10h]
mov [r12+10h], rax
m... | _QWORD * func0(_QWORD *a1, long long a2)
{
int *v3; // rbx
int *v4; // rdx
_BYTE *v6; // rsi
signed long long v7; // rdx
v3 = *(int **)a2;
v4 = *(int **)(a2 + 8);
if ( *(int **)a2 == v4 )
{
v3 = *(int **)(a2 + 8);
}
else
{
do
{
if ( *v3 < 0 )
{
v6 = v3 + 1;
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV RBP,RSI
MOV RBX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
CMP RBX,RDX
JNZ 0x001012c4
MOV RBX,RDX
LAB_00101266:
MOV RAX,qword ptr [RBP]
MOV qword ptr [R12],RAX
MOV qword ptr [R12 + 0x8],RBX
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [R12 + 0x10],RAX
MOV qwo... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1)
{
size_t __n;
int *piVar1;
int *piVar2;
int *__dest;
int8 *in_RSI;
int4 in_register_0000003c;
int8 *puVar3;
puVar3 = (int8 *)CONCAT44(in_register_0000003c,param_1);
__dest = (int *)*in_RSI;
piVar1 = (int *)in_RSI[1... |
3,406 | func0 | #include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> num_list) {
for (auto it = num_list.begin(); it != num_list.end(); ) {
if (*it < 0) {
it = num_list.erase(it);
} else {
++it;
}
}
return num_list;
}
| int main() {
assert((func0({1,-2,3,-4}) == std::vector<int>{1,3}));
assert((func0({1,2,3,-4}) == std::vector<int>{1,2,3}));
assert((func0({4,5,-6,7,-8}) == std::vector<int>{4,5,7}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
mov %rdi,%r12
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
mov 0x8(%rsi),%rdx
mov (%rsi),%rcx
mov %rdx,%rax
cmp %rdx,%rcx
jne 15c4 <_Z5func0St6vectorIiSaIiEE+0x34>
jmp 15f5 <_Z5func0St6vectorIiSaIiEE+0x65>
nopw 0x0(%rax,%rax,1)
m... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
movdqu xmm0, xmmword ptr [rsi]
movhlps xmm1, xmm0
movq rcx, xmm0
movq rdx, xmm1
cmp rcx, rdx
jnz short loc_15BC
jmp short loc_15FD
loc_15B0:
mov rdx, [rbx+8]
mov rcx, rsi
cmp rdx, r... | __m128 * func0(__m128 *a1, const __m128i *a2, double a3, __m128 a4)
{
__m128 v5; // xmm0
int *v6; // rcx
long long v7; // rdx
const void *v8; // rsi
signed long long v9; // rdx
long long v10; // rax
__m128 *result; // rax
v5 = (__m128)_mm_loadu_si128(a2);
v6 = (int *)v5.m128_u64[0];
v7 = _mm_movehl... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
MOVDQU XMM0,xmmword ptr [RSI]
MOVHLPS XMM1,XMM0
MOVQ RCX,XMM0
MOVQ RDX,XMM1
CMP RCX,RDX
JNZ 0x001015bc
JMP 0x001015fd
LAB_001015b0:
MOV RDX,qword ptr [RBX + 0x8]
MOV RCX,RSI
CMP RDX,RCX
JZ 0x001015f0
LAB_001015bc:
MOV EAX,dword ptr [RCX]
LEA RSI,[RCX ... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(int8 *param_1,int (*param_2) [16])
{
int *__src;
int8 uVar1;
int *__dest;
int *piVar2;
size_t __n;
__dest = *(int **)*param_2;
piVar2 = *(int **)(*param_2 + 8);
if (__dest != piVar2) {
do {
while (__src = __dest + 1, -1 < *_... |
3,407 | func0 | #include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> num_list) {
for (auto it = num_list.begin(); it != num_list.end(); ) {
if (*it < 0) {
it = num_list.erase(it);
} else {
++it;
}
}
return num_list;
}
| int main() {
assert((func0({1,-2,3,-4}) == std::vector<int>{1,3}));
assert((func0({1,2,3,-4}) == std::vector<int>{1,2,3}));
assert((func0({4,5,-6,7,-8}) == std::vector<int>{4,5,7}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
mov %rdi,%r12
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
mov 0x8(%rsi),%rdx
mov (%rsi),%rcx
movq %rdx,%xmm0
cmp %rdx,%rcx
jne 1580 <_Z5func0St6vectorIiSaIiEE+0x30>
jmp 15b2 <_Z5func0St6vectorIiSaIiEE+0x62>
nopl 0x0(%rax)
mov ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
movdqu xmm0, xmmword ptr [rsi]
movhlps xmm1, xmm0
movq rcx, xmm0
movq rax, xmm1
cmp rax, rcx
jnz short loc_15B8
jmp short loc_15FC
loc_15B0:
mov rcx, rsi
cmp rcx, rax
jz short loc_... | __m128 * func0(__m128 *a1, const __m128i *a2, double a3, __m128 a4)
{
__m128 v5; // xmm0
int *v6; // rcx
unsigned long long v7; // rax
const void *v8; // rsi
long long v9; // rax
__m128 *result; // rax
v5 = (__m128)_mm_loadu_si128(a2);
v6 = (int *)v5.m128_u64[0];
v7 = _mm_movehl_ps(a4, v5).m128_u64[0... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
MOVDQU XMM0,xmmword ptr [RSI]
MOVHLPS XMM1,XMM0
MOVQ RCX,XMM0
MOVQ RAX,XMM1
CMP RAX,RCX
JNZ 0x001015b8
JMP 0x001015fc
LAB_001015b0:
MOV RCX,RSI
CMP RCX,RAX
JZ 0x001015ef
LAB_001015b8:
MOV EDX,dword ptr [RCX]
LEA RSI,[RCX + 0x4]
TEST EDX,EDX
JNS 0x0010... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(int8 *param_1,int (*param_2) [16])
{
int8 uVar1;
int *__dest;
int *piVar2;
int *__src;
size_t __n;
__dest = *(int **)*param_2;
piVar2 = *(int **)(*param_2 + 8);
if (piVar2 != __dest) {
do {
while (__src = __dest + 1, -1 < *_... |
3,408 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| int func0(int n) {
int res = 1;
while (n % 2 == 0) {
n = n / 2;
}
for (int i = 3; i <= int(sqrt(n) + 1); i += 2) {
int count = 0;
int curr_sum = 1;
int curr_term = 1;
while (n % i == 0) {
count++;
n = n / i;
curr_ter... | int main() {
assert(func0(30) == 24);
assert(func0(18) == 13);
assert(func0(2) == 1);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x24(%rbp)
movl $0x1,-0x14(%rbp)
mov -0x24(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 11da <_Z5func0i+0x31>
mov -0x24(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x24(%rbp)
jmp ... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_14], 1
jmp short loc_1190
loc_1181:
mov eax, [rbp+var_24]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_24], eax
loc_1190:
mov eax, [rbp+var_24]
and eax, 1
tes... | long long func0(int a1)
{
unsigned int v3; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int v5; // [rsp+24h] [rbp-Ch]
int v6; // [rsp+28h] [rbp-8h]
int v7; // [rsp+2Ch] [rbp-4h]
v3 = 1;
while ( (a1 & 1) == 0 )
a1 /= 2;
for ( i = 3; i <= (int)(sqrt((double)a1) + 1.0); i += 2 )
{
v5 = ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x14],0x1
JMP 0x00101190
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
LAB_00101190:
MOV EAX,dword ptr [RBP + -0x24]
AND EAX,0x1
TEST EA... | /* func0(int) */
int func0(int param_1)
{
double dVar1;
int4 local_2c;
int4 local_1c;
int4 local_18;
int4 local_10;
int4 local_c;
local_1c = 1;
for (local_2c = param_1; (local_2c & 1) == 0; local_2c = (int)local_2c / 2) {
}
local_18 = 3;
while( true ) {
dVar1 = sqrt((double)(int)local_2c)... |
3,409 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| int func0(int n) {
int res = 1;
while (n % 2 == 0) {
n = n / 2;
}
for (int i = 3; i <= int(sqrt(n) + 1); i += 2) {
int count = 0;
int curr_sum = 1;
int curr_term = 1;
while (n % i == 0) {
count++;
n = n / i;
curr_ter... | int main() {
assert(func0(30) == 24);
assert(func0(18) == 13);
assert(func0(2) == 1);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %edi,%ebx
test $0x1,%dil
jne 11ce <_Z5func0i+0x25>
mov %ebx,%edi
shr $0x1f,%edi
add %ebx,%edi
sar %edi
mov %edi,%ebx
test $0x1,%dil
je 11bd <_Z5func0i+0x14>
mov $0x3,%ebp
mov $0x1,%r12d
jmp 11ee <_Z5func0... | _Z5func0i:
endbr64
push r12
push rbp
push rbx
mov ebx, edi
test dil, 1
jnz short loc_1188
loc_1179:
mov eax, ebx
shr eax, 1Fh
add eax, ebx
sar eax, 1
mov ebx, eax
test al, 1
jz short loc_1179
loc_1188:
mov ebp, 3
mov r12d, 1
jmp short loc_11AF
loc_1195:
mov ... | long long func0(int a1)
{
int i; // ebx
int v2; // ebp
unsigned int v3; // r12d
int v4; // ecx
int j; // esi
double v6; // xmm0_8
double v7; // xmm0_8
for ( i = a1; (i & 1) == 0; i /= 2 )
;
v2 = 3;
v3 = 1;
while ( 1 )
{
v6 = (double)i;
v7 = (double)i < 0.0 ? sqrt(v6) : sqrt(v6);
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
TEST DIL,0x1
JNZ 0x00101188
LAB_00101179:
MOV EAX,EBX
SHR EAX,0x1f
ADD EAX,EBX
SAR EAX,0x1
MOV EBX,EAX
TEST AL,0x1
JZ 0x00101179
LAB_00101188:
MOV EBP,0x3
MOV R12D,0x1
JMP 0x001011af
LAB_00101195:
MOV EAX,EBX
CDQ
IDIV EBP
MOV EBX,EAX
IMUL ECX,EBP
ADD ESI,ECX
CDQ
IDI... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
long lVar1;
uint uVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
double dVar8;
uVar2 = param_1 & 1;
while (uVar2 == 0) {
param_1 = param_1 / 2;
uV... |
3,410 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| int func0(int n) {
int res = 1;
while (n % 2 == 0) {
n = n / 2;
}
for (int i = 3; i <= int(sqrt(n) + 1); i += 2) {
int count = 0;
int curr_sum = 1;
int curr_term = 1;
while (n % i == 0) {
count++;
n = n / i;
curr_ter... | int main() {
assert(func0(30) == 24);
assert(func0(18) == 13);
assert(func0(2) == 1);
return 0;
}
| O2 | cpp | func0(int):
endbr64
push %r12
push %rbx
sub $0x28,%rsp
test $0x1,%dil
jne 12b7 <_Z5func0i+0x27>
nopl 0x0(%rax)
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
mov %eax,%edi
sar %edi
test $0x2,%al
je 12a8 <_Z5func0i+0x18>
pxor %xmm2,%xmm2
mov $0x3,%ebx
mov $0x1,%r12d
movsd 0xdba(%r... | _Z5func0i:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
test dil, 1
jnz short loc_1237
nop word ptr [rax+rax+00h]
loc_1228:
mov eax, edi
shr eax, 1Fh
add eax, edi
mov edi, eax
sar edi, 1
test al, 2
jz short loc_1228
loc_1237:
pxor xmm1, xmm1
mov ebp, 3
mov ... | long long func0(int a1)
{
unsigned int v1; // eax
int v2; // ebp
unsigned int v3; // r12d
double v4; // xmm1_8
double v5; // xmm0_8
int v6; // ecx
int v7; // esi
int v8; // edx
if ( (a1 & 1) == 0 )
{
do
{
v1 = a1 + ((unsigned int)a1 >> 31);
a1 /= 2;
}
while ( (v1 & 2) =... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
TEST DIL,0x1
JNZ 0x00101237
NOP word ptr [RAX + RAX*0x1]
LAB_00101228:
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
MOV EDI,EAX
SAR EDI,0x1
TEST AL,0x2
JZ 0x00101228
LAB_00101237:
PXOR XMM1,XMM1
MOV EBP,0x3
MOV R12D,0x1
MOVSD XMM3,qword ptr [0x00102060]
CVTSI2SD XMM1,EDI
P... | /* func0(int) */
int func0(int param_1)
{
long lVar1;
uint uVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
double dVar7;
double __x;
double dVar8;
for (uVar2 = param_1 & 1; uVar2 == 0; uVar2 = uVar2 & 2) {
uVar2 = param_1 - (param_1 >> 0x1f);
param_1 = param_1 / 2;
}
iVar4 = 3;
... |
3,411 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| int func0(int n) {
int res = 1;
while (n % 2 == 0) {
n = n / 2;
}
for (int i = 3; i <= int(sqrt(n) + 1); i += 2) {
int count = 0;
int curr_sum = 1;
int curr_term = 1;
while (n % i == 0) {
count++;
n = n / i;
curr_ter... | int main() {
assert(func0(30) == 24);
assert(func0(18) == 13);
assert(func0(2) == 1);
return 0;
}
| O3 | cpp | func0(int):
endbr64
push %r12
push %rbx
sub $0x28,%rsp
test $0x1,%dil
jne 12b7 <_Z5func0i+0x27>
nopl 0x0(%rax)
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
mov %eax,%edi
sar %edi
test $0x2,%al
je 12a8 <_Z5func0i+0x18>
pxor %xmm2,%xmm2
mov $0x3,%ebx
mov $0x1,%r12d
movsd 0xdba(%r... | _Z5func0i:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
test dil, 1
jnz short loc_1237
nop word ptr [rax+rax+00h]
loc_1228:
mov eax, edi
shr eax, 1Fh
add eax, edi
mov edi, eax
sar edi, 1
test al, 2
jz short loc_1228
loc_1237:
pxor xmm1, xmm1
mov ebp, 3
mov ... | long long func0(int a1)
{
unsigned int v1; // eax
int v2; // ebp
unsigned int v3; // r12d
double v4; // xmm1_8
double v5; // xmm0_8
int v6; // ecx
int v7; // esi
int v8; // edx
if ( (a1 & 1) == 0 )
{
do
{
v1 = a1 + ((unsigned int)a1 >> 31);
a1 /= 2;
}
while ( (v1 & 2) =... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
TEST DIL,0x1
JNZ 0x00101237
NOP word ptr [RAX + RAX*0x1]
LAB_00101228:
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
MOV EDI,EAX
SAR EDI,0x1
TEST AL,0x2
JZ 0x00101228
LAB_00101237:
PXOR XMM1,XMM1
MOV EBP,0x3
MOV R12D,0x1
MOVSD XMM3,qword ptr [0x00102068]
CVTSI2SD XMM1,EDI
P... | /* func0(int) */
int func0(int param_1)
{
long lVar1;
uint uVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
double dVar7;
double __x;
double dVar8;
for (uVar2 = param_1 & 1; uVar2 == 0; uVar2 = uVar2 & 2) {
uVar2 = param_1 - (param_1 >> 0x1f);
param_1 = param_1 / 2;
}
iVar4 = 3;
... |
3,412 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(std::vector<int> rawheap) {
std::make_heap(rawheap.begin(), rawheap.end(), std::greater<int>());
return rawheap;
}
| int main() {
assert(func0({25, 44, 68, 21, 39, 23, 89}) == std::vector<int>({21, 25, 23, 44, 39, 68, 89}));
assert(func0({25, 35, 22, 85, 14, 65, 75, 25, 58}) == std::vector<int>({14, 25, 22, 25, 35, 65, 75, 85, 58}));
assert(func0({4, 5, 6, 2}) == std::vector<int>({2, 4, 6, 5}));
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1a68 <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1a1c <_ZNSt... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+var_20]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [rbp+var_20]
mov rdi, rax
call ... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
v2 = std::vector<int>::end(a2);
v3 = std::vector<int>::begin(a2);
std::make_heap<__gnu_cxx::__normal_iterator<int *,std::vector<int>>,std::greater<int>>(v3, v2);
std::vector<int>::vector(a1, a2);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101aa8
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101a5c
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00101b0a
MOV RDX,qword ptr [RBP + -... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int8 uVar1;
int8 uVar2;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
uVar1 = std::vector<int,std::allocator<int>>::end(in_RSI);
uVar2 = std::vector<int,std::allocator<int... |
3,413 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(std::vector<int> rawheap) {
std::make_heap(rawheap.begin(), rawheap.end(), std::greater<int>());
return rawheap;
}
| int main() {
assert(func0({25, 44, 68, 21, 39, 23, 89}) == std::vector<int>({21, 25, 23, 44, 39, 68, 89}));
assert(func0({25, 35, 22, 85, 14, 65, 75, 25, 58}) == std::vector<int>({14, 25, 22, 25, 35, 65, 75, 85, 58}));
assert(func0({4, 5, 6, 2}) == std::vector<int>({2, 4, 6, 5}));
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %rsi,%rbx
mov (%rsi),%r13
mov 0x8(%rsi),%rbp
sub %r13,%rbp
cmp $0x4,%rbp
jle 1281 <_Z5func0St6vectorIiSaIiEE+0x58>
sar $0x2,%rbp
mov %rbp,%r14
lea -0x2(%rbp)... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov r12, rsi
mov rbp, [rsi]
mov r13, [rsi+8]
sub r13, rbp
cmp r13, 4
jle short loc_127D
sar r13, 2
lea rax, [r13-2]
mov rbx, rax
shr rbx, 3Fh
add rbx, rax
sar r... | long long * func0(long long *a1, long long *a2)
{
long long v2; // rbp
long long v3; // r13
long long v4; // r13
long long i; // rbx
v2 = *a2;
v3 = a2[1] - *a2;
if ( v3 > 4 )
{
v4 = v3 >> 2;
for ( i = (v4 - 2) / 2; ; --i )
{
std::__adjust_heap<__gnu_cxx::__normal_iterator<int *,std::v... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV R12,RSI
MOV RBP,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
SUB R13,RBP
CMP R13,0x4
JLE 0x0010127d
SAR R13,0x2
LEA RAX,[R13 + -0x2]
MOV RBX,RAX
SHR RBX,0x3f
ADD RBX,RAX
SAR RBX,0x1
JMP 0x00101266
LAB_00101262:
SUB RBX,0x1
LAB_00101266:
MOV EC... | /* func0(std::vector<int, std::allocator<int> >) */
long * func0(vector param_1)
{
long lVar1;
long lVar2;
long *in_RSI;
int4 in_register_0000003c;
long *plVar3;
_Iter_comp_iter in_R8D;
long lVar4;
plVar3 = (long *)CONCAT44(in_register_0000003c,param_1);
lVar1 = *in_RSI;
if (4 < in_RSI[1] - lVa... |
3,414 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(std::vector<int> rawheap) {
std::make_heap(rawheap.begin(), rawheap.end(), std::greater<int>());
return rawheap;
}
| int main() {
assert(func0({25, 44, 68, 21, 39, 23, 89}) == std::vector<int>({21, 25, 23, 44, 39, 68, 89}));
assert(func0({25, 35, 22, 85, 14, 65, 75, 25, 58}) == std::vector<int>({14, 25, 22, 25, 35, 65, 75, 85, 58}));
assert(func0({4, 5, 6, 2}) == std::vector<int>({2, 4, 6, 5}));
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
mov 0x8(%rsi),%rcx
mov %rsi,%rbx
mov (%rsi),%r12
mov %rcx,%rdx
sub %r12,%rdx
cmp $0x4,%rdx
jle 1672 <_Z5func0St6vectorIiSaIiEE+0x62>
sar $0x2,%rdx
lea -0x2(%rdx)... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 28h
movdqu xmm0, xmmword ptr [rsi]
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
lea rdx, [rsp+38h+var_21]
movhlps xmm1, xmm0
movq rdi, xmm0
movaps [rsp+38h+var_38], xmm0
movq rsi, ... | __m128i * func0(__m128i *a1, const __m128i *a2, double a3, __m128 a4)
{
__m128 v4; // xmm0
long long v5; // rax
__m128i v6; // xmm0
__m128i v8; // [rsp+0h] [rbp-38h] BYREF
char v9; // [rsp+17h] [rbp-21h] BYREF
unsigned long long v10; // [rsp+18h] [rbp-20h]
v4 = (__m128)_mm_loadu_si128(a2);
v10 = __read... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x28
MOVDQU XMM0,xmmword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RDX,[RSP + 0x17]
MOVHLPS XMM1,XMM0
MOVQ RDI,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVQ RSI,XMM1
CALL 0x00101740
MOV RAX,qword ptr [RBX + 0x10]
MOVDQ... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(int8 *param_1,int (*param_2) [16])
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
long in_FS_OFFSET;
_Iter_comp_iter local_21;
long local_20;
uVar2 = *(int8 *)*param_2;
uVar3 = *(int8 *)(*param_2 + 8);
local_20 = *(long *)(in_FS_OFFSET + 0x2... |
3,415 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(std::vector<int> rawheap) {
std::make_heap(rawheap.begin(), rawheap.end(), std::greater<int>());
return rawheap;
}
| int main() {
assert(func0({25, 44, 68, 21, 39, 23, 89}) == std::vector<int>({21, 25, 23, 44, 39, 68, 89}));
assert(func0({25, 35, 22, 85, 14, 65, 75, 25, 58}) == std::vector<int>({14, 25, 22, 25, 35, 65, 75, 85, 58}));
assert(func0({4, 5, 6, 2}) == std::vector<int>({2, 4, 6, 5}));
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
mov 0x8(%rsi),%rcx
mov %rsi,%rbx
mov (%rsi),%rbp
mov %rcx,%rdx
sub %rbp,%rdx
cmp $0x4,%rdx
jle 15e3 <_Z5func0St6vectorIiSaIiEE+0x63>
sar $0x2,%rdx
lea -0x2(%rdx)... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 28h
movdqu xmm0, xmmword ptr [rsi]
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
lea rdx, [rsp+38h+var_21]
movhlps xmm1, xmm0
movq rdi, xmm0
movaps [rsp+38h+var_38], xmm0
movq rsi, ... | __m128i * func0(__m128i *a1, const __m128i *a2, double a3, __m128 a4)
{
__m128 v4; // xmm0
long long v5; // rax
__m128i v6; // xmm0
__m128i v8; // [rsp+0h] [rbp-38h] BYREF
char v9; // [rsp+17h] [rbp-21h] BYREF
unsigned long long v10; // [rsp+18h] [rbp-20h]
v4 = (__m128)_mm_loadu_si128(a2);
v10 = __read... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x28
MOVDQU XMM0,xmmword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RDX,[RSP + 0x17]
MOVHLPS XMM1,XMM0
MOVQ RDI,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVQ RSI,XMM1
CALL 0x00101820
MOV RAX,qword ptr [RBX + 0x10]
MOVDQ... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(int8 *param_1,int (*param_2) [16])
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
long in_FS_OFFSET;
_Iter_comp_iter local_21;
long local_20;
uVar2 = *(int8 *)*param_2;
uVar3 = *(int8 *)(*param_2 + 8);
local_20 = *(long *)(in_FS_OFFSET + 0x2... |
3,416 | func0 |
#include <assert.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity += 1;
}
if (parity % 2 == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(11) == false);
assert(func0(18) == true);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
cmpl $0x0,-0x14(%rbp)
je 1170 <_Z5func0i+0x27>
mov -0x14(%rbp),%eax
sub $0x1,%eax
and %eax,-0x14(%rbp)
addl $0x1,-0x4(%rbp)
jmp 115b <_Z5func0i+0x12>
mov -0x4(%rbp),%eax
and $0x1,%eax
test %eax,%e... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
jmp short loc_116A
loc_115D:
mov eax, [rbp+var_14]
sub eax, 1
and [rbp+var_14], eax
add [rbp+var_4], 1
loc_116A:
cmp [rbp+var_14], 0
jnz short loc_115D
mov eax, [rbp+var_4]
and eax, 1
tes... | _BOOL8 func0(int a1)
{
char v3; // [rsp+10h] [rbp-4h]
v3 = 0;
while ( a1 )
{
a1 &= a1 - 1;
++v3;
}
return (v3 & 1) == 0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010116a
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
AND dword ptr [RBP + -0x14],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_0010116a:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x0010115d
MOV EAX,dword ptr [RBP +... | /* func0(int) */
bool func0(int param_1)
{
bool bVar1;
uint local_1c;
bVar1 = false;
for (local_1c = param_1; local_1c != 0; local_1c = local_1c & local_1c - 1) {
bVar1 = (bool)(bVar1 ^ 1);
}
return !bVar1;
} |
3,417 | func0 |
#include <assert.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity += 1;
}
if (parity % 2 == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(11) == false);
assert(func0(18) == true);
return 0;
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
je 1167 <_Z5func0i+0x1e>
mov $0x0,%eax
lea -0x1(%rdi),%edx
add $0x1,%eax
and %edx,%edi
jne 1156 <_Z5func0i+0xd>
xor $0x1,%eax
and $0x1,%eax
retq
mov %edi,%eax
jmp 1160 <_Z5func0i+0x17>
| _Z5func0i:
endbr64
test edi, edi
jz short loc_1166
mov eax, 0
loc_1156:
lea edx, [rdi-1]
add eax, 1
and edi, edx
jnz short loc_1156
loc_1160:
not eax
and eax, 1
retn
loc_1166:
mov eax, edi
jmp short loc_1160 | _BOOL8 func0(int a1)
{
char v1; // al
if ( a1 )
{
v1 = 0;
do
{
++v1;
a1 &= a1 - 1;
}
while ( a1 );
}
else
{
v1 = 0;
}
return (v1 & 1) == 0;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101166
MOV EAX,0x0
LAB_00101156:
LEA EDX,[RDI + -0x1]
ADD EAX,0x1
AND EDI,EDX
JNZ 0x00101156
LAB_00101160:
NOT EAX
AND EAX,0x1
RET
LAB_00101166:
MOV EAX,EDI
JMP 0x00101160 | /* func0(int) */
uint func0(int param_1)
{
uint uVar1;
if (param_1 == 0) {
uVar1 = 0;
}
else {
uVar1 = 0;
do {
uVar1 = uVar1 + 1;
param_1 = param_1 & param_1 - 1U;
} while (param_1 != 0);
}
return ~uVar1 & 1;
} |
3,418 | func0 |
#include <assert.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity += 1;
}
if (parity % 2 == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(11) == false);
assert(func0(18) == true);
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
je 1160 <_Z5func0i+0x20>
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea -0x1(%rdi),%edx
add $0x1,%eax
and %edx,%edi
jne 1150 <_Z5func0i+0x10>
not %eax
and $0x1,%eax
retq
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
test edi, edi
jz short loc_1160
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1150:
lea edx, [rdi-1]
add eax, 1
and edi, edx
jnz short loc_1150
not eax
and eax, 1
retn
loc_1160:
mov eax, 1
retn | _BOOL8 func0(int a1)
{
char v1; // al
if ( !a1 )
return 1LL;
v1 = 0;
do
{
++v1;
a1 &= a1 - 1;
}
while ( a1 );
return (v1 & 1) == 0;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101160
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
LEA EDX,[RDI + -0x1]
ADD EAX,0x1
AND EDI,EDX
JNZ 0x00101150
NOT EAX
AND EAX,0x1
RET
LAB_00101160:
MOV EAX,0x1
RET | /* func0(int) */
uint func0(int param_1)
{
uint uVar1;
if (param_1 != 0) {
uVar1 = 0;
do {
uVar1 = uVar1 + 1;
param_1 = param_1 & param_1 - 1U;
} while (param_1 != 0);
return ~uVar1 & 1;
}
return 1;
} |
3,419 | func0 |
#include <assert.h>
| bool func0(int x) {
int parity = 0;
while (x != 0) {
x = x & (x - 1);
parity += 1;
}
if (parity % 2 == 0) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(10) == true);
assert(func0(11) == false);
assert(func0(18) == true);
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
je 1160 <_Z5func0i+0x20>
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
lea -0x1(%rdi),%edx
add $0x1,%eax
and %edx,%edi
jne 1150 <_Z5func0i+0x10>
not %eax
and $0x1,%eax
retq
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
test edi, edi
jz short loc_1160
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1150:
lea edx, [rdi-1]
add eax, 1
and edi, edx
jnz short loc_1150
not eax
and eax, 1
retn
loc_1160:
mov eax, 1
retn | _BOOL8 func0(int a1)
{
char v1; // al
if ( !a1 )
return 1LL;
v1 = 0;
do
{
++v1;
a1 &= a1 - 1;
}
while ( a1 );
return (v1 & 1) == 0;
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101160
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101150:
LEA EDX,[RDI + -0x1]
ADD EAX,0x1
AND EDI,EDX
JNZ 0x00101150
NOT EAX
AND EAX,0x1
RET
LAB_00101160:
MOV EAX,0x1
RET | /* func0(int) */
uint func0(int param_1)
{
uint uVar1;
if (param_1 != 0) {
uVar1 = 0;
do {
uVar1 = uVar1 + 1;
param_1 = param_1 & param_1 - 1U;
} while (param_1 != 0);
return ~uVar1 & 1;
}
return 1;
} |
3,420 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<int> arr, int n) {
std::vector<int> noOfZeroes(n, 0);
int count = 0;
noOfZeroes[n - 1] = 1 - arr[n - 1];
for (int i = n-2; i >= 0; --i) {
noOfZeroes[i] = noOfZeroes[i + 1];
if (arr[i] == 0) {
noOfZeroes[i] += 1;
}
}
... | int main() {
assert(func0({1, 0, 1, 0}, 4) == 3);
assert(func0({0, 1, 0}, 3) == 1);
assert(func0({0, 0, 1, 1, 0}, 5) == 2);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x41(%rbp),%rax
mov %rax,%rdi
callq 16dc <_ZNSaIiEC1Ev>
movl $0x0,-0x40(%rbp)... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_49]
mov [rbp+var_38], rax
nop
nop
mov [rbp+var_48], 0
mov eax, [rbp+var_5C]
m... | long long func0(long long a1, int a2)
{
int v2; // ebx
int v3; // ebx
_DWORD *v4; // rax
_DWORD *v5; // rax
unsigned int v6; // ebx
char v8; // [rsp+17h] [rbp-49h] BYREF
int v9; // [rsp+18h] [rbp-48h] BYREF
unsigned int v10; // [rsp+1Ch] [rbp-44h]
int i; // [rsp+20h] [rbp-40h]
int j; // [rsp+24h] [... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x49]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV dword ptr [RBP + -0x48],0x0
MOV EAX,dword ptr [RBP + -0x5c]
... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
int4 uVar2;
int *piVar3;
int4 *puVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
allocator local_51;
int local_50;
int local_4c;
int local_48;
... |
3,421 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<int> arr, int n) {
std::vector<int> noOfZeroes(n, 0);
int count = 0;
noOfZeroes[n - 1] = 1 - arr[n - 1];
for (int i = n-2; i >= 0; --i) {
noOfZeroes[i] = noOfZeroes[i + 1];
if (arr[i] == 0) {
noOfZeroes[i] += 1;
}
}
... | int main() {
assert(func0({1, 0, 1, 0}, 4) == 3);
assert(func0({0, 1, 0}, 3) == 1);
assert(func0({0, 0, 1, 1, 0}, 5) == 2);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r12
push %rbp
push %rbx
movslq %esi,%rbp
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rbp
ja 1273 <_Z5func0St6vectorIiSaIiEEi+0x6a>
mov %rdi,%r12
mov %esi,%ebx
test %rbp,%rbp
je 12ba <_Z5func0St6vectorIiSaIiEEi+0xb1>
shl $0x2,%rb... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
movsxd r12, esi
mov rax, r12
shr rax, 3Dh
jnz short loc_126E
mov r13, rdi
mov ebx, esi
test r12, r12
jz short loc_12AB
lea rbp, ds:0[r12*4]
mov rdi, rbp; unsigned __int64
call __Znw... | long long func0(long long *a1, int a2)
{
unsigned long long v3; // rbp
_DWORD *v4; // rax
_DWORD *v5; // rdi
_DWORD *v6; // rdx
long long v7; // rcx
long long v8; // rax
int v9; // edx
long long v10; // rax
unsigned int v11; // ebx
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error(... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVSXD R12,ESI
MOV RAX,R12
SHR RAX,0x3d
JNZ 0x0010126e
MOV R13,RDI
MOV EBX,ESI
TEST R12,R12
JZ 0x001012ab
LEA RBP,[R12*0x4]
MOV RDI,RBP
CALL 0x001010e0
MOV RDI,RAX
LEA RDX,[RAX + RBP*0x1]
LAB_00101244:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
char *pcVar1;
char *pcVar2;
long lVar3;
long in_RCX;
int iVar4;
ulong unaff_RBP;
int4 in_register_0000003c;
ulong uVar5;... |
3,422 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<int> arr, int n) {
std::vector<int> noOfZeroes(n, 0);
int count = 0;
noOfZeroes[n - 1] = 1 - arr[n - 1];
for (int i = n-2; i >= 0; --i) {
noOfZeroes[i] = noOfZeroes[i + 1];
if (arr[i] == 0) {
noOfZeroes[i] += 1;
}
}
... | int main() {
assert(func0({1, 0, 1, 0}, 4) == 3);
assert(func0({0, 1, 0}, 3) == 1);
assert(func0({0, 0, 1, 1, 0}, 5) == 2);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
movabs $0x1fffffffffffffff,%rax
movslq %esi,%rdx
push %r14
push %r13
push %r12
push %rbp
push %rbx
cmp %rax,%rdx
ja 14fd <_Z5func0St6vectorIiSaIiEEi+0x10d>
lea -0x1(%rdx),%ebp
mov %rdi,%r14
mov %rdx,%r12
movslq %ebp,%r13
lea 0x0(,%... | _Z5func0St6vectorIiSaIiEEi:
endbr64
movsxd rax, esi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rax
shr rbx, 3Dh
jnz loc_14F1
lea r13d, [rax-1]
mov r14, rdi
mov r12, rax
movsxd r13, r13d
lea rbp, ds:0[r13*4]
test rax, rax
jz loc_14D0
lea rbx, [rbp+4]
mo... | long long func0(long long *a1, int a2)
{
long long v3; // r13
long long v4; // rbp
void *v5; // rax
long long v6; // rcx
_DWORD *v7; // rdi
void *v8; // rax
int v9; // edx
unsigned long long v10; // rax
unsigned int v11; // r12d
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("ca... | func0:
ENDBR64
MOVSXD RAX,ESI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RAX
SHR RBX,0x3d
JNZ 0x001014f1
LEA R13D,[RAX + -0x1]
MOV R14,RDI
MOV R12,RAX
MOVSXD R13,R13D
LEA RBP,[R13*0x4]
TEST RAX,RAX
JZ 0x001014d0
LEA RBX,[RBP + 0x4]
MOV RDI,RBX
CALL 0x00101100
MOV RDX,RBX
XOR ESI,ESI
MOV RDI,RAX
CALL 0x001010d... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >, int) */
void * func0(vector param_1,int param_2)
{
ulong __n;
int iVar1;
long lVar2;
long lVar3;
void *pvVar4;
long lVar5;
void *extraout_RAX;
int4 in_register_0000003c... |
3,423 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<int> arr, int n) {
std::vector<int> noOfZeroes(n, 0);
int count = 0;
noOfZeroes[n - 1] = 1 - arr[n - 1];
for (int i = n-2; i >= 0; --i) {
noOfZeroes[i] = noOfZeroes[i + 1];
if (arr[i] == 0) {
noOfZeroes[i] += 1;
}
}
... | int main() {
assert(func0({1, 0, 1, 0}, 4) == 3);
assert(func0({0, 1, 0}, 3) == 1);
assert(func0({0, 0, 1, 1, 0}, 5) == 2);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
movabs $0x1fffffffffffffff,%rdx
push %r15
movslq %esi,%rax
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
cmp %rdx,%rax
ja 1615 <_Z5func0St6vectorIiSaIiEEi+0x215>
lea -0x1(%rax),%ebx
mov %rdi,%r13
mov %rax,%rbp
m... | _Z5func0St6vectorIiSaIiEEi:
endbr64
movsxd rax, esi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rax
shr rbx, 3Dh
jnz loc_14F1
lea r13d, [rax-1]
mov r14, rdi
mov r12, rax
movsxd r13, r13d
lea rbp, ds:0[r13*4]
test rax, rax
jz loc_14D0
lea rbx, [rbp+4]
mo... | long long func0(long long *a1, int a2)
{
long long v3; // r13
long long v4; // rbp
void *v5; // rax
long long v6; // rcx
_DWORD *v7; // rdi
void *v8; // rax
int v9; // edx
unsigned long long v10; // rax
unsigned int v11; // r12d
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("ca... | func0:
ENDBR64
MOVSXD RAX,ESI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RAX
SHR RBX,0x3d
JNZ 0x001014f1
LEA R13D,[RAX + -0x1]
MOV R14,RDI
MOV R12,RAX
MOVSXD R13,R13D
LEA RBP,[R13*0x4]
TEST RAX,RAX
JZ 0x001014d0
LEA RBX,[RBP + 0x4]
MOV RDI,RBX
CALL 0x00101100
MOV RDX,RBX
XOR ESI,ESI
MOV RDI,RAX
CALL 0x001010d... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >, int) */
void * func0(vector param_1,int param_2)
{
ulong __n;
int iVar1;
long lVar2;
long lVar3;
void *pvVar4;
long lVar5;
void *extraout_RAX;
int4 in_register_0000003c... |
3,424 | func0 |
#include <vector>
#include <string>
#include <iostream>
#include <assert.h>
| std::vector<std::vector<char>> func0(const std::vector<std::string>& list1) {
std::vector<std::vector<char>> result;
for (const std::string & str : list1) {
std::vector<char> chars(str.begin(), str.end());
result.push_back(chars);
}
return result;
}
| int main() {
assert((func0({"Red", "Blue", "Black", "White", "Pink"}) == std::vector<std::vector<char>>{{'R', 'e', 'd'}, {'B', 'l', 'u', 'e'}, {'B', 'l', 'a', 'c', 'k'}, {'W', 'h', 'i', 't', 'e'}, {'P', 'i', 'n', 'k'}}));
assert((func0({"python"}) == std::vector<std::vector<char>>{{'p', 'y', 't', 'h', 'o', 'n... | O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_68]
mov rdi, rax
call _ZNSt6... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
char v5; // [rsp+17h] [rbp-59h] BYREF
long long v6; // [rsp+18h] [rbp-58h] BYREF
_QWORD v7[2]; // [rsp+20h] [rbp-50h] BYREF
long long v8; // [rsp+30h] [rbp-40h]
char *v9; // [rsp+38h] [rbp-38h]
_BYTE v10[24]; // [rs... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
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 0x001033fa
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x48],RAX
MO... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
bool bVar1;
int8 uVar2;
int8 uVar3;
vector<std::string,std::allocator<std::string>> *in_RSI;
long in_FS_OFFSET;
__new_allocator<char> local_61;
int8 local_60;
int8 local_58;
vector<std::stri... |
3,425 | func0 |
#include <vector>
#include <string>
#include <iostream>
#include <assert.h>
| std::vector<std::vector<char>> func0(const std::vector<std::string>& list1) {
std::vector<std::vector<char>> result;
for (const std::string & str : list1) {
std::vector<char> chars(str.begin(), str.end());
result.push_back(chars);
}
return result;
}
| int main() {
assert((func0({"Red", "Blue", "Black", "White", "Pink"}) == std::vector<std::vector<char>>{{'R', 'e', 'd'}, {'B', 'l', 'u', 'e'}, {'B', 'l', 'a', 'c', 'k'}, {'W', 'h', 'i', 't', 'e'}, {'P', 'i', 'n', 'k'}}));
assert((func0({"python"}) == std::vector<std::vector<char>>{{'p', 'y', 't', 'h', 'o', 'n... | O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r1... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r14, rdi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
m... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v3; // rbp
_BYTE *v4; // r12
_BYTE *v5; // r15
_QWORD *v6; // r13
_BYTE *v7; // rdi
_BYTE *v8; // r15
_BYTE *v9; // r13
signed long long v10; // rbx
_BYTE *v11; // rax
long long v13; // [rsp+0h] [rbp-68h]
_BYTE *v14; // [rsp+10h] [rbp-58h] BYRE... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBP,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [R... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
int8 *puVar1;
ulong __n;
int8 uVar2;
int *puVar3;
int *__dest;
int8 *puVar4;
int8 *in_RSI;
int8 *puVar5;
int8 *puVar6;
int *puVar7;
long in_FS_OFFSET;
int *local_58;
int *local_50;
... |
3,426 | func0 |
#include <vector>
#include <string>
#include <iostream>
#include <assert.h>
| std::vector<std::vector<char>> func0(const std::vector<std::string>& list1) {
std::vector<std::vector<char>> result;
for (const std::string & str : list1) {
std::vector<char> chars(str.begin(), str.end());
result.push_back(chars);
}
return result;
}
| int main() {
assert((func0({"Red", "Blue", "Black", "White", "Pink"}) == std::vector<std::vector<char>>{{'R', 'e', 'd'}, {'B', 'l', 'u', 'e'}, {'B', 'l', 'a', 'c', 'k'}, {'W', 'h', 'i', 't', 'e'}, {'P', 'i', 'n', 'k'}}));
assert((func0({"python"}) == std::vector<std::vector<char>>{{'p', 'y', 't', 'h', 'o', 'n... | O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x48,%rs... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 38h
mov rbp, [rsi]
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov rax, [rsi+8... | long long func0(long long a1, long long *a2)
{
long long v2; // rbp
long long v3; // rax
_BYTE *v4; // rax
_BYTE *v5; // r15
_BYTE *v6; // r13
long long v7; // r14
_BYTE *v8; // rax
_BYTE *v9; // r15
long long v10; // rax
signed long long v11; // rbx
_BYTE *v12; // r14
long long v13; // rsi
l... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RBP,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RSP + 0x8]... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
long lVar1;
int8 *puVar2;
long lVar3;
ulong __n;
int *puVar4;
vector *pvVar5;
int *__dest;
int *__dest_00;
int8 *puVar6;
int8 *in_RSI;
long in_FS_OFFSET;
puVar6 = (int8 *)*in_RSI;
... |
3,427 | func0 |
#include <vector>
#include <string>
#include <iostream>
#include <assert.h>
| std::vector<std::vector<char>> func0(const std::vector<std::string>& list1) {
std::vector<std::vector<char>> result;
for (const std::string & str : list1) {
std::vector<char> chars(str.begin(), str.end());
result.push_back(chars);
}
return result;
}
| int main() {
assert((func0({"Red", "Blue", "Black", "White", "Pink"}) == std::vector<std::vector<char>>{{'R', 'e', 'd'}, {'B', 'l', 'u', 'e'}, {'B', 'l', 'a', 'c', 'k'}, {'W', 'h', 'i', 't', 'e'}, {'P', 'i', 'n', 'k'}}));
assert((func0({"python"}) == std::vector<std::vector<char>>{{'p', 'y', 't', 'h', 'o', 'n... | O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %r... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 38h
mov rbp, [rsi]
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov rax, [rsi+8... | long long func0(long long a1, long long *a2)
{
long long v2; // rbp
long long v3; // rax
_BYTE *v4; // rax
_BYTE *v5; // r15
_BYTE *v6; // r13
long long v7; // r14
_BYTE *v8; // rax
_BYTE *v9; // r15
long long v10; // rax
signed long long v11; // rbx
_BYTE *v12; // r14
long long v13; // rsi
l... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RBP,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RSP + 0x8]... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
long lVar1;
int8 *puVar2;
long lVar3;
ulong __n;
int *puVar4;
vector *pvVar5;
int *__dest;
int *__dest_00;
int8 *puVar6;
int8 *in_RSI;
long in_FS_OFFSET;
puVar6 = (int8 *)*in_RSI;
... |
3,428 | func0 |
#include <vector>
#include <cassert>
| int func0(const std::vector<std::vector<int>>& input_list) {
return input_list.size() * input_list.size();
}
| int main() {
assert(func0({{0}, {1, 3}, {5, 7}, {9, 11}, {13, 15, 17}}) == 25);
assert(func0({{1, 3}, {5, 7}, {9, 11}, {13, 15, 17}}) == 16);
assert(func0({{2, 4}, {6,8,4,5,8}, {10, 12, 14}}) == 9);
return 0;
}
| O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1dcc <_ZNKSt6vectorIS_IiSaIiEESaIS1_EE4sizeEv>
mov %e... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_18], rdi
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EE4sizeEv; std::vector<std::vector<int>>::size(void)
mov ebx, eax
mov rax, [rbp+var_18]
mov rdi... | long long func0(long long a1)
{
int v1; // ebx
v1 = std::vector<std::vector<int>>::size(a1);
return v1 * (unsigned int)std::vector<std::vector<int>>::size(a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101d58
MOV EBX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101d58
IMUL EAX,EBX
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
int iVar1;
int iVar2;
iVar1 = std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
... |
3,429 | func0 |
#include <vector>
#include <cassert>
| int func0(const std::vector<std::vector<int>>& input_list) {
return input_list.size() * input_list.size();
}
| int main() {
assert(func0({{0}, {1, 3}, {5, 7}, {9, 11}, {13, 15, 17}}) == 25);
assert(func0({{1, 3}, {5, 7}, {9, 11}, {13, 15, 17}}) == 16);
assert(func0({{2, 4}, {6,8,4,5,8}, {10, 12, 14}}) == 9);
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
mov 0x8(%rdi),%rax
sub (%rdi),%rax
sar $0x3,%rax
imul %eax,%eax
imul $0x38e38e39,%eax,%eax
retq
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rax, [rdi+8]
sub rax, [rdi]
sar rax, 3
imul eax, eax
imul eax, 38E38E39h
retn | long long func0(_QWORD *a1)
{
long long v1; // rax
v1 = (long long)(a1[1] - *a1) >> 3;
return (unsigned int)(954437177 * v1 * v1);
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,qword ptr [RDI]
SAR RAX,0x3
IMUL EAX,EAX
IMUL EAX,EAX,0x38e38e39
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
int iVar1;
iVar1 = (int)(*(long *)(param_1 + 8) - *(long *)param_1 >> 3);
return iVar1 * iVar1 * 0x38e38e39;
} |
3,430 | func0 |
#include <vector>
#include <cassert>
| int func0(const std::vector<std::vector<int>>& input_list) {
return input_list.size() * input_list.size();
}
| int main() {
assert(func0({{0}, {1, 3}, {5, 7}, {9, 11}, {13, 15, 17}}) == 25);
assert(func0({{1, 3}, {5, 7}, {9, 11}, {13, 15, 17}}) == 16);
assert(func0({{2, 4}, {6,8,4,5,8}, {10, 12, 14}}) == 9);
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
mov 0x8(%rdi),%rax
sub (%rdi),%rax
sar $0x3,%rax
imul %eax,%eax
imul $0x38e38e39,%eax,%eax
retq
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rax, [rdi+8]
sub rax, [rdi]
sar rax, 3
imul eax, eax
imul eax, 38E38E39h
retn | long long func0(_QWORD *a1)
{
long long v1; // rax
v1 = (long long)(a1[1] - *a1) >> 3;
return (unsigned int)(954437177 * v1 * v1);
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,qword ptr [RDI]
SAR RAX,0x3
IMUL EAX,EAX
IMUL EAX,EAX,0x38e38e39
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
int iVar1;
iVar1 = (int)(*(long *)(param_1 + 8) - *(long *)param_1 >> 3);
return iVar1 * iVar1 * 0x38e38e39;
} |
3,431 | func0 |
#include <vector>
#include <cassert>
| int func0(const std::vector<std::vector<int>>& input_list) {
return input_list.size() * input_list.size();
}
| int main() {
assert(func0({{0}, {1, 3}, {5, 7}, {9, 11}, {13, 15, 17}}) == 25);
assert(func0({{1, 3}, {5, 7}, {9, 11}, {13, 15, 17}}) == 16);
assert(func0({{2, 4}, {6,8,4,5,8}, {10, 12, 14}}) == 9);
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
mov 0x8(%rdi),%rax
sub (%rdi),%rax
sar $0x3,%rax
imul %eax,%eax
imul $0x38e38e39,%eax,%eax
retq
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rax, [rdi+8]
sub rax, [rdi]
sar rax, 3
imul eax, eax
imul eax, 38E38E39h
retn | long long func0(_QWORD *a1)
{
long long v1; // rax
v1 = (long long)(a1[1] - *a1) >> 3;
return (unsigned int)(954437177 * v1 * v1);
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,qword ptr [RDI]
SAR RAX,0x3
IMUL EAX,EAX
IMUL EAX,EAX,0x38e38e39
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
int iVar1;
iVar1 = (int)(*(long *)(param_1 + 8) - *(long *)param_1 >> 3);
return iVar1 * iVar1 * 0x38e38e39;
} |
3,432 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
template<typename T>
| std::vector<std::vector<T>> func0(std::vector<T> my_list) {
std::vector<std::vector<T>> subs;
for (size_t i = 0; i <= my_list.size(); ++i) {
std::vector<T> temp;
std::vector<bool> v(my_list.size());
std::fill(v.begin() + i, v.end(), true);
do {
for (size_t j ... | int main() {
assert((func0(std::vector<int>{10, 20, 30, 40}) == std::vector<std::vector<int>>{{}, {10}, {20}, {30}, {40}, {10, 20}, {10, 30}, {10, 40}, {20, 30}, {20, 40}, {30, 40}, {10, 20, 30}, {10, 20, 40}, {10, 30, 40}, {20, 30, 40}, {10, 20, 30, 40}}));
assert((func0(std::vector<char>{'X', 'Y', 'Z'}) == ... | O0 | cpp | std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xd8,%rsp
mov %rdi,-0xd8(%rbp)
mov %rsi,-0xe0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp... | _Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0D8h
mov [rbp+var_D8], rdi
mov [rbp+var_E0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_D8]
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEC2Ev; st... | long long func0<int>(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rdx
unsigned long long v4; // rbx
long long v5; // rdx
long long v6; // rdx
long long v7; // rdx
long long v8; // rax
unsigned long long v9; // rax
long long v10; // rdx
long long v11; // rdx
unsigned long lo... | func0<int>:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xd8
MOV qword ptr [RBP + -0xd8],RDI
MOV qword ptr [RBP + -0xe0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0xd8]
MOV RDI,RAX
CALL 0x00103260
MOV qword ptr [RBP + -0xc8],0x0
JMP 0x001034da
LAB_001032cb:
... | /* std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> >) */
vector func0<int>(vector param_1)
{
bool bVar1;
char cVar2;
int *piVar3;
ulong uVar4;
vector<int,std::allocator<int>> *in_RSI;
int4 in_r... |
3,433 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
template<typename T>
| std::vector<std::vector<T>> func0(std::vector<T> my_list) {
std::vector<std::vector<T>> subs;
for (size_t i = 0; i <= my_list.size(); ++i) {
std::vector<T> temp;
std::vector<bool> v(my_list.size());
std::fill(v.begin() + i, v.end(), true);
do {
for (size_t j ... | int main() {
assert((func0(std::vector<int>{10, 20, 30, 40}) == std::vector<std::vector<int>>{{}, {10}, {20}, {30}, {40}, {10, 20}, {10, 30}, {10, 40}, {20, 30}, {20, 40}, {30, 40}, {10, 20, 30}, {10, 20, 40}, {10, 30, 40}, {20, 30, 40}, {10, 20, 30, 40}}));
assert((func0(std::vector<char>{'X', 'Y', 'Z'}) == ... | O1 | cpp | std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rdi,%r14
mov %rsi,%rbx
mov %fs:0x28,%rax
mov ... | _Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EES3_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r14, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr... | _QWORD * func0<int>(_QWORD *a1, long long *a2, long long a3, long long a4, long long a5, long long a6)
{
long long v8; // rax
long long v9; // rbp
signed long long v10; // r15
unsigned long long v11; // r12
char *v12; // rdi
char *v13; // rdx
long long v14; // rcx
char *v15; // rbp
int v16; // r12d
... | func0<int>:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R14,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI + 0x8]
SUB RAX,qword ptr [RSI]... | /* std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> >) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0<int>(vector<std::vector<int,std::allocator<... |
3,434 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
template<typename T>
| std::vector<std::vector<T>> func0(std::vector<T> my_list) {
std::vector<std::vector<T>> subs;
for (size_t i = 0; i <= my_list.size(); ++i) {
std::vector<T> temp;
std::vector<bool> v(my_list.size());
std::fill(v.begin() + i, v.end(), true);
do {
for (size_t j ... | int main() {
assert((func0(std::vector<int>{10, 20, 30, 40}) == std::vector<std::vector<int>>{{}, {10}, {20}, {30}, {40}, {10, 20}, {10, 30}, {10, 40}, {20, 30}, {20, 40}, {30, 40}, {10, 20, 30}, {10, 20, 40}, {10, 30, 40}, {20, 30, 40}, {10, 20, 30, 40}}));
assert((func0(std::vector<char>{'X', 'Y', 'Z'}) == ... | O2 | cpp | std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x98,%rsp
mov 0x8(%rsi),%rbx
sub ... | _Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EES3_:
endbr64
push r15
pxor xmm0, xmm0
xor r15d, r15d
push r14
push r13
mov r13, rdi
push r12
push rbp
mov rbp, rsi
push rbx
sub rsp, 78h
mov rbx, [rsi+8]
sub rbx, [rsi]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax,... | long long func0<int>(long long a1, long long *a2, long long a3, long long a4, long long a5, long long a6)
{
signed long long v6; // r15
long long v9; // rbx
long long v10; // rbx
long long v11; // rax
void **v12; // rdi
long long v13; // rax
long long v14; // rcx
void **v15; // r14
int v16; // ebx
... | func0<int>:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
XOR R15D,R15D
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
SUB RSP,0x78
MOV RBX,qword ptr [RSI + 0x8]
SUB RBX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
SAR RBX,0x2
MOVUPS xmmwo... | /* std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> >) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0<int>(vector<std::vector<int,std::allocator<... |
3,435 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
template<typename T>
| std::vector<std::vector<T>> func0(std::vector<T> my_list) {
std::vector<std::vector<T>> subs;
for (size_t i = 0; i <= my_list.size(); ++i) {
std::vector<T> temp;
std::vector<bool> v(my_list.size());
std::fill(v.begin() + i, v.end(), true);
do {
for (size_t j ... | int main() {
assert((func0(std::vector<int>{10, 20, 30, 40}) == std::vector<std::vector<int>>{{}, {10}, {20}, {30}, {40}, {10, 20}, {10, 30}, {10, 40}, {20, 30}, {20, 40}, {30, 40}, {10, 20, 30}, {10, 20, 40}, {10, 30, 40}, {20, 30, 40}, {10, 20, 30, 40}}));
assert((func0(std::vector<char>{'X', 'Y', 'Z'}) == ... | O3 | cpp | std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
push %r15
pxor %xmm0,%xmm0
mov %rsi,%r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov ... | _Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EES3_:
endbr64
push r15
pxor xmm0, xmm0
xor r15d, r15d
push r14
push r13
mov r13, rsi
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 78h
mov rbx, [rsi+8]
sub rbx, [rsi]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax,... | long long func0<int>(long long a1, long long *a2, long long a3, long long a4, long long a5, long long a6)
{
signed long long v6; // r15
long long v9; // rbx
long long v10; // rbx
long long v11; // rax
void **v12; // rdi
long long v13; // rax
long long v14; // rcx
void **v15; // r14
int v16; // ebx
... | func0<int>:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
XOR R15D,R15D
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RBX,qword ptr [RSI + 0x8]
SUB RBX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
SAR RBX,0x2
MOVUPS xmmwo... | /* std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> >) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0<int>(vector<std::vector<int,std::allocator<... |
3,436 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& str) {
std::regex rule("[a-zA-Z0-9]$");
if (std::regex_search(str, rule)) {
return "Accept";
} else {
return "Discard";
}
}
| int main() {
assert(func0("dawood@") == "Discard");
assert(func0("skdmsam326") == "Accept");
assert(func0("cooltricks@") == "Discard");
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov $0x10,%edx
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, aAZaZ09; "[a-zA-Z0-... | long long func0(long long a1, long long a2)
{
char v3; // [rsp+1Fh] [rbp-51h] BYREF
char *v4; // [rsp+20h] [rbp-50h]
char *v5; // [rsp+28h] [rbp-48h]
_BYTE v6[40]; // [rsp+30h] [rbp-40h] BYREF
unsigned long long v7; // [rsp+58h] [rbp-18h]
v7 = __readfsqword(0x28u);
std::basic_regex<char,std::regex_trait... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV EDX,0x10
LEA RCX,[0x132051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b43:
CALL 0x001061ba
LEA RCX,[RBP + -0x... | /* func0(std::string const&) */
string * func0(string *param_1)
{
bool bVar1;
string *in_RSI;
long in_FS_OFFSET;
allocator local_59;
allocator *local_58;
allocator *local_50;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_48,"[a-zA-Z... |
3,437 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& str) {
std::regex rule("[a-zA-Z0-9]$");
if (std::regex_search(str, rule)) {
return "Accept";
} else {
return "Discard";
}
}
| int main() {
assert(func0("dawood@") == "Discard");
assert(func0("skdmsam326") == "Accept");
assert(func0("cooltricks@") == "Discard");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
mov %r13,%rdi
callq 4730 <_ZN... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea r12, [rbp+var_70]
lea rdi, [rbp+var_68]; this
call __Z... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x70]
LEA RDI,[RBP + -0x68]
CALL 0x001046f0
MOV qword ptr [RBP + -0x60],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV ECX,0x10
LEA RDX,[0x... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
bool bVar3;
int iVar4;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_78 [8];
int local_70 [8];
int8 local_68;
_Sp_counted_base<(_Lock_policy)2> *lo... | |
3,438 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& str) {
std::regex rule("[a-zA-Z0-9]$");
if (std::regex_search(str, rule)) {
return "Accept";
} else {
return "Discard";
}
}
| int main() {
assert(func0("dawood@") == "Discard");
assert(func0("skdmsam326") == "Accept");
assert(func0("cooltricks@") == "Discard");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
lea 0x8(%rsp),%rbp... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
mov r14, rsi
push r13
lea r13, [rbp+var_70]
push r12
lea r12, [rbp+var_68]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_28], rax... | long long func0(long long a1, long long *a2)
{
long long v3; // rdi
long long v4; // rsi
long long v5; // rsi
char v6; // r13
long long v7; // rdi
long long v8; // rdx
volatile signed __int32 *v9; // rcx
signed __int32 v10; // eax
long long v12; // rax
_BYTE v13[8]; // [rsp+0h] [rbp-70h] BYREF
_B... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
MOV R14,RSI
PUSH R13
LEA R13,[RBP + -0x70]
PUSH R12
LEA R12,[RBP + -0x68]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001036d0
LEA RDX,[0x11862f]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
bool bVar3;
int iVar4;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_78 [8];
int local_70 [8];
int local_68 [16];
int local_58 [16];
int local_48 [16];
long local_30;
lo... |
3,439 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& str) {
std::regex rule("[a-zA-Z0-9]$");
if (std::regex_search(str, rule)) {
return "Accept";
} else {
return "Discard";
}
}
| int main() {
assert(func0("dawood@") == "Discard");
assert(func0("skdmsam326") == "Accept");
assert(func0("cooltricks@") == "Discard");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
lea 0x8(%rsp),%rbp... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
mov r15, rsi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 2B8h
mov rax, fs:28h
mov [rsp+2E8h+var_40], rax
xor eax, eax
lea r14, [rsp+2E8h+var_2A0]
mov rdi, r14; this
c... | long long func0(long long a1, unsigned long long *a2)
{
__m128i v3; // xmm0
long long v4; // rdi
void *v5; // rdi
void **v6; // rbp
unsigned long long v7; // r12
void *v8; // rdi
unsigned long long v9; // r13
unsigned long long v10; // rbp
long long v11; // rax
long long v12; // rcx
unsigned long... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x2b8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x2a8],RAX
XOR EAX,EAX
LEA R14,[RSP + 0x48]
MOV RDI,R14
CALL 0x00104730
LEA RDX,[0x11a674]
PXOR XMM0,XMM0
LEA RDI,[RSP + 0x110]
MOV R8D,0x10
MOV RCX,R14
LEA RSI,[RD... | /* func0(std::string const&) */
string * func0(string *param_1)
{
ulong uVar1;
int8 uVar2;
ulong uVar3;
int auVar4 [16];
bool bVar5;
char cVar6;
long lVar7;
int8 *puVar8;
int8 *puVar9;
ulong uVar10;
ulong *puVar11;
long lVar12;
ulong uVar13;
ulong *in_RSI;
uint *puVar14;
_Match_mode _V... |
3,440 | func0 |
#include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::string> func0(std::vector<std::string> texts, std::string str) {
std::vector<std::string> result;
std::sort(str.begin(), str.end());
for (auto& text : texts) {
std::string temp = text;
std::sort(temp.begin(), temp.end());
if (temp == str) {
result.... | int main() {
assert((func0({"bcda", "abce", "cbda", "cbea", "adcb"}, "abcd") == std::vector<std::string>{"bcda", "cbda", "adcb"}));
assert((func0({"recitals", " python"}, "articles") == std::vector<std::string>{"recitals"}));
assert((func0({" keep", " abcdef", " xyz"}, " peek") == std::vector<std::string... | O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
pu... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_78], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_68]
mov ... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rbx
long long v4; // rax
long long v5; // rbx
long long v6; // rax
long long v9; // [rsp+20h] [rbp-60h] BYREF
_QWORD v10[2]; // [rsp+28h] [rbp-58h] BYREF
long long v11; // [rsp+38h] [rbp-48h]
_BYTE v12[40]; // [rsp+40h] [rbp-4... | 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 qword ptr [RBP + -0x78],RDX
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 0x00103324
MOV RAX,qword ptr [RBP + -0x78]
MO... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,
vector<std::string,std::allocator<std::string>> *param_2,string *param_3)
{
bool bVar1;
__normal_iterator _Var2;
... |
3,441 | func0 |
#include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::string> func0(std::vector<std::string> texts, std::string str) {
std::vector<std::string> result;
std::sort(str.begin(), str.end());
for (auto& text : texts) {
std::string temp = text;
std::sort(temp.begin(), temp.end());
if (temp == str) {
result.... | int main() {
assert((func0({"bcda", "abce", "cbda", "cbea", "adcb"}, "abcd") == std::vector<std::string>{"bcda", "cbda", "adcb"}));
assert((func0({"recitals", " python"}, "articles") == std::vector<std::string>{"recitals"}));
assert((func0({" keep", " abcdef", " xyz"}, " peek") == std::vector<std::string... | O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r13, rdi
mov rbp, rsi
mov r14, rdx
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov qword ptr [rdi... | _QWORD * func0(_QWORD *a1, _QWORD *a2, long long a3)
{
const void *v5; // rbx
unsigned long long v6; // rax
unsigned long long v7; // r12
_QWORD *v8; // rbx
_QWORD *v9; // r15
void *v10; // rbp
char *v11; // r12
unsigned long long v12; // rax
_QWORD *v13; // rdi
void *s1; // [rsp+10h] [rbp-68h] BYRE... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R13,RDI
MOV RBP,RSI
MOV R14,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBX,qword ptr [RDX]
MOV RAX,qword ptr [RDX... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2,long *param_3,
_Iter_less_iter param_4)
{
long lVar1;
ulong uVar2;
string *psVar3;
long *plVar4;... |
3,442 | func0 |
#include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::string> func0(std::vector<std::string> texts, std::string str) {
std::vector<std::string> result;
std::sort(str.begin(), str.end());
for (auto& text : texts) {
std::string temp = text;
std::sort(temp.begin(), temp.end());
if (temp == str) {
result.... | int main() {
assert((func0({"bcda", "abce", "cbda", "cbea", "adcb"}, "abcd") == std::vector<std::string>{"bcda", "cbda", "adcb"}));
assert((func0({"recitals", " python"}, "articles") == std::vector<std::string>{"recitals"}));
assert((func0({" keep", " abcdef", " xyz"}, " peek") == std::vector<std::string... | O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 48h
mov r12, [rdx]
mov rax, fs:28h
mov [rsp+78h+var_40], rax
x... | long long func0(long long a1, _QWORD *a2, char **a3)
{
char *v5; // r12
unsigned long long v6; // rax
char *v7; // r14
unsigned long long v8; // rdx
_QWORD *v9; // r14
_QWORD *i; // rbx
unsigned long long v11; // rax
char *v12; // r15
long long v13; // rdx
_QWORD *v14; // rdi
long long v15; // rd... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x48
MOV R12,qword ptr [RDX]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RDX + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
L... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,int8 *param_2,long *param_3,
_Iter_less_iter param_4)
{
long lVar1;
ulong uVar2;
string *psVar3;
int8 uVar4;
... |
3,443 | func0 |
#include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::string> func0(std::vector<std::string> texts, std::string str) {
std::vector<std::string> result;
std::sort(str.begin(), str.end());
for (auto& text : texts) {
std::string temp = text;
std::sort(temp.begin(), temp.end());
if (temp == str) {
result.... | int main() {
assert((func0({"bcda", "abce", "cbda", "cbea", "adcb"}, "abcd") == std::vector<std::string>{"bcda", "cbda", "adcb"}));
assert((func0({"recitals", " python"}, "articles") == std::vector<std::string>{"recitals"}));
assert((func0({" keep", " abcdef", " xyz"}, " peek") == std::vector<std::string... | O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
mov rbp, rsi
push rbx
sub rsp, 78h
mov r15, [rdx]
mov r13, [rdx+8]
mov [rsp+0A8h+var_A8], rdx
lea r14, [r1... | long long func0(long long a1, long long *a2, long long a3, _BYTE *a4, unsigned __int8 *a5)
{
long long *j; // rbp
unsigned __int8 *v7; // r15
signed long long v8; // r13
unsigned __int8 *v9; // r14
unsigned long long v10; // rdx
unsigned __int8 *v11; // rbx
unsigned __int8 *v12; // rbp
signed __int8 v1... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
PUSH RBX
SUB RSP,0x78
MOV R15,qword ptr [RDX]
MOV R13,qword ptr [RDX + 0x8]
MOV qword ptr [RSP],RDX
LEA R14,[R15 + R13*0x1]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10]... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,int8 *param_2,
int8 *param_3,_Iter_less_iter param_4)
{
char ... |
3,444 | func0 | #include <iostream>
#include <vector>
#include <unordered_map>
#include <string>
#include <regex>
#include <algorithm>
#include <assert.h>
using namespace std;
| vector<pair<string, int>> func0(const string &text, int n) {
unordered_map<string, int> word_count;
regex word_regex("\\w+");
auto words_begin = sregex_iterator(text.begin(), text.end(), word_regex);
auto words_end = sregex_iterator();
for (sregex_iterator i = words_begin; i != words_end; ++i... | int main() {
assert((func0("python is a programming language", 1) == vector<pair<string, int>>{{"a", 1}}));
assert((func0("python is a programming language", 2) == vector<pair<string, int>>{{"a", 1}, {"is", 1}}));
assert((func0("python is a programming language", 5) == vector<pair<string, int>>{{"a", 1},... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, int)::{lambda(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int> const&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int> const&)#1}::... | _ZZ5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiENKUlRKSt4pairIS4_iESA_E_clESA_SA_:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
mov edx, [rax+20h]
mov rax, [rbp+var_18]
mov eax, [rax+20h]... | _BOOL8 func0(std::string const&,int)::{lambda(std::pair<std::string,int> const&,std::pair<std::string,int> const&)#1}::operator()(
long long a1,
long long a2,
long long a3)
{
return *(_DWORD *)(a2 + 32) > *(_DWORD *)(a3 + 32)
|| *(_DWORD *)(a2 + 32) == *(_DWORD *)(a3 + 32) && (unsigned ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x188
MOV qword ptr [RBP + -0x178],RDI
MOV qword ptr [RBP + -0x180],RSI
MOV dword ptr [RBP + -0x184],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x140]
MOV RDI,RAX
CALL 0x00108c5e
LEA RAX,[RBP + -0x160]
MOV EDX,0x10
LEA... | /* func0(std::string const&, int) */
string * func0(string *param_1,int param_2)
{
bool bVar1;
char cVar2;
__normal_iterator _Var3;
__normal_iterator _Var4;
_Node_iterator _Var5;
_Node_iterator _Var6;
int *piVar7;
pair *ppVar8;
ulong uVar9;
int in_EDX;
_lambda_std__pair<std::string,int>_const__s... |
3,445 | func0 | #include <iostream>
#include <vector>
#include <unordered_map>
#include <string>
#include <regex>
#include <algorithm>
#include <assert.h>
using namespace std;
| vector<pair<string, int>> func0(const string &text, int n) {
unordered_map<string, int> word_count;
regex word_regex("\\w+");
auto words_begin = sregex_iterator(text.begin(), text.end(), word_regex);
auto words_end = sregex_iterator();
for (sregex_iterator i = words_begin; i != words_end; ++i... | int main() {
assert((func0("python is a programming language", 1) == vector<pair<string, int>>{{"a", 1}}));
assert((func0("python is a programming language", 2) == vector<pair<string, int>>{{"a", 1}, {"is", 1}}));
assert((func0("python is a programming language", 5) == vector<pair<string, int>>{{"a", 1},... | O1 | cpp | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_str... | _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIPSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESt6vectorIS9_SaIS9_EEEElS9_NS0_5__ops15_Iter_comp_iterIZ5func0RKS8_iEUlRKS9_SK_E_EEEvT_T0_SO_T1_T2_:
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rbp, rdi... | unsigned long long std::__adjust_heap<__gnu_cxx::__normal_iterator<std::pair<std::string,int> *,std::vector<std::pair<std::string,int>>>,long,std::pair<std::string,int>,__gnu_cxx::__ops::_Iter_comp_iter<func0(std::string const&,int)::{lambda(std::pair<std::string,int> const&,std::pair<std::string,int> const&)#1}>>(
... | __adjust_heap<__normal_iterator<std::pair<std::string,int>*,std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>>>,long,std::pair<std::string,int>,__ops::_Iter_comp_iter<func0(std::string_const&,int)::{lambda(std::pair<std::string,int>const&,std::pair<std::string,int>const&)#1}>>:
PUSH R15
... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__adjust_heap<__normal_iterator<std::pair<std::string, int>*,
std::vector<std::pair<std::string, int>, std::allocator<std::pair<std::string, int> > > >, long,
std::pair<std::string, int>, __ops::_Iter_comp_iter<func0(std::st... |
3,446 | func0 | #include <iostream>
#include <vector>
#include <unordered_map>
#include <string>
#include <regex>
#include <algorithm>
#include <assert.h>
using namespace std;
| vector<pair<string, int>> func0(const string &text, int n) {
unordered_map<string, int> word_count;
regex word_regex("\\w+");
auto words_begin = sregex_iterator(text.begin(), text.end(), word_regex);
auto words_end = sregex_iterator();
for (sregex_iterator i = words_begin; i != words_end; ++i... | int main() {
assert((func0("python is a programming language", 1) == vector<pair<string, int>>{{"a", 1}}));
assert((func0("python is a programming language", 2) == vector<pair<string, int>>{{"a", 1}, {"is", 1}}));
assert((func0("python is a programming language", 5) == vector<pair<string, int>>{{"a", 1},... | O2 | cpp | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_str... | _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIPSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESt6vectorIS9_SaIS9_EEEElS9_NS0_5__ops15_Iter_comp_iterIZ5func0RKS8_iEUlRKS9_SK_E_EEEvT_T0_SO_T1_T2_:
push r15
mov r15, rdx
sub rdx, 1
push r14
mov r14, rcx
push r13
mov r13, rdi
pus... | unsigned long long std::__adjust_heap<__gnu_cxx::__normal_iterator<std::pair<std::string,int> *,std::vector<std::pair<std::string,int>>>,long,std::pair<std::string,int>,__gnu_cxx::__ops::_Iter_comp_iter<func0(std::string const&,int)::{lambda(std::pair<std::string,int> const&,std::pair<std::string,int> const&)#1}>>(
... | __adjust_heap<__normal_iterator<std::pair<std::string,int>*,std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>>>,long,std::pair<std::string,int>,__ops::_Iter_comp_iter<func0(std::string_const&,int)::{lambda(std::pair<std::string,int>const&,std::pair<std::string,int>const&)#1}>>:
PUSH R15
... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__adjust_heap<__normal_iterator<std::pair<std::string, int>*,
std::vector<std::pair<std::string, int>, std::allocator<std::pair<std::string, int> > > >, long,
std::pair<std::string, int>, __ops::_Iter_comp_iter<func0(std::st... |
3,447 | func0 | #include <iostream>
#include <vector>
#include <unordered_map>
#include <string>
#include <regex>
#include <algorithm>
#include <assert.h>
using namespace std;
| vector<pair<string, int>> func0(const string &text, int n) {
unordered_map<string, int> word_count;
regex word_regex("\\w+");
auto words_begin = sregex_iterator(text.begin(), text.end(), word_regex);
auto words_end = sregex_iterator();
for (sregex_iterator i = words_begin; i != words_end; ++i... | int main() {
assert((func0("python is a programming language", 1) == vector<pair<string, int>>{{"a", 1}}));
assert((func0("python is a programming language", 2) == vector<pair<string, int>>{{"a", 1}, {"is", 1}}));
assert((func0("python is a programming language", 5) == vector<pair<string, int>>{{"a", 1},... | O3 | cpp | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_str... | _ZSt16__insertion_sortIN9__gnu_cxx17__normal_iteratorIPSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESt6vectorIS9_SaIS9_EEEENS0_5__ops15_Iter_comp_iterIZ5func0RKS8_iEUlRKS9_SK_E_EEEvT_SN_T0__isra_0:
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov [rsp+88h... | unsigned long long std::__insertion_sort<__gnu_cxx::__normal_iterator<std::pair<std::string,int> *,std::vector<std::pair<std::string,int>>>,__gnu_cxx::__ops::_Iter_comp_iter<func0(std::string const&,int)::{lambda(std::pair<std::string,int> const&,std::pair<std::string,int> const&)#1}>>(
_DWORD *a1,
_DW... | __insertion_sort<__normal_iterator<std::pair<std::string,int>*,std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>>>,__ops::_Iter_comp_iter<func0(std::string_const&,int)::{lambda(std::pair<std::string,int>const&,std::pair<std::string,int>const&)#1}>>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PU... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__insertion_sort<__normal_iterator<std::pair<std::string, int>*,
std::vector<std::pair<std::string, int>, std::allocator<std::pair<std::string, int> > > >,
__ops::_Iter_comp_iter<func0(std::string const&, int)::{lambda(std::... |
3,448 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(std::vector<int>& arr, int n) {
int ans = 0;
int count = 0;
std::sort(arr.begin(), arr.end());
std::vector<int> v;
v.push_back(arr[0]);
for (int i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
v.push_back(arr[i]);
}
}
for (int i = 0; i < ... | int main() {
std::vector<int> arr1 = {1, 2, 2, 3};
std::vector<int> arr2 = {1, 9, 3, 10, 4, 20, 2};
std::vector<int> arr3 = {36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 7) == 4);
assert(func0(arr3, 11) == 5);
std::cout << "All tests... | O0 | cpp | func0(std::vector<int, std::allocator<int> >&, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x40(%rbp)
movl $0x0,-0x3c(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
c... | _Z5func0RSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_40], 0
mov [rbp+var_3C], 0
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vecto... | long long func0(long long a1, int a2)
{
long long v2; // rbx
long long v3; // rax
long long v4; // rax
int v5; // ebx
long long v6; // rax
int v7; // ebx
int v9; // eax
unsigned int v10; // ebx
unsigned int v12; // [rsp+10h] [rbp-40h] BYREF
int v13; // [rsp+14h] [rbp-3Ch] BYREF
int i; // [rsp+18h... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00101938
MO... | /* func0(std::vector<int, std::allocator<int> >&, int) */
int func0(vector *param_1,int param_2)
{
int iVar1;
bool bVar2;
__normal_iterator _Var3;
__normal_iterator _Var4;
int iVar5;
int *piVar6;
long in_FS_OFFSET;
int local_48;
int local_44;
int local_40;
int local_3c;
vector<int,std::allocat... |
3,449 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(std::vector<int>& arr, int n) {
int ans = 0;
int count = 0;
std::sort(arr.begin(), arr.end());
std::vector<int> v;
v.push_back(arr[0]);
for (int i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
v.push_back(arr[i]);
}
}
for (int i = 0; i < ... | int main() {
std::vector<int> arr1 = {1, 2, 2, 3};
std::vector<int> arr2 = {1, 9, 3, 10, 4, 20, 2};
std::vector<int> arr3 = {36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 7) == 4);
assert(func0(arr3, 11) == 5);
std::cout << "All tests... | O1 | cpp | func0(std::vector<int, std::allocator<int> >&, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %rdi,%rbp
mov %esi,%r12d
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov 0x8(%rdi),%rbx
mov (%rdi),%r14
cmp %r14,%rbx
je 1363 <_Z5func0RSt6ve... | _Z5func0RSt6vectorIiSaIiEEi:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 20h
mov r12, rdi
mov ebp, esi
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov r13, [rdi+8]
mov r14, [rdi]
cmp r14, r13
jz loc_1325
mov rbx, r13
sub rbx, r... | long long func0(char **a1, int a2)
{
char *v3; // r13
char *v4; // r14
int v5; // eax
unsigned long long v6; // rax
char *v7; // rbx
int v8; // ecx
char *v9; // rax
int v10; // edx
char *v11; // rsi
long long v12; // rbp
long long v13; // rbx
int v14; // edx
char *v15; // rsi
long long v16;... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV R12,RDI
MOV EBP,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV R13,qword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI]
CMP R14,R13
JZ 0x00101325
MOV RBX,R13
SUB RBX,R14
MOV RDX,RBX
SAR RDX,0x2
MOV EAX,0x40
JZ 0x001012... | /* func0(std::vector<int, std::allocator<int> >&, int) */
int func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7,int8 param_8,int8 param_9)
{
int *piVar1;
int *piVar2;
int *piVar3;
int *piVar4;
uint uVar5;
int iVar6;
int7 in_register_00000009;
_Ite... |
3,450 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(std::vector<int>& arr, int n) {
int ans = 0;
int count = 0;
std::sort(arr.begin(), arr.end());
std::vector<int> v;
v.push_back(arr[0]);
for (int i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
v.push_back(arr[i]);
}
}
for (int i = 0; i < ... | int main() {
std::vector<int> arr1 = {1, 2, 2, 3};
std::vector<int> arr2 = {1, 9, 3, 10, 4, 20, 2};
std::vector<int> arr3 = {36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 7) == 4);
assert(func0(arr3, 11) == 5);
std::cout << "All tests... | O2 | cpp | func0(std::vector<int, std::allocator<int> >&, int):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %esi,%ebx
sub $0x20,%rsp
mov 0x8(%rdi),%r13
mov (%rdi),%r14
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
cmp %r14,%r13
je 1670 <_Z5func0RSt6vec... | _Z5func0RSt6vectorIiSaIiEEi:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov ebx, esi
sub rsp, 20h
mov r13, [rdi+8]
mov r14, [rdi]
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
cmp r14, r13
jz loc_1A10
mov r12, r13
mov rdx, 0... | long long func0(char **a1, unsigned int a2)
{
long long v3; // rbx
char *v4; // r13
char *v5; // r14
long long v6; // rdx
unsigned long long v7; // rax
char *v8; // rdi
int v9; // ecx
int v10; // edx
char *v11; // rsi
char *v12; // rax
char *v13; // rsi
char *v14; // rdi
long long v15; // r13... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV EBX,ESI
SUB RSP,0x20
MOV R13,qword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CMP R14,R13
JZ 0x00101a10
MOV R12,R13
MOV RDX,-0x2
SUB R12,R14
MOV RAX,R12
SAR RAX,0x2
JZ 0x001019... | /* func0(std::vector<int, std::allocator<int> >&, int) */
int func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int8 param_8,int8 param_9)
{
int *piVar1;
ulong uVar2;
int7 in_register_00000009;
_Iter_less_iter extraout_EDX;
int iVar3;
long lVar4;
int... |
3,451 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(std::vector<int>& arr, int n) {
int ans = 0;
int count = 0;
std::sort(arr.begin(), arr.end());
std::vector<int> v;
v.push_back(arr[0]);
for (int i = 1; i < n; i++) {
if (arr[i] != arr[i - 1]) {
v.push_back(arr[i]);
}
}
for (int i = 0; i < ... | int main() {
std::vector<int> arr1 = {1, 2, 2, 3};
std::vector<int> arr2 = {1, 9, 3, 10, 4, 20, 2};
std::vector<int> arr3 = {36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42};
assert(func0(arr1, 4) == 3);
assert(func0(arr2, 7) == 4);
assert(func0(arr3, 11) == 5);
std::cout << "All tests... | O3 | cpp | func0(std::vector<int, std::allocator<int> >&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %esi,%r12d
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x38,%rsp
mov 0x8(%rdi),%r15
mov (%rdi),%r14
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
cmp %r14,%r15
je 16a0 <_Z... | _Z5func0RSt6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov ebx, esi
sub rsp, 38h
mov r15, [rdi+8]
mov r13, [rdi]
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
cmp r13, r15
jz loc_198C
mov r14, r15
le... | long long func0(char **a1, unsigned int a2)
{
long long v3; // rbx
char *v4; // r15
char *j; // r13
char *v6; // r12
unsigned long long v7; // rdx
char *v8; // r14
int v9; // ecx
char *v10; // rsi
int v11; // edx
char *i; // rax
int v13; // ecx
int v14; // edx
char *v15; // rax
char *v16; /... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV EBX,ESI
SUB RSP,0x38
MOV R15,qword ptr [RDI + 0x8]
MOV R13,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CMP R13,R15
JZ 0x0010198c
MOV R14,R15
LEA R12,[R13 + 0x4]
SUB R14,R13
MOV RAX,R14
SAR RAX... | /* func0(std::vector<int, std::allocator<int> >&, int) */
int func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,int param_10,
int4 param_11,int1 param_12 [16],int8 param_13,int8 param_14)
{
ulong uVar1;
int *piVar2;
_Iter_les... |
3,452 | func0 |
#include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::string> func0(const std::vector<std::string>& texts) {
std::vector<std::string> result;
for (const auto& text : texts) {
std::string reversedText = text;
std::reverse(reversedText.begin(), reversedText.end());
if (text == reversedText) {
result.push_bac... | int main() {
assert((func0({"php", "res", "Python", "abcd", "Java", "aaa"}) == std::vector<std::string>{"php", "aaa"}));
assert((func0({"abcd", "Python", "abba", "aba"}) == std::vector<std::string>{"abba", "aba"}));
assert((func0({"abcd", "abbccbba", "abba", "aba"}) == std::vector<std::string>{"abbccbba"... | O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_68]
mov rdi, rax
call _ZNSt6... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
long long v5; // [rsp+10h] [rbp-60h] BYREF
_QWORD v6[2]; // [rsp+18h] [rbp-58h] BYREF
long long v7; // [rsp+28h] [rbp-48h]
_BYTE v8[40]; // [rsp+30h] [rbp-40h] BYREF
unsigned long long v9; // [rsp+58h] [rbp-18h]
v9... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
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 0x001031b2
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x50],RAX
MO... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
bool bVar1;
int8 uVar2;
int8 uVar3;
vector<std::string,std::allocator<std::string>> *in_RSI;
long in_FS_OFFSET;
int8 local_68;
int8 local_60;
vector<std::string,std::allocator<std::string>> *l... |
3,453 | func0 |
#include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::string> func0(const std::vector<std::string>& texts) {
std::vector<std::string> result;
for (const auto& text : texts) {
std::string reversedText = text;
std::reverse(reversedText.begin(), reversedText.end());
if (text == reversedText) {
result.push_bac... | int main() {
assert((func0({"php", "res", "Python", "abcd", "Java", "aaa"}) == std::vector<std::string>{"php", "aaa"}));
assert((func0({"abcd", "Python", "abba", "aba"}) == std::vector<std::string>{"abba", "aba"}));
assert((func0({"abcd", "abbccbba", "abba", "aba"}) == std::vector<std::string>{"abbccbba"... | O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov %rdi,%r12
mov %fs... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 30h
mov r12, rdi
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword... | _QWORD * func0(_QWORD *a1, const void ***a2)
{
const void **v3; // rbx
const void **v4; // r13
char *v5; // rdx
char *v6; // rax
char v7; // cl
size_t v8; // rdx
_QWORD *v9; // rdi
void *s2; // [rsp+0h] [rbp-58h] BYREF
long long v12; // [rsp+8h] [rbp-50h]
_QWORD v13[9]; // [rsp+10h] [rbp-48h] BYREF
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBX,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
CMP R13,RBX
JZ 0x00101475... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
int uVar1;
string *psVar2;
size_t __n;
int iVar3;
long *plVar4;
long *plVar5;
string *psVar6;
int8 *in_RSI;
long in_FS_OFFSET;
long *local_58;
size_t local_50;
long local_48 [3];
lon... |
3,454 | func0 |
#include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::string> func0(const std::vector<std::string>& texts) {
std::vector<std::string> result;
for (const auto& text : texts) {
std::string reversedText = text;
std::reverse(reversedText.begin(), reversedText.end());
if (text == reversedText) {
result.push_bac... | int main() {
assert((func0({"php", "res", "Python", "abcd", "Java", "aaa"}) == std::vector<std::string>{"php", "aaa"}));
assert((func0({"abcd", "Python", "abba", "aba"}) == std::vector<std::string>{"abba", "aba"}));
assert((func0({"abcd", "abbccbba", "abba", "aba"}) == std::vector<std::string>{"abbccbba"... | O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x48,%rs... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups ... | long long func0(long long a1, const void ***a2)
{
const void **v3; // r13
const void **i; // rbx
_QWORD *v5; // r15
long long v6; // rcx
char *v7; // rax
char *v8; // rdx
char v9; // cl
char v10; // si
size_t v11; // rdx
int v13; // eax
_QWORD *v14; // rdi
const void *v15; // [rsp+0h] [rbp-70h]... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV R13,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
CMP R13,RBX
JZ 0x00101c00... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
int uVar1;
string *psVar2;
size_t __n;
int iVar3;
long *plVar4;
long *plVar5;
size_t sVar6;
long *plVar7;
long *plVar8;
string *psVar9;
long *in_RSI;
long *plVar10;
long in_FS_OFFSET... |
3,455 | func0 |
#include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::string> func0(const std::vector<std::string>& texts) {
std::vector<std::string> result;
for (const auto& text : texts) {
std::string reversedText = text;
std::reverse(reversedText.begin(), reversedText.end());
if (text == reversedText) {
result.push_bac... | int main() {
assert((func0({"php", "res", "Python", "abcd", "Java", "aaa"}) == std::vector<std::string>{"php", "aaa"}));
assert((func0({"abcd", "Python", "abba", "aba"}) == std::vector<std::string>{"abba", "aba"}));
assert((func0({"abcd", "abbccbba", "abba", "aba"}) == std::vector<std::string>{"abbccbba"... | O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %r... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
lea ... | long long func0(long long a1, long long *a2)
{
long long v3; // r15
long long v4; // rbx
size_t v5; // rbp
_BYTE *v6; // r12
_QWORD *v7; // rax
_QWORD *v8; // rbp
size_t v9; // rdx
char *v10; // rax
char *v11; // rdx
char v12; // cl
char v13; // si
size_t v14; // r12
long long *v16; // rbp
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
LEA RAX,[RSP + 0x30]
LEA R14,[RSP + 0x40]
MOV qword ptr [RDI + 0x10],0x0
MOV R15,qword ptr [RSI + 0x8]
MOV RBX... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
int uVar1;
string *psVar2;
int *puVar3;
int iVar4;
ulong *puVar5;
ulong *puVar6;
ulong *puVar7;
ulong *puVar8;
ulong uVar9;
string *psVar10;
ulong *puVar11;
int8 *in_RSI;
size_t __n;... |
3,456 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> nums, int n) {
std::vector<int> result;
for (int num : nums) {
result.push_back(n * num);
}
return result;
}
| int main() {
std::vector<int> arr1 = {1, 2, 3, 4, 5, 6, 7};
std::vector<int> res1 = {3, 6, 9, 12, 15, 18, 21};
std::vector<int> res2 = {4, 8, 12, 16, 20, 24, 28};
std::vector<int> res3 = {10, 20, 30, 40, 50, 60, 70};
assert(func0(arr1, 3) == res1);
assert(func0(arr1, 4) == res2);
asse... | O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %edx,-0x54(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 1912 <_ZNSt6vectorI... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov [rbp+var_54], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vec... | long long func0(long long a1, long long a2, int a3)
{
int v5; // [rsp+28h] [rbp-38h] BYREF
int v6; // [rsp+2Ch] [rbp-34h]
long long v7; // [rsp+30h] [rbp-30h] BYREF
_QWORD v8[4]; // [rsp+38h] [rbp-28h] BYREF
v8[2] = __readfsqword(0x28u);
std::vector<int>::vector(a1);
v8[1] = a2;
v7 = std::vector<int>:... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV dword ptr [RBP + -0x54],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x0010197c
MOV RAX,qword ptr [RBP + -0x50]
MO... | /* func0(std::vector<int, std::allocator<int> >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
bool bVar1;
int *piVar2;
int in_EDX;
int4 in_register_00000034;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_40;
int local_... |
3,457 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> nums, int n) {
std::vector<int> result;
for (int num : nums) {
result.push_back(n * num);
}
return result;
}
| int main() {
std::vector<int> arr1 = {1, 2, 3, 4, 5, 6, 7};
std::vector<int> res1 = {3, 6, 9, 12, 15, 18, 21};
std::vector<int> res2 = {4, 8, 12, 16, 20, 24, 28};
std::vector<int> res3 = {10, 20, 30, 40, 50, 60, 70};
assert(func0(arr1, 3) == res1);
assert(func0(arr1, 4) == res2);
asse... | O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbp
mov 0x8(%rsi),%r13
... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rbp, [rsi]
mov r13, [rsi... | _QWORD * func0(_QWORD *a1, long long a2, int a3)
{
_DWORD *v3; // rbp
_DWORD *v4; // r13
int v6; // eax
int *v7; // rsi
int v9; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v10; // [rsp+8h] [rbp-30h]
v10 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v3 = *(_DWORD **)a2;
v4 = *(... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBP,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
CMP R13,RBP
JZ 0x00101317
... | /* func0(std::vector<int, std::allocator<int> >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
int *piVar1;
int *piVar2;
int in_EDX;
int *piVar3;
int4 in_register_00000034;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_... |
3,458 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> nums, int n) {
std::vector<int> result;
for (int num : nums) {
result.push_back(n * num);
}
return result;
}
| int main() {
std::vector<int> arr1 = {1, 2, 3, 4, 5, 6, 7};
std::vector<int> res1 = {3, 6, 9, 12, 15, 18, 21};
std::vector<int> res2 = {4, 8, 12, 16, 20, 24, 28};
std::vector<int> res3 = {10, 20, 30, 40, 50, 60, 70};
assert(func0(arr1, 3) == res1);
assert(func0(arr1, 4) == res2);
asse... | O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbx
mov 0x8(%rsi),%r15
cmp %r15,%rbx
je 17d7 <_Z5func0St6vectorI... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov r13, [rsi+8]
c... | long long func0(long long a1, long long a2, int a3)
{
_DWORD *v3; // rbx
_DWORD *v4; // r13
int *v6; // rsi
int *i; // rdx
int v8; // eax
int v10; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+4h] [rbp-30h]
v11 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RBX,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
CMP R13,RBX
JZ 0x001016f0
MOV R12D,... | /* func0(std::vector<int, std::allocator<int> >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
int *piVar1;
int in_EDX;
int *piVar2;
int *piVar3;
int4 in_register_00000034;
int *piVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSE... |
3,459 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> nums, int n) {
std::vector<int> result;
for (int num : nums) {
result.push_back(n * num);
}
return result;
}
| int main() {
std::vector<int> arr1 = {1, 2, 3, 4, 5, 6, 7};
std::vector<int> res1 = {3, 6, 9, 12, 15, 18, 21};
std::vector<int> res2 = {4, 8, 12, 16, 20, 24, 28};
std::vector<int> res3 = {10, 20, 30, 40, 50, 60, 70};
assert(func0(arr1, 3) == res1);
assert(func0(arr1, 4) == res2);
asse... | O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov 0x8(%rsi),%r14
mov (%rsi),%rbx
cmp %r14,%rbx
je 177b <_Z5func0St6vectorIiS... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov r14, [rsi+8]
mov rbx, [rsi]
cmp r14, rbx
jz loc_1734
mov r13d, edx
xor ... | long long func0(long long a1, long long a2, int a3)
{
_DWORD *v4; // r14
_DWORD *v5; // rbx
char *v7; // r8
char *v8; // rcx
int v9; // r12d
signed long long v10; // r15
unsigned long long v11; // rax
unsigned long long v12; // rdx
char *v13; // r9
char *v15; // rax
unsigned long long v16; // rsi... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV R14,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
CMP R14,RBX
JZ 0x00101734
MOV R13D,EDX
XOR R8D,R8D
XOR ECX,ECX
JMP 0x001016a8
LAB_00101690:
MOV ... | /* func0(std::vector<int, std::allocator<int> >, int) */
int (*) [16] func0(vector param_1,int param_2)
{
int iVar1;
int *piVar2;
int *__src;
ulong uVar3;
void *__dest;
int (*pauVar4) [16];
int *piVar5;
int in_EDX;
int *piVar6;
int iVar7;
int4 in_register_00000034;
int8 *puVar8;
vector vVar9... |
3,460 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| bool func0(const std::string& monthname2) {
if (monthname2 == "January" || monthname2 == "March" || monthname2 == "May" ||
monthname2 == "July" || monthname2 == "Augest" || monthname2 == "October" ||
monthname2 == "December") {
return true;
} else {
return false;
}
... | int main() {
assert(func0("February") == false);
assert(func0("January") == true);
assert(func0("March") == true);
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov -0x8(%rbp),%rax
lea 0xbe4(%rip),%rsi
mov %rax,%rdi
callq 1829 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_E... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
lea rdx, aJanuary; "January"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_;... | _BOOL8 func0(long long a1)
{
return (unsigned __int8)std::operator==<char>(a1, "January")
|| (unsigned __int8)std::operator==<char>(a1, "March")
|| (unsigned __int8)std::operator==<char>(a1, "May")
|| (unsigned __int8)std::operator==<char>(a1, "July")
|| (unsigned __int8)std::operator==<char>... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018a2
TEST AL,AL
JNZ 0x00101437
MOV RAX,qword ptr [RBP + -0x8]
LEA RDX,[0x102010]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018a2
TEST AL,AL
JNZ 0x00101437
MOV RAX,... | /* func0(std::string const&) */
int func0(string *param_1)
{
int uVar1;
bool bVar2;
bVar2 = std::operator==(param_1,"January");
if ((((bVar2) || (bVar2 = std::operator==(param_1,"March"), bVar2)) ||
(bVar2 = std::operator==(param_1,"May"), bVar2)) ||
(((bVar2 = std::operator==(param_1,"July"), b... |
3,461 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| bool func0(const std::string& monthname2) {
if (monthname2 == "January" || monthname2 == "March" || monthname2 == "May" ||
monthname2 == "July" || monthname2 == "Augest" || monthname2 == "October" ||
monthname2 == "December") {
return true;
} else {
return false;
}
... | int main() {
assert(func0("February") == false);
assert(func0("January") == true);
assert(func0("March") == true);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbx
mov %rdi,%rbx
lea 0xdac(%rip),%rsi
callq 10d0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
mov %eax,%edx
mov $0x1,%eax
test %edx,%edx
jne 126a <_Z5func0RKNSt7_... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbx
mov rbx, rdi
mov rax, [rdi+8]
cmp rax, 7
jz short loc_1272
cmp rax, 5
jz short loc_1291
cmp rax, 3
jz short loc_12AC
cmp rax, 4
jz short loc_12C7
cmp rax, 6
jz loc_12E2
cmp rax, 7... | bool func0(long long a1)
{
long long v1; // rax
v1 = *(_QWORD *)(a1 + 8);
switch ( v1 )
{
case 7LL:
return !memcmp(*(const void **)a1, "January", 7uLL) || memcmp(*(const void **)a1, "October", 7uLL) == 0;
case 5LL:
return memcmp(*(const void **)a1, "March", 5uLL) == 0;
case 3LL:
... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x8]
CMP RAX,0x7
JZ 0x00101272
CMP RAX,0x5
JZ 0x00101291
CMP RAX,0x3
JZ 0x001012ac
CMP RAX,0x4
JZ 0x001012c7
CMP RAX,0x6
JZ 0x001012e2
CMP RAX,0x7
JZ 0x001012fd
CMP RAX,0x8
JZ 0x0010131b
MOV EAX,0x0
JMP 0x0010128f
LAB_00101272:
MOV RDI,qword ptr [RDI]
MOV EDX... | /* func0(std::string const&) */
int8 func0(string *param_1)
{
long lVar1;
int iVar2;
int4 extraout_var;
int4 extraout_var_00;
int4 extraout_var_01;
int4 extraout_var_02;
int4 extraout_var_03;
int4 extraout_var_04;
lVar1 = *(long *)(param_1 + 8);
if (lVar1 == 7) {
iVar2 = memcmp(*(void **)pa... |
3,462 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| bool func0(const std::string& monthname2) {
if (monthname2 == "January" || monthname2 == "March" || monthname2 == "May" ||
monthname2 == "July" || monthname2 == "Augest" || monthname2 == "October" ||
monthname2 == "December") {
return true;
} else {
return false;
}
... | int main() {
assert(func0("February") == false);
assert(func0("January") == true);
assert(func0("March") == true);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
lea 0xc08(%rip),%rsi
mov %rdi,%rbp
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1410 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_tra... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
cmp rax, 7
jz short loc_1370
cmp rax, 5
jnz short loc_1350
mov rax, [rdi]
cmp dword ptr [rax], 6372614Dh
jz short loc_13A8
loc_133F:
mov eax, 1
loc_1344:
test eax, eax
setz al
retn
loc_13... | char func0(_QWORD *a1)
{
long long v1; // rax
int v2; // eax
_DWORD *v4; // rax
v1 = a1[1];
switch ( v1 )
{
case 7LL:
v4 = (_DWORD *)*a1;
if ( *(_DWORD *)*a1 != 1970168138 || *(_DWORD *)((char *)v4 + 3) != 2037539189 )
{
if ( *v4 == 1869898575 && *(_DWORD *)((char *)v4 + 3) =... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
CMP RAX,0x7
JZ 0x00101370
CMP RAX,0x5
JNZ 0x00101350
MOV RAX,qword ptr [RDI]
CMP dword ptr [RAX],0x6372614d
JZ 0x001013a8
LAB_0010133f:
MOV EAX,0x1
LAB_00101344:
TEST EAX,EAX
SETZ AL
RET
LAB_00101350:
CMP RAX,0x3
JNZ 0x00101390
MOV RAX,qword ptr [RDI]
CMP word ptr [RAX],0x61... | /* func0(std::string const&) */
ulong func0(string *param_1)
{
long lVar1;
int *piVar2;
bool bVar3;
lVar1 = *(long *)(param_1 + 8);
if (lVar1 == 7) {
piVar2 = *(int **)param_1;
if ((*piVar2 == 0x756e614a) && (*(int *)((long)piVar2 + 3) == 0x79726175)) {
return 1;
}
if ((*piVar2 == 0... |
3,463 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| bool func0(const std::string& monthname2) {
if (monthname2 == "January" || monthname2 == "March" || monthname2 == "May" ||
monthname2 == "July" || monthname2 == "Augest" || monthname2 == "October" ||
monthname2 == "December") {
return true;
} else {
return false;
}
... | int main() {
assert(func0("February") == false);
assert(func0("January") == true);
assert(func0("March") == true);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
lea 0xc08(%rip),%rsi
mov %rdi,%rbp
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1410 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_tra... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
cmp rax, 7
jz short loc_1370
cmp rax, 5
jnz short loc_1350
mov rax, [rdi]
cmp dword ptr [rax], 6372614Dh
jz short loc_13A8
loc_133F:
mov eax, 1
loc_1344:
test eax, eax
setz al
retn
loc_13... | char func0(_QWORD *a1)
{
long long v1; // rax
int v2; // eax
_DWORD *v4; // rax
v1 = a1[1];
switch ( v1 )
{
case 7LL:
v4 = (_DWORD *)*a1;
if ( *(_DWORD *)*a1 != 1970168138 || *(_DWORD *)((char *)v4 + 3) != 2037539189 )
{
if ( *v4 == 1869898575 && *(_DWORD *)((char *)v4 + 3) =... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
CMP RAX,0x7
JZ 0x00101370
CMP RAX,0x5
JNZ 0x00101350
MOV RAX,qword ptr [RDI]
CMP dword ptr [RAX],0x6372614d
JZ 0x001013a8
LAB_0010133f:
MOV EAX,0x1
LAB_00101344:
TEST EAX,EAX
SETZ AL
RET
LAB_00101350:
CMP RAX,0x3
JNZ 0x00101390
MOV RAX,qword ptr [RDI]
CMP word ptr [RAX],0x61... | /* func0(std::string const&) */
ulong func0(string *param_1)
{
long lVar1;
int *piVar2;
bool bVar3;
lVar1 = *(long *)(param_1 + 8);
if (lVar1 == 7) {
piVar2 = *(int **)param_1;
if ((*piVar2 == 0x756e614a) && (*(int *)((long)piVar2 + 3) == 0x79726175)) {
return 1;
}
if ((*piVar2 == 0... |
3,464 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int arr[], int n) {
int odd = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] % 2) {
odd += 1;
}
}
if (odd % 2) {
return 1;
}
return 2;
}
| int main() {
int arr1[9] = {1,2,3,4,5,6,7,8,9};
assert(func0(arr1, 9) == 1);
int arr2[8] = {1,2,3,4,5,6,7,8};
assert(func0(arr2, 8) == 2);
int arr3[3] = {1,2,3};
assert(func0(arr3, 3) == 2);
return 0;
}
| O0 | cpp | func0(int*, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jge 11f5 <_Z5func0Pii+0x4c>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax... | _Z5func0Pii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11AD
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test ... | long long func0(int *a1, int a2)
{
char v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (a1[i] & 1) != 0 )
++v3;
}
if ( (v3 & 1) != 0 )
return 1LL;
else
return 2LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011ad
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX... | /* func0(int*, int) */
int8 func0(int *param_1,int param_2)
{
byte bVar1;
int8 uVar2;
int local_c;
bVar1 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((param_1[local_c] & 1U) != 0) {
bVar1 = bVar1 + 1;
}
}
if ((bool)(bVar1 & 1)) {
uVar2 = 1;
}
else {
... |
3,465 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int arr[], int n) {
int odd = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] % 2) {
odd += 1;
}
}
if (odd % 2) {
return 1;
}
return 2;
}
| int main() {
int arr1[9] = {1,2,3,4,5,6,7,8,9};
assert(func0(arr1, 9) == 1);
int arr2[8] = {1,2,3,4,5,6,7,8};
assert(func0(arr2, 8) == 2);
int arr3[3] = {1,2,3};
assert(func0(arr3, 3) == 2);
return 0;
}
| O1 | cpp | func0(int*, int):
endbr64
test %esi,%esi
jle 11e0 <_Z5func0Pii+0x37>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rsi
mov $0x0,%ecx
mov (%rax),%edx
and $0x1,%edx
cmp $0x1,%edx
sbb $0xffffffff,%ecx
add $0x4,%rax
cmp %rsi,%rax
jne 11c1 <_Z5func0Pii+0x18>
and $0x1,%ecx
m... | _Z5func0Pii:
endbr64
test esi, esi
jle short loc_119F
mov rax, rdi
movsxd rsi, esi
lea rsi, [rdi+rsi*4]
mov ecx, 0
loc_1180:
mov edx, [rax]
and edx, 1
cmp edx, 1
sbb ecx, 0FFFFFFFFh
add rax, 4
cmp rax, rsi
jnz short loc_1180
loc_1194:
and ecx, 1
mov eax, 2
sub ... | long long func0(int *a1, int a2)
{
int *v2; // rax
int *v3; // rsi
char v4; // cl
if ( a2 <= 0 )
{
v4 = 0;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 0;
do
v4 -= ((*v2++ & 1) == 0) - 1;
while ( v2 != v3 );
}
return 2 - (v4 & 1u);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119f
MOV RAX,RDI
MOVSXD RSI,ESI
LEA RSI,[RDI + RSI*0x4]
MOV ECX,0x0
LAB_00101180:
MOV EDX,dword ptr [RAX]
AND EDX,0x1
CMP EDX,0x1
SBB ECX,-0x1
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101180
LAB_00101194:
AND ECX,0x1
MOV EAX,0x2
SUB EAX,ECX
RET
LAB_0010119f:
MOV ECX,0x0
JMP 0x00101194 | /* func0(int*, int) */
int func0(int *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
if (param_2 < 1) {
uVar2 = 0;
}
else {
puVar1 = (uint *)(param_1 + param_2);
uVar2 = 0;
do {
uVar2 = (uVar2 + 1) - (uint)((*param_1 & 1U) == 0);
param_1 = (int *)((uint *)param_1 + 1);
}... |
3,466 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int arr[], int n) {
int odd = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] % 2) {
odd += 1;
}
}
if (odd % 2) {
return 1;
}
return 2;
}
| int main() {
int arr1[9] = {1,2,3,4,5,6,7,8,9};
assert(func0(arr1, 9) == 1);
int arr2[8] = {1,2,3,4,5,6,7,8};
assert(func0(arr2, 8) == 2);
int arr3[3] = {1,2,3};
assert(func0(arr3, 3) == 2);
return 0;
}
| O2 | cpp | func0(int*, int):
endbr64
test %esi,%esi
jle 1390 <_Z5func0Pii+0x40>
lea -0x1(%rsi),%eax
xor %edx,%edx
lea 0x4(%rdi,%rax,4),%rcx
nopw 0x0(%rax,%rax,1)
mov (%rdi),%eax
and $0x1,%eax
cmp $0x1,%eax
sbb $0xffffffff,%edx
add $0x4,%rdi
cmp %rdi,%rcx
jne 1368 <_Z5func0Pii+0x18>
and $0x1... | _Z5func0Pii:
endbr64
test esi, esi
jle short loc_12C0
movsxd rsi, esi
xor edx, edx
lea rcx, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_1298:
mov eax, [rdi]
and eax, 1
cmp eax, 1
sbb edx, 0FFFFFFFFh
add rdi, 4
cmp rcx, rdi
jnz short loc_1298
and edx, 1
mov eax, ... | long long func0(int *a1, int a2)
{
char v2; // dl
int *v3; // rcx
if ( a2 <= 0 )
return 2LL;
v2 = 0;
v3 = &a1[a2];
do
v2 -= ((*a1++ & 1) == 0) - 1;
while ( v3 != a1 );
return 2 - (v2 & 1u);
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012c0
MOVSXD RSI,ESI
XOR EDX,EDX
LEA RCX,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101298:
MOV EAX,dword ptr [RDI]
AND EAX,0x1
CMP EAX,0x1
SBB EDX,-0x1
ADD RDI,0x4
CMP RCX,RDI
JNZ 0x00101298
AND EDX,0x1
MOV EAX,0x2
SUB EAX,EDX
RET
LAB_001012c0:
MOV EAX,0x2
RET | /* func0(int*, int) */
int func0(int *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
if (0 < param_2) {
uVar2 = 0;
puVar1 = (uint *)(param_1 + param_2);
do {
uVar2 = (uVar2 + 1) - (uint)((*param_1 & 1U) == 0);
param_1 = (int *)((uint *)param_1 + 1);
} while (puVar1 != (uint *)pa... |
3,467 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int arr[], int n) {
int odd = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] % 2) {
odd += 1;
}
}
if (odd % 2) {
return 1;
}
return 2;
}
| int main() {
int arr1[9] = {1,2,3,4,5,6,7,8,9};
assert(func0(arr1, 9) == 1);
int arr2[8] = {1,2,3,4,5,6,7,8};
assert(func0(arr2, 8) == 2);
int arr3[3] = {1,2,3};
assert(func0(arr3, 3) == 2);
return 0;
}
| O3 | cpp | func0(int*, int):
endbr64
test %esi,%esi
jle 12a8 <_Z5func0Pii+0xe8>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 12ae <_Z5func0Pii+0xee>
mov %esi,%edx
pxor %xmm1,%xmm1
pcmpeqd %xmm2,%xmm2
mov %rdi,%rax
shr $0x2,%edx
movdqa 0xe20(%rip),%xmm4
movdqa %xmm1,%xmm3
shl $0x4,%rdx
add %rdi,%rdx
nopl ... | _Z5func0Pii:
endbr64
mov ecx, esi
test esi, esi
jle loc_1218
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1220
mov edx, esi
pxor xmm1, xmm1
movdqa xmm3, cs:xmmword_2010
mov rax, rdi
shr edx, 2
movdqa xmm2, xmm1
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00000000h]
loc_1180:
mo... | long long func0(const __m128i *a1, int a2)
{
__m128i v2; // xmm1
__m128i si128; // xmm3
const __m128i *v4; // rax
__m128i v5; // xmm0
signed int v6; // edx
__m128i v7; // xmm1
char v8; // al
long long v9; // r8
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 2 )
{
v6 = 0;
v8 = 0... | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101218
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101220
MOV EDX,ESI
PXOR XMM1,XMM1
MOVDQA XMM3,xmmword ptr [0x00102010]
MOV RAX,RDI
SHR EDX,0x2
MOVDQA XMM2,XMM1
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101180:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PAND XMM0,X... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int*, int) */
int func0(int *param_1,int param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint uVar5;
int iVar6;
uint uVar7;
int iVar8;
int iVar9;
int iVar10;
if (param_2 < 1) {
... |
3,468 | func0 |
#include <string>
#include <assert.h>
| int func0(std::string a) {
int l = 0;
std::string x = a;
while(!x.empty() && isspace(x.back())) x.pop_back();
for (int i = 0; i < x.length(); ++i) {
if (x[i] == ' ') {
l = 0;
} else {
l += 1;
}
}
return l;
}
| int main() {
assert(func0("python language") == 8);
assert(func0("PHP") == 3);
assert(func0("") == 0);
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x48(%rbp)
mov -0x58(%rbp),%rdx
lea -0x40(%rbp),%rax
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_48], 0
mov rdx, [rbp+var_58]
lea rax, [rbp+var_40]
mov rsi, rdx
mov rd... | long long func0(long long a1)
{
char *v1; // rax
unsigned int v4; // [rsp+18h] [rbp-48h]
int i; // [rsp+1Ch] [rbp-44h]
_BYTE v6[40]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v7; // [rsp+48h] [rbp-18h]
v7 = __readfsqword(0x28u);
v4 = 0;
std::string::basic_string(v6, a1);
while ( (unsigned __in... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x48],0x0
MOV RDX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
LAB_0010241e:
CALL 0x001021b0
JMP 0x00102431
LAB... | /* func0(std::string) */
int func0(string *param_1)
{
bool bVar1;
char cVar2;
int iVar3;
char *pcVar4;
ulong uVar5;
long in_FS_OFFSET;
int local_50;
int local_4c;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_50 = 0;
std::string::string(local_48,par... |
3,469 | func0 |
#include <string>
#include <assert.h>
| int func0(std::string a) {
int l = 0;
std::string x = a;
while(!x.empty() && isspace(x.back())) x.pop_back();
for (int i = 0; i < x.length(); ++i) {
if (x[i] == ' ') {
l = 0;
} else {
l += 1;
}
}
return l;
}
| int main() {
assert(func0("python language") == 8);
assert(func0("PHP") == 3);
assert(func0("") == 0);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rax
mov %rax,0x10(%rsp)
mov (%rdi),%rbp
mov 0x8(%rdi),%rbx
test %rb... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r12
push rbp
push rbx
sub rsp, 40h
mov rax, fs:28h
mov [rsp+58h+var_20], rax
xor eax, eax
lea rax, [rsp+58h+var_38]
mov [rsp+58h+var_48], rax
mov rbp, [rdi]
mov rbx, [rdi+8]
mov [rsp+58h+var_50], rbx
... | long long func0(long long a1)
{
_BYTE *v1; // rbp
size_t v2; // rbx
size_t v3; // rbx
void *v4; // rdi
unsigned int v5; // ebp
_QWORD *v6; // rdi
_BYTE *v7; // rdx
_BYTE *v9; // rbx
size_t v10; // [rsp+8h] [rbp-50h] BYREF
_QWORD *v11; // [rsp+10h] [rbp-48h] BYREF
size_t v12; // [rsp+18h] [rbp-40h... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV RBP,qword ptr [RDI]
MOV RBX,qword ptr [RDI + 0x8]
MOV qword ptr [RSP + 0x8],RBX
CMP RBX,0xf
JA 0x00101348
CMP RBX,0x1
JNZ 0x0010137e
MOVZX... | /* func0(std::string) */
int func0(int8 *param_1)
{
int *__src;
ulong uVar1;
ulong uVar2;
int iVar3;
ulong *puVar4;
long in_FS_OFFSET;
ulong local_50;
ulong *local_48;
ulong local_40;
ulong local_38 [3];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = local_38;
__sr... |
3,470 | func0 |
#include <string>
#include <assert.h>
| int func0(std::string a) {
int l = 0;
std::string x = a;
while(!x.empty() && isspace(x.back())) x.pop_back();
for (int i = 0; i < x.length(); ++i) {
if (x[i] == ' ') {
l = 0;
} else {
l += 1;
}
}
return l;
}
| int main() {
assert(func0("python language") == 8);
assert(func0("PHP") == 3);
assert(func0("") == 0);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x40,%rsp
mov (%rdi),%r13
mov 0x8(%rdi),%r12
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rbp
mov %r13,%rax
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 40h
mov rbx, [rdi+8]
mov rbp, [rdi]
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
lea r12, [rsp+68h+var_48]
lea r13, [rsp+68h+var_58]
mov ... | long long func0(long long a1)
{
size_t v1; // rbx
_BYTE *v2; // rbp
_QWORD *v3; // rax
size_t v4; // rbx
_BYTE *v5; // rbp
_BYTE *v6; // rax
_BYTE *v7; // rbx
unsigned int v8; // r13d
_QWORD *v10; // rdi
size_t v11; // [rsp+8h] [rbp-60h] BYREF
void *v12; // [rsp+10h] [rbp-58h] BYREF
size_t v13;... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x40
MOV RBX,qword ptr [RDI + 0x8]
MOV RBP,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA R12,[RSP + 0x20]
LEA R13,[RSP + 0x10]
MOV qword ptr [RSP + 0x10],R12
MOV qword ptr [RSP + 0x8],RBX
CMP RBX,0xf
JA 0x00... | /* func0(std::string) */
int func0(int8 *param_1)
{
ulong uVar1;
int *__src;
ulong *puVar2;
int iVar3;
ulong *puVar4;
long in_FS_OFFSET;
ulong local_60;
ulong *local_58;
ulong local_50;
ulong local_48 [3];
long local_30;
uVar1 = param_1[1];
__src = (int *)*param_1;
local_30 = *(long *)(... |
3,471 | func0 |
#include <string>
#include <assert.h>
| int func0(std::string a) {
int l = 0;
std::string x = a;
while(!x.empty() && isspace(x.back())) x.pop_back();
for (int i = 0; i < x.length(); ++i) {
if (x[i] == ' ') {
l = 0;
} else {
l += 1;
}
}
return l;
}
| int main() {
assert(func0("python language") == 8);
assert(func0("PHP") == 3);
assert(func0("") == 0);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x40,%rsp
mov (%rdi),%r13
mov 0x8(%rdi),%r12
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rbp
mov %r13,%rax
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 40h
mov rbx, [rdi+8]
mov rbp, [rdi]
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
lea r12, [rsp+68h+var_48]
lea r13, [rsp+68h+var_58]
mov ... | long long func0(long long a1)
{
size_t v1; // rbx
_BYTE *v2; // rbp
_QWORD *v3; // rax
size_t v4; // rbx
_BYTE *v5; // rbp
_BYTE *v6; // rax
_BYTE *v7; // rbx
unsigned int v8; // r13d
_QWORD *v10; // rdi
size_t v11; // [rsp+8h] [rbp-60h] BYREF
void *v12; // [rsp+10h] [rbp-58h] BYREF
size_t v13;... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x40
MOV RBX,qword ptr [RDI + 0x8]
MOV RBP,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA R12,[RSP + 0x20]
LEA R13,[RSP + 0x10]
MOV qword ptr [RSP + 0x10],R12
MOV qword ptr [RSP + 0x8],RBX
CMP RBX,0xf
JA 0x00... | /* func0(std::string) */
int func0(int8 *param_1)
{
ulong uVar1;
int *__src;
ulong *puVar2;
int iVar3;
ulong *puVar4;
long in_FS_OFFSET;
ulong local_60;
ulong *local_58;
ulong local_50;
ulong local_48 [3];
long local_30;
uVar1 = param_1[1];
__src = (int *)*param_1;
local_30 = *(long *)(... |
3,472 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| std::vector<std::vector<int>> func0(std::vector<std::vector<int>> list1, int leftrange, int rigthrange) {
std::vector<std::vector<int>> result;
for (auto& sublist : list1) {
if (!sublist.empty() && *min_element(sublist.begin(), sublist.end()) >= leftrange && *max_element(sublist.begin(), sublist.end(... | int main() {
assert((func0({{2}, {0}, {1, 2, 3}, {0, 1, 2, 3, 6, 7}, {9, 11}, {13, 14, 15, 17}}, 13, 17) == std::vector<std::vector<int>>{{13, 14, 15, 17}}));
assert((func0({{2}, {0}, {1, 2, 3}, {0, 1, 2, 3, 6, 7}, {9, 11}, {13, 14, 15, 17}}, 1, 3) == std::vector<std::vector<int>>{{2}, {1, 2, 3}}));
asse... | O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %edx,-0x64(%rbp)
mov %ecx,-0x68(%rbp)
mov %fs:0x28,%rax
mov %... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_64], edx
mov [rbp+var_68], ecx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_58]
mov rdi, rax
call... | long long func0(long long a1, long long a2, int a3, int a4)
{
long long v4; // rbx
long long v5; // rax
long long v6; // rbx
long long v7; // rax
long long v12; // [rsp+28h] [rbp-48h] BYREF
long long v13; // [rsp+30h] [rbp-40h] BYREF
long long v14; // [rsp+38h] [rbp-38h] BYREF
_QWORD v15[2]; // [rsp+40... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV dword ptr [RBP + -0x64],EDX
MOV dword ptr [RBP + -0x68],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
CALL 0x00102acc
MO... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int, int) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0(vector param_1,int param_2,int param_3)
{
char cVar1;
bool bVar2;
int8... |
3,473 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| std::vector<std::vector<int>> func0(std::vector<std::vector<int>> list1, int leftrange, int rigthrange) {
std::vector<std::vector<int>> result;
for (auto& sublist : list1) {
if (!sublist.empty() && *min_element(sublist.begin(), sublist.end()) >= leftrange && *max_element(sublist.begin(), sublist.end(... | int main() {
assert((func0({{2}, {0}, {1, 2, 3}, {0, 1, 2, 3, 6, 7}, {9, 11}, {13, 14, 15, 17}}, 13, 17) == std::vector<std::vector<int>>{{13, 14, 15, 17}}));
assert((func0({{2}, {0}, {1, 2, 3}, {0, 1, 2, 3, 6, 7}, {9, 11}, {13, 14, 15, 17}}, 1, 3) == std::vector<std::vector<int>>{{2}, {1, 2, 3}}));
asse... | O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rbp
mov %edx,%r13d
mov %ecx,%r15d
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rbp, rdi
mov r13d, edx
mov r14d, ecx
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rbx, [rsi]
mov r12, [rsi+8]
cmp... | _QWORD * func0(_QWORD *a1, char ***a2, int a3, _DWORD *a4)
{
int v6; // r14d
char **v7; // rbx
char **v8; // r12
_DWORD *v10; // rax
char *v11; // rdx
char *v12; // rdx
_DWORD *v13; // rsi
char *v14; // rdi
char *v15; // r8
_QWORD *v16; // r15
_DWORD *v17; // rax
struct _Unwind_Exception *v18; /... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBP,RDI
MOV R13D,EDX
MOV R14D,ECX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBX,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
CMP R12,RBX
JNZ 0x00101359
LAB_00101307:
MOV RAX,RBP
ADD RSP,... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int, int) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0(vector param_1,int param_2,int param_3)
{
vector *pvVar1;
int *piVar2;
... |
3,474 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| std::vector<std::vector<int>> func0(std::vector<std::vector<int>> list1, int leftrange, int rigthrange) {
std::vector<std::vector<int>> result;
for (auto& sublist : list1) {
if (!sublist.empty() && *min_element(sublist.begin(), sublist.end()) >= leftrange && *max_element(sublist.begin(), sublist.end(... | int main() {
assert((func0({{2}, {0}, {1, 2, 3}, {0, 1, 2, 3, 6, 7}, {9, 11}, {13, 14, 15, 17}}, 13, 17) == std::vector<std::vector<int>>{{13, 14, 15, 17}}));
assert((func0({{2}, {0}, {1, 2, 3}, {0, 1, 2, 3, 6, 7}, {9, 11}, {13, 14, 15, 17}}, 1, 3) == std::vector<std::vector<int>>{{2}, {1, 2, 3}}));
asse... | O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov 0x8(%r... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbp, [rsi+8]
mov rbx, [rsi]
cmp rbp, rbx
jz loc_2186
mov r1... | long long func0(long long a1, char ***a2, int a3, int a4)
{
char **v5; // rbp
char **i; // rbx
char *v9; // rcx
char *v10; // r8
char v11; // r10
int v12; // edi
char *v13; // r9
char *v14; // rdx
int v15; // eax
long long v16; // r15
_DWORD *v17; // rcx
char *v18; // rsi
signed long long v19... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RBP,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
CMP RBP,RBX
JZ 0x00102186
MOV R13D,EDX
MOV R14D,ECX
JMP 0x0010203d
LAB_00102030:
ADD RBX,0x18
CM... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int, int) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0(vector param_1,int param_2,int param_3)
{
vector *pvVar1;
uint *puVar2;
... |
3,475 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| std::vector<std::vector<int>> func0(std::vector<std::vector<int>> list1, int leftrange, int rigthrange) {
std::vector<std::vector<int>> result;
for (auto& sublist : list1) {
if (!sublist.empty() && *min_element(sublist.begin(), sublist.end()) >= leftrange && *max_element(sublist.begin(), sublist.end(... | int main() {
assert((func0({{2}, {0}, {1, 2, 3}, {0, 1, 2, 3, 6, 7}, {9, 11}, {13, 14, 15, 17}}, 13, 17) == std::vector<std::vector<int>>{{13, 14, 15, 17}}));
assert((func0({{2}, {0}, {1, 2, 3}, {0, 1, 2, 3, 6, 7}, {9, 11}, {13, 14, 15, 17}}, 1, 3) == std::vector<std::vector<int>>{{2}, {1, 2, 3}}));
asse... | O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int, int):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov 0x8(%rsi... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbp, [rsi+8]
mov rbx, [rsi]
cmp rbp, rbx
jz loc_2329
mov r1... | long long func0(long long a1, signed int ***a2, signed int a3, signed int a4)
{
signed int **v5; // rbp
signed int **v6; // rbx
signed int *v9; // rsi
signed int *v10; // rdx
signed int *v11; // r11
signed int v12; // r9d
signed int *v13; // r8
unsigned long long v14; // r10
unsigned long long v15; /... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RBP,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
CMP RBP,RBX
JZ 0x00102329
MOV R13D,EDX
MOV R14D,ECX
JMP 0x0010209d
LAB_00102090:
ADD RBX,0x18
CM... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int, int) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0(vector param_1,int param_2,int param_3)
{
uint *puVar1;
vector *pvVar2;
... |
3,476 | func0 |
#include <iostream>
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<int>& nums) {
int total = 0;
for (int num : nums) {
if (num > 0) {
total += num;
}
}
return total;
}
| int main() {
assert(func0({2, 4, -6, -9, 11, -12, 14, -5, 17}) == 48);
assert(func0({10, 15, -14, 13, -18, 12, -20}) == 50);
assert(func0({19, -65, 57, 39, 152, -639, 121, 44, 90, -190}) == 522);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x28(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 16a0 <... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_28], 0
mov rax, [rbp+var_38]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5... | long long func0(long long a1)
{
unsigned int v2; // [rsp+18h] [rbp-28h]
int v3; // [rsp+1Ch] [rbp-24h]
long long v4; // [rsp+20h] [rbp-20h] BYREF
_QWORD v5[3]; // [rsp+28h] [rbp-18h] BYREF
v5[2] = __readfsqword(0x28u);
v2 = 0;
v5[1] = a1;
v4 = std::vector<int>::begin(a1);
v5[0] = std::vector<int>::e... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101660
MOV qword pt... | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
bool bVar1;
int *piVar2;
long in_FS_OFFSET;
int local_30;
int8 local_28;
int8 local_20;
vector<int,std::allocator<int>> *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = 0;
lo... |
3,477 | func0 |
#include <iostream>
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<int>& nums) {
int total = 0;
for (int num : nums) {
if (num > 0) {
total += num;
}
}
return total;
}
| int main() {
assert(func0({2, 4, -6, -9, 11, -12, 14, -5, 17}) == 48);
assert(func0({10, 15, -14, 13, -18, 12, -20}) == 50);
assert(func0({19, -65, 57, 39, 152, -639, 121, 44, 90, -190}) == 522);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdi
cmp %rdi,%rax
je 1274 <_Z5func0RKSt6vectorIiSaIiEE+0x2b>
mov $0x0,%edx
mov (%rax),%ecx
lea (%rdx,%rcx,1),%esi
test %ecx,%ecx
cmovg %esi,%edx
add $0x4,%rax
cmp %rax,%rdi
jne 125e <_Z5func0RK... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rax, [rdi]
mov rdi, [rdi+8]
cmp rdi, rax
jz short loc_1234
mov edx, 0
loc_121E:
mov ecx, [rax]
lea esi, [rdx+rcx]
test ecx, ecx
cmovg edx, esi
add rax, 4
cmp rax, rdi
jnz short loc_121E
loc_1231:
mov eax, edx
retn
loc_1234:
mov ... | long long func0(int **a1)
{
int *v1; // rax
int *v2; // rdi
unsigned int v3; // edx
v1 = *a1;
v2 = a1[1];
if ( v2 == v1 )
{
return 0;
}
else
{
v3 = 0;
do
{
if ( *v1 > 0 )
v3 += *v1;
++v1;
}
while ( v1 != v2 );
}
return v3;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RAX
JZ 0x00101234
MOV EDX,0x0
LAB_0010121e:
MOV ECX,dword ptr [RAX]
LEA ESI,[RDX + RCX*0x1]
TEST ECX,ECX
CMOVG EDX,ESI
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x0010121e
LAB_00101231:
MOV EAX,EDX
RET
LAB_00101234:
MOV EDX,0x0
JMP 0x00101231 | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
int *piVar1;
int iVar2;
piVar1 = *(int **)param_1;
if (*(int **)(param_1 + 8) == piVar1) {
iVar2 = 0;
}
else {
iVar2 = 0;
do {
if (0 < *piVar1) {
iVar2 = iVar2 + *piVar1;
}
piVa... |
3,478 | func0 |
#include <iostream>
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<int>& nums) {
int total = 0;
for (int num : nums) {
if (num > 0) {
total += num;
}
}
return total;
}
| int main() {
assert(func0({2, 4, -6, -9, 11, -12, 14, -5, 17}) == 48);
assert(func0({10, 15, -14, 13, -18, 12, -20}) == 50);
assert(func0({19, -65, 57, 39, 152, -639, 121, 44, 90, -190}) == 522);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rsi
xor %r8d,%r8d
cmp %rsi,%rax
je 153d <_Z5func0RKSt6vectorIiSaIiEE+0x2d>
nopl 0x0(%rax,%rax,1)
mov (%rax),%edx
test %edx,%edx
lea (%r8,%rdx,1),%ecx
cmovg %ecx,%r8d
add $0x4,%rax
cmp %rax,%rsi
... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rax, [rdi]
mov rdi, [rdi+8]
xor edx, edx
cmp rdi, rax
jz short loc_143B
nop word ptr [rax+rax+00h]
loc_1428:
mov ecx, [rax]
test ecx, ecx
lea esi, [rdx+rcx]
cmovg edx, esi
add rax, 4
cmp rdi, rax
jnz short loc_1428
loc_143B:
mov ... | long long func0(int **a1)
{
int *v1; // rax
int *v2; // rdi
unsigned int i; // edx
v1 = *a1;
v2 = a1[1];
for ( i = 0; v2 != v1; ++v1 )
{
if ( *v1 > 0 )
i += *v1;
}
return i;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
XOR EDX,EDX
CMP RDI,RAX
JZ 0x0010143b
NOP word ptr [RAX + RAX*0x1]
LAB_00101428:
MOV ECX,dword ptr [RAX]
TEST ECX,ECX
LEA ESI,[RDX + RCX*0x1]
CMOVG EDX,ESI
ADD RAX,0x4
CMP RDI,RAX
JNZ 0x00101428
LAB_0010143b:
MOV EAX,EDX
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
int *piVar1;
int iVar2;
iVar2 = 0;
for (piVar1 = *(int **)param_1; *(int **)(param_1 + 8) != piVar1; piVar1 = piVar1 + 1) {
if (0 < *piVar1) {
iVar2 = iVar2 + *piVar1;
}
}
return iVar2;
} |
3,479 | func0 |
#include <iostream>
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<int>& nums) {
int total = 0;
for (int num : nums) {
if (num > 0) {
total += num;
}
}
return total;
}
| int main() {
assert(func0({2, 4, -6, -9, 11, -12, 14, -5, 17}) == 48);
assert(func0({10, 15, -14, 13, -18, 12, -20}) == 50);
assert(func0({19, -65, 57, 39, 152, -639, 121, 44, 90, -190}) == 522);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rdi
cmp %rdi,%rdx
je 1770 <_Z5func0RKSt6vectorIiSaIiEE+0xd0>
lea -0x4(%rdi),%rcx
mov %rdx,%rax
sub %rdx,%rcx
mov %rcx,%rsi
shr $0x2,%rsi
add $0x1,%rsi
cmp $0x8,%rcx
jbe 1779 <_Z5func0RKSt6ve... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rdx, [rdi]
mov rdi, [rdi+8]
cmp rdi, rdx
jz loc_16F0
lea rcx, [rdi-4]
mov rax, rdx
sub rcx, rdx
mov rsi, rcx
shr rsi, 2
add rsi, 1
cmp rcx, 8
jbe loc_16F9
mov rcx, rsi
pxor xmm0, xmm0
shr rcx, 2
movdqa xmm2, xmm0
shl ... | long long func0(const __m128i **a1)
{
const __m128i *v1; // rdx
const __m128i *v2; // rdi
const __m128i *v3; // rax
unsigned long long v4; // rsi
__m128i v5; // xmm0
__m128i v6; // xmm1
__m128i v7; // xmm0
long long result; // rax
int v9; // ecx
int v10; // edx
v1 = *a1;
v2 = a1[1];
if ( v2 ... | func0:
ENDBR64
MOV RDX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RDX
JZ 0x001016f0
LEA RCX,[RDI + -0x4]
MOV RAX,RDX
SUB RCX,RDX
MOV RSI,RCX
SHR RSI,0x2
ADD RSI,0x1
CMP RCX,0x8
JBE 0x001016f9
MOV RCX,RSI
PXOR XMM0,XMM0
SHR RCX,0x2
MOVDQA XMM2,XMM0
SHL RCX,0x4
ADD RCX,RDX
NOP dword ptr [RAX]
LAB_00101670:
MOV... | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
uint uVar6;
uint *puVar7;
uint *puVar8;
uint *puVar9;
uint *puVar10;
ulong uVar11;
uint *puVar12;
ulong uVar13;
int iVar14;
int iVar... |
3,480 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| bool func0(std::string string1, std::string string2) {
int size1 = string1.length();
int size2 = string2.length();
std::string temp;
if (size1 != size2) {
return false;
}
temp = string1 + string1;
if (temp.find(string2) != std::string::npos) {
return true;
... | int main() {
assert(func0("abc", "cba") == false);
assert(func0("abcd", "cdba") == false);
assert(func0("abacd", "cdaba") == true);
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %rsi,-0x80(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_78]
mov rdi, rax
call __ZNKSt7__cxx1112basic_... | _BOOL8 func0(long long a1, long long a2)
{
_BOOL4 v2; // ebx
int v4; // [rsp+18h] [rbp-68h]
int v5; // [rsp+1Ch] [rbp-64h]
_BYTE v6[32]; // [rsp+20h] [rbp-60h] BYREF
_BYTE v7[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+68h] [rbp-18h]
v8 = __readfsqword(0x28u);
v4 = std::string::le... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDI,RAX
CALL 0x001022f0
MOV dword ptr [RBP + -0x68],EAX
MOV RAX,qword ptr [RBP + -0x80]
MO... | /* func0(std::string, std::string) */
int8 func0(int8 param_1,ulong param_2)
{
int iVar1;
int iVar2;
long lVar3;
int8 uVar4;
long in_FS_OFFSET;
string local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = std::string::length();
iVar2 = std::str... |
3,481 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| bool func0(std::string string1, std::string string2) {
int size1 = string1.length();
int size2 = string2.length();
std::string temp;
if (size1 != size2) {
return false;
}
temp = string1 + string1;
if (temp.find(string2) != std::string::npos) {
return true;
... | int main() {
assert(func0("abc", "cba") == false);
assert(func0("abcd", "cdba") == false);
assert(func0("abacd", "cdaba") == true);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
mov 0x8(%rdi)... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r12
push rbp
push rbx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov rbp, [rdi+8]
lea rax, [rsp+68h+var_58]
mov [rsp+68h+var_68], rax
mov [rsp+68h+var_60], 0
mov byte ptr [... | long long func0(long long *a1, long long a2)
{
unsigned long long v2; // rbp
long long v3; // r12
char *v5; // rax
long long v6; // rcx
long long v8; // rdx
unsigned long long v9; // rdi
char *v10; // rax
char *v11; // rsi
unsigned int v12; // ecx
unsigned int v13; // eax
void *v14; // [rsp+0h] [... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,qword ptr [RDI + 0x8]
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
MOV R12D,0x0
CMP dword ptr [RSI + 0x8],EBP
JNZ 0x001014bb
M... | /* func0(std::string, std::string) */
ulong func0(ulong *param_1,ulong *param_2)
{
ulong *puVar1;
uint uVar2;
int8 uVar3;
long lVar4;
uint uVar5;
ulong uVar6;
ulong uVar7;
ulong uVar8;
long in_FS_OFFSET;
ulong *local_68;
ulong local_60;
ulong local_58 [2];
ulong *local_48;
int8 local_40;
... |
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.