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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
1,682 | func0 | #include <string>
#include <vector>
#include <sstream>
#include <assert.h>
| std::string func0(const std::vector<std::string>& test_tup) {
std::string delim = "-";
std::stringstream res;
for (size_t i = 0; i < test_tup.size(); ++i) {
res << test_tup[i];
if (i < test_tup.size() - 1) {
res << delim;
}
}
return res.str();
}
| int main() {
assert(func0({"ID", "is", "4", "UTS"}) == "ID-is-4-UTS");
assert(func0({"QWE", "is", "4", "RTY"}) == "QWE-is-4-RTY");
assert(func0({"ZEN", "is", "4", "OP"}) == "ZEN-is-4-OP");
return 0;
}
| 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
mov %rsi,%rbp
push %rbx... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
lea rdx, unk_3005
push r14
push r13
mov r13, rdi
push r12
push rbp
mov rbp, rsi
lea rsi, [rdx-1]
push rbx
lea rbx, unk_4C58
movq xmm3, rbx
sub rsp, 1F8h
mov rax, fs:28h
mov... | long long func0(long long a1, long long *a2, long long a3, long long a4, long long a5, long long a6)
{
_QWORD *v7; // rdi
__m128i si128; // xmm2
long long v9; // rdx
unsigned long long v10; // rbx
unsigned long long v11; // rax
unsigned long long v12; // r8
unsigned long long v13; // rdx
__m128i v14; /... | func0:
ENDBR64
PUSH R15
LEA RDX,[0x103005]
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
MOV RBP,RSI
LEA RSI,[RDX + -0x1]
PUSH RBX
LEA RBX,[0x104c58]
MOVQ XMM3,RBX
SUB RSP,0x1f8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1e8],RAX
LEA RAX,[0x104c10]
LEA RDI,[RSP + 0x40]
LEA R15,[RSP + 0x60]
MOV qword ptr [RSP ... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
int8 uVar1;
pointer_____offset_0x10___ puVar2;
ulong uVar3;
streambuf *psVar4;
long lVar5;
int8 *puVar6;
ulong uVar7;
long *in_RSI;
long in_FS_OFFSET;
long *local_1e8;
long local_1e0;
... |
1,683 | func0 | #include <string>
#include <vector>
#include <sstream>
#include <assert.h>
| std::string func0(const std::vector<std::string>& test_tup) {
std::string delim = "-";
std::stringstream res;
for (size_t i = 0; i < test_tup.size(); ++i) {
res << test_tup[i];
if (i < test_tup.size() - 1) {
res << delim;
}
}
return res.str();
}
| int main() {
assert(func0({"ID", "is", "4", "UTS"}) == "ID-is-4-UTS");
assert(func0({"QWE", "is", "4", "RTY"}) == "QWE-is-4-RTY");
assert(func0({"ZEN", "is", "4", "OP"}) == "ZEN-is-4-OP");
return 0;
}
| 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
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
mov ecx, 2Dh ; '-'
push r14
push r13
mov r13, rdi
push r12
push rbp
mov rbp, rsi
push rbx
lea rbx, unk_4C78
movq xmm3, rbx
sub rsp, 1F8h
mov rax, fs:28h
mov [rsp+228h+var_4... | long long func0(long long a1, long long *a2)
{
long long v3; // rdx
long long v4; // r8
long long v5; // r9
_QWORD *v6; // rdi
long long v7; // rdx
long long v8; // r8
long long v9; // r9
__m128i si128; // xmm2
long long v11; // rdx
long long v12; // r8
long long v13; // r9
long long v14; // rd... | func0:
ENDBR64
PUSH R15
MOV ECX,0x2d
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
LEA RBX,[0x104c78]
MOVQ XMM3,RBX
SUB RSP,0x1f8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1e8],RAX
LEA RAX,[0x104c30]
LEA R15,[RSP + 0x60]
MOV word ptr [RSP + 0x50],CX
MOV qword ptr [RSP + 0x38],R15
MOV qwo... | /* WARNING: Removing unreachable block (ram,0x00102b5a) */
/* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
int8 uVar1;
int8 uVar2;
pointer_____offset_0x10___ puVar3;
ulong uVar4;
streambuf *psVar5;
long lVar6;
int8 *puVar7;
ulong uVar8;
l... |
1,684 | func0 |
#include <cmath>
#include <cassert>
| double func0(int n) {
double sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return round(sum / n * 1000000) / 1000000;
}
| int main() {
assert(func0(2) == 4.5);
assert(func0(3) == 12);
assert(func0(1) == 1);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
pxor %xmm0,%xmm0
movsd %xmm0,-0x8(%rbp)
movl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jg 11b2 <_Z5func0i+0x49>
mov -0xc(%rbp),%eax
imul %eax,%eax
imul -0xc(%rbp),%eax
cvtsi2sd %eax,%xmm0
movs... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
pxor xmm0, xmm0
movsd [rbp+var_8], xmm0
mov [rbp+var_C], 1
jmp short loc_11AE
loc_118A:
mov eax, [rbp+var_C]
imul eax, eax
imul eax, [rbp+var_C]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
movsd xmm1, [rbp+var_... | __int128 __usercall func0@<xmm0>(int a1@<edi>)
{
double v1; // rax
__int128 v2; // xmm1
int i; // [rsp+14h] [rbp-Ch]
double v5; // [rsp+18h] [rbp-8h]
v5 = 0.0;
for ( i = 1; i <= a1; ++i )
v5 = (double)(i * i * i) + v5;
v1 = round(v5 / (double)a1 * 1000000.0);
v2 = *(unsigned long long *)&v1;
*(do... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x8],XMM0
MOV dword ptr [RBP + -0xc],0x1
JMP 0x001011ae
LAB_0010118a:
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0xc]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr ... | /* func0(int) */
double func0(int param_1)
{
double dVar1;
int4 local_14;
int8 local_10;
local_10 = 0.0;
for (local_14 = 1; local_14 <= param_1; local_14 = local_14 + 1) {
local_10 = (double)(local_14 * local_14 * local_14) + local_10;
}
dVar1 = round((local_10 / (double)param_1) * DAT_00102068);... |
1,685 | func0 |
#include <cmath>
#include <cassert>
| double func0(int n) {
double sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return round(sum / n * 1000000) / 1000000;
}
| int main() {
assert(func0(2) == 4.5);
assert(func0(3) == 12);
assert(func0(1) == 1);
return 0;
}
| O1 | cpp | func0(int):
endbr64
sub $0x8,%rsp
test %edi,%edi
jle 11c2 <_Z5func0i+0x59>
lea 0x1(%rdi),%ecx
mov $0x1,%eax
pxor %xmm0,%xmm0
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
pxor %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
addsd %xmm1,%xmm0
add $0x1,%eax
cmp %ecx,%eax
jne 1181 <_Z5func0i+0x18>
pxor ... | _Z5func0i:
endbr64
sub rsp, 8
test edi, edi
jle short loc_11C2
lea ecx, [rdi+1]
mov eax, 1
pxor xmm0, xmm0
loc_1181:
mov edx, eax
imul edx, eax
imul edx, eax
pxor xmm1, xmm1
cvtsi2sd xmm1, edx
addsd xmm0, xmm1
add eax, 1
cmp eax, ecx
jnz short loc_1181
loc_119C:
pxor ... | double func0(int a1)
{
int v1; // eax
double v2; // xmm0_8
if ( a1 <= 0 )
{
v2 = 0.0;
}
else
{
v1 = 1;
v2 = 0.0;
do
{
v2 = v2 + (double)(v1 * v1 * v1);
++v1;
}
while ( v1 != a1 + 1 );
}
return round(v2 / (double)a1 * 1000000.0) / 1000000.0;
} | func0:
ENDBR64
SUB RSP,0x8
TEST EDI,EDI
JLE 0x001011c2
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
PXOR XMM0,XMM0
LAB_00101181:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDX
ADDSD XMM0,XMM1
ADD EAX,0x1
CMP EAX,ECX
JNZ 0x00101181
LAB_0010119c:
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
MULSD XMM0,qwor... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
double func0(int param_1)
{
int iVar1;
double dVar2;
if (param_1 < 1) {
dVar2 = 0.0;
}
else {
iVar1 = 1;
dVar2 = 0.0;
do {
dVar2 = dVar2 + (double)(iVar1 * iVar1 * iVar1);
iVa... |
1,686 | func0 |
#include <cmath>
#include <cassert>
| double func0(int n) {
double sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return round(sum / n * 1000000) / 1000000;
}
| int main() {
assert(func0(2) == 4.5);
assert(func0(3) == 12);
assert(func0(1) == 1);
return 0;
}
| O2 | cpp | func0(int):
endbr64
sub $0x8,%rsp
test %edi,%edi
jle 1288 <_Z5func0i+0x68>
lea 0x1(%rdi),%ecx
mov $0x1,%eax
pxor %xmm0,%xmm0
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
pxor %xmm1,%xmm1
imul %eax,%edx
imul %eax,%edx
add $0x1,%eax
cvtsi2sd %edx,%xmm1
addsd %xmm1,%xmm0
cmp %ecx,%eax
jne 1240 ... | _Z5func0i:
endbr64
sub rsp, 8
test edi, edi
jle short loc_1288
lea ecx, [rdi+1]
mov eax, 1
pxor xmm0, xmm0
nop dword ptr [rax+rax+00000000h]
loc_1240:
mov edx, eax
pxor xmm1, xmm1
imul edx, eax
imul edx, eax
add eax, 1
cvtsi2sd xmm1, edx
addsd xmm0, xmm1
cmp eax, ecx
jnz... | double func0(int a1)
{
int v1; // eax
double v2; // xmm0_8
int v3; // edx
if ( a1 <= 0 )
{
v2 = 0.0;
}
else
{
v1 = 1;
v2 = 0.0;
do
{
v3 = v1 * v1 * v1;
++v1;
v2 = v2 + (double)v3;
}
while ( v1 != a1 + 1 );
}
return round(v2 / (double)a1 * 1000000.0) / ... | func0:
ENDBR64
SUB RSP,0x8
TEST EDI,EDI
JLE 0x00101288
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
PXOR XMM0,XMM0
NOP dword ptr [RAX + RAX*0x1]
LAB_00101240:
MOV EDX,EAX
PXOR XMM1,XMM1
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
CVTSI2SD XMM1,EDX
ADDSD XMM0,XMM1
CMP EAX,ECX
JNZ 0x00101240
LAB_0010125b:
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
D... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
double func0(int param_1)
{
int iVar1;
int iVar2;
double dVar3;
if (param_1 < 1) {
dVar3 = 0.0;
}
else {
iVar1 = 1;
dVar3 = 0.0;
do {
iVar2 = iVar1 * iVar1 * iVar1;
iVar1 = ... |
1,687 | func0 |
#include <cmath>
#include <cassert>
| double func0(int n) {
double sum = 0;
for (int i = 1; i <= n; i++) {
sum += i * i * i;
}
return round(sum / n * 1000000) / 1000000;
}
| int main() {
assert(func0(2) == 4.5);
assert(func0(3) == 12);
assert(func0(1) == 1);
return 0;
}
| O3 | cpp | func0(int):
endbr64
sub $0x8,%rsp
test %edi,%edi
jle 1288 <_Z5func0i+0x68>
lea 0x1(%rdi),%ecx
mov $0x1,%eax
pxor %xmm0,%xmm0
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
pxor %xmm1,%xmm1
imul %eax,%edx
imul %eax,%edx
add $0x1,%eax
cvtsi2sd %edx,%xmm1
addsd %xmm1,%xmm0
cmp %ecx,%eax
jne 1240 ... | _Z5func0i:
endbr64
sub rsp, 8
test edi, edi
jle short loc_1288
lea ecx, [rdi+1]
mov eax, 1
pxor xmm0, xmm0
nop dword ptr [rax+rax+00000000h]
loc_1240:
mov edx, eax
pxor xmm1, xmm1
imul edx, eax
imul edx, eax
add eax, 1
cvtsi2sd xmm1, edx
addsd xmm0, xmm1
cmp eax, ecx
jnz... | double func0(int a1)
{
int v1; // eax
double v2; // xmm0_8
int v3; // edx
if ( a1 <= 0 )
{
v2 = 0.0;
}
else
{
v1 = 1;
v2 = 0.0;
do
{
v3 = v1 * v1 * v1;
++v1;
v2 = v2 + (double)v3;
}
while ( v1 != a1 + 1 );
}
return round(v2 / (double)a1 * 1000000.0) / ... | func0:
ENDBR64
SUB RSP,0x8
TEST EDI,EDI
JLE 0x00101288
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
PXOR XMM0,XMM0
NOP dword ptr [RAX + RAX*0x1]
LAB_00101240:
MOV EDX,EAX
PXOR XMM1,XMM1
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
CVTSI2SD XMM1,EDX
ADDSD XMM0,XMM1
CMP EAX,ECX
JNZ 0x00101240
LAB_0010125b:
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
D... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
double func0(int param_1)
{
int iVar1;
int iVar2;
double dVar3;
if (param_1 < 1) {
dVar3 = 0.0;
}
else {
iVar1 = 1;
dVar3 = 0.0;
do {
iVar2 = iVar1 * iVar1 * iVar1;
iVar1 = ... |
1,688 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>
| int func0(const std::vector<std::vector<int>>& gold, int m, int n) {
std::vector<std::vector<int>> goldTable(m, std::vector<int>(n, 0));
for (int col = n - 1; col >= 0; col--) {
for (int row = 0; row < m; row++) {
int right = (col == n - 1) ? 0 : goldTable[row][col + 1];
... | int main() {
assert(func0({{1, 3, 1, 5}, {2, 2, 4, 1}, {5, 0, 2, 3}, {0, 6, 1, 2}}, 4, 4) == 16);
assert(func0({{10, 20}, {30, 40}}, 2, 2) == 70);
assert(func0({{4, 9}, {3, 7}}, 2, 2) == 13);
return 0;
}
| O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x88,%rsp
mov %rdi,-0x98(%rbp)
mov %esi,-0x9c(%rbp)
mov %edx,-0xa0(%rbp)
mov %fs:0x28,%rax
m... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 98h
mov [rbp+var_A8], rdi
mov [rbp+var_AC], esi
mov [rbp+var_B0], edx
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea rax, [rbp+var_99]
mov [rbp+var_78],... | long long func0(long long a1, int a2, int a3)
{
long long v3; // rax
int v4; // eax
long long v5; // rax
int v6; // eax
long long v7; // rax
int v8; // eax
long long v9; // rax
_DWORD *v10; // rax
int v11; // ebx
long long v12; // rax
long long v13; // rax
long long v14; // rax
long long v15;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0xa8],RDI
MOV dword ptr [RBP + -0xac],ESI
MOV dword ptr [RBP + -0xb0],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x99]
MOV qword ptr [RBP + -0x78],RAX
NOP
NOP
LEA RAX,[RBP +... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
int iVar1;
int4 *puVar2;
vector<int,std::allocator<int>> *pvVar3;
int *piVar4;
long in_FS_OFFSET;
allocator lo... |
1,689 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>
| int func0(const std::vector<std::vector<int>>& gold, int m, int n) {
std::vector<std::vector<int>> goldTable(m, std::vector<int>(n, 0));
for (int col = n - 1; col >= 0; col--) {
for (int row = 0; row < m; row++) {
int right = (col == n - 1) ? 0 : goldTable[row][col + 1];
... | int main() {
assert(func0({{1, 3, 1, 5}, {2, 2, 4, 1}, {5, 0, 2, 3}, {0, 6, 1, 2}}, 4, 4) == 16);
assert(func0({{10, 20}, {30, 40}}, 2, 2) == 70);
assert(func0({{4, 9}, {3, 7}}, 2, 2) == 13);
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %esi,0x24(%rsp)
mov %edx,%eax
mov %edx,0x28(%rsp)
mov %fs:0x28,%rbx
mov... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
movsxd r14, edx
mov rax, r14
shr rax, 3Dh
jnz loc_1362
mov rbp, rdi
mov ebx, esi
mov r13... | long long func0(_QWORD *a1, int a2, int a3)
{
unsigned long long v3; // r14
_DWORD *v7; // rax
void *v8; // r15
_DWORD *v9; // rdx
int v10; // r12d
int v11; // esi
long long v12; // r8
int v13; // r11d
int v14; // esi
int v15; // eax
bool v16; // cc
int *v17; // rsi
int v18; // esi
int v19;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOVSXD R14,EDX
MOV RAX,R14
SHR RAX,0x3d
JNZ 0x00101362
MOV RBP,RDI
MOV EBX,ESI
MOV R13D,EDX
TEST R14,R14
JZ 0x001015d6
SHL R14,0x2
MOV RDI,R14
LAB_001012f3:
CALL 0x001... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
void *pvVar1;
int iVar2;
int4 *puVar3;
int8 uVar4;
vector *pvVar5;
vector *pvVar6;
vector *pvVar7;
int iVa... |
1,690 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>
| int func0(const std::vector<std::vector<int>>& gold, int m, int n) {
std::vector<std::vector<int>> goldTable(m, std::vector<int>(n, 0));
for (int col = n - 1; col >= 0; col--) {
for (int row = 0; row < m; row++) {
int right = (col == n - 1) ? 0 : goldTable[row][col + 1];
... | int main() {
assert(func0({{1, 3, 1, 5}, {2, 2, 4, 1}, {5, 0, 2, 3}, {0, 6, 1, 2}}, 4, 4) == 16);
assert(func0({{10, 20}, {30, 40}}, 2, 2) == 70);
assert(func0({{4, 9}, {3, 7}}, 2, 2) == 13);
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int, int):
endbr64
push %r15
movslq %edx,%rax
movabs $0x1fffffffffffffff,%rdx
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,0x20(%rsp)
mov %eax,0x2... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
push r15
push r14
push r13
push r12
movsxd r12, edx
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_80], rdi
mov rax, fs:28h
mov [rsp+98h+var_40], rax
mov rax, r12
shr rax, 3Dh
jnz loc_1ADC
pxor xmm0, xmm0
mov ebx, e... | long long func0(_QWORD *a1, int a2, int a3)
{
unsigned long long v3; // r12
char *v6; // rax
char *v7; // r13
void *v8; // r14
unsigned int **v9; // r15
long long v10; // r13
int v11; // r12d
long long v12; // rsi
int v13; // r9d
_QWORD *v14; // r8
long long v15; // r11
unsigned int **v16; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOVSXD R12,EDX
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,R12
SHR RAX,0x3d
JNZ 0x00101adc
PXOR XMM0,XMM0
MOV EBX,ESI
MOV RBP,R12
MOVUPS xmmword ptr [RSP + 0x48],XMM0
TEST R12,R12
JZ 0... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
long *plVar1;
vector *pvVar2;
int iVar3;
void *__s;
vector *pvVar4;
vector *pvVar5;
vector *pvVar6;
int iV... |
1,691 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>
| int func0(const std::vector<std::vector<int>>& gold, int m, int n) {
std::vector<std::vector<int>> goldTable(m, std::vector<int>(n, 0));
for (int col = n - 1; col >= 0; col--) {
for (int row = 0; row < m; row++) {
int right = (col == n - 1) ? 0 : goldTable[row][col + 1];
... | int main() {
assert(func0({{1, 3, 1, 5}, {2, 2, 4, 1}, {5, 0, 2, 3}, {0, 6, 1, 2}}, 4, 4) == 16);
assert(func0({{10, 20}, {30, 40}}, 2, 2) == 70);
assert(func0({{4, 9}, {3, 7}}, 2, 2) == 13);
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r15
movslq %edx,%rdx
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,0x10(%rsp)
mov %edx,0x1... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_70], rdi
mov [rsp+98h+var_64], edx
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
movsxd rax, edx
mov [rsp+98h+n], rax
shr rax,... | long long func0(long long **a1, int a2, int a3)
{
char *v4; // rax
char *v5; // rbp
char *v6; // r13
long long v7; // rax
unsigned int **v8; // rbx
signed long long v9; // rbp
long long v10; // r15
char *v11; // rax
char *v12; // r12
int v13; // r13d
long long v14; // r8
long long *v15; // r12
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x28],RDI
MOV dword ptr [RSP + 0x34],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOVSXD RAX,EDX
MOV qword ptr [RSP + 0x8],RAX
SHR RAX,0x3d
JNZ 0x00101c48
PXOR XMM0,XMM0
CMP qword ptr [RS... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
long *plVar1;
int4 uVar2;
long lVar3;
long *plVar4;
long lVar5;
int (*pauVar6) [16];
int iVar7;
void *pvVa... |
1,692 | func0 | #include <cassert>
#include <vector>
#include <string>
using namespace std;
| vector<char> func0(const vector<string>& test_tuple) {
vector<char> res;
for (const auto& sub : test_tuple) {
res.push_back(sub[sub.size() - 1]);
}
return res;
}
| int main() {
assert(func0({"Mers", "for", "Vers"}) == vector<char>({'s', 'r', 's'}));
assert(func0({"Avenge", "for", "People"}) == vector<char>({'e', 'r', 'e'}));
assert(func0({"Gotta", "get", "go"}) == vector<char>({'a', 't', 'o'}));
return 0;
}
| 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 $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v5; // [rsp+18h] [rbp-38h] BYREF
_QWORD v6[2]; // [rsp+20h] [rbp-30h] BYREF
long long v7; // [rsp+30h] [rbp-20h]
unsigned long long v8; // [rsp+38h] [rbp-18h]
v8 = __readfsqword(0x28u);
std::vector<char>:... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
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 0x00102c20
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x28],RAX
MO... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
bool bVar1;
char *pcVar2;
vector<std::string,std::allocator<std::string>> *in_RSI;
long in_FS_OFFSET;
int8 local_40;
int8 local_38;
vector<std::string,std::allocator<std::string>> *local_30;
u... |
1,693 | func0 | #include <cassert>
#include <vector>
#include <string>
using namespace std;
| vector<char> func0(const vector<string>& test_tuple) {
vector<char> res;
for (const auto& sub : test_tuple) {
res.push_back(sub[sub.size() - 1]);
}
return res;
}
| int main() {
assert(func0({"Mers", "for", "Vers"}) == vector<char>({'s', 'r', 's'}));
assert(func0({"Avenge", "for", "People"}) == vector<char>({'e', 'r', 'e'}));
assert(func0({"Gotta", "get", "go"}) == vector<char>({'a', 't', 'o'}));
return 0;
}
| 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 %r12
push %rbp
push %rbx
mov %rdi,%rbp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
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 r12, rbx
jnz short loc_1370
loc_1357:
... | _QWORD * func0(_QWORD *a1, long long a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r12
_BYTE *v5; // rdx
_BYTE *v6; // rsi
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v2 = *(_QWORD **)a2;
v3 = *(_QWORD **)(a2 + 8);
if ( v3 != *(_QWORD **)a2 )
{
do
{
v5 = (_BYTE *)(*v2 + v2[1] - 1LL);
v6 = ... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
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 0x00101370
LAB_00101357:
MOV RAX,RBP
POP RBX
POP RBP
POP R12
RET
LAB_0010135f:
MOV RDI,RBP
LAB_00101362:
CALL 0... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
char *pcVar1;
long *plVar2;
char *pcVar3;
long *plVar4;
int8 *in_RSI;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
plVar2 = (long *)in_RSI[1];
for (p... |
1,694 | func0 | #include <cassert>
#include <vector>
#include <string>
using namespace std;
| vector<char> func0(const vector<string>& test_tuple) {
vector<char> res;
for (const auto& sub : test_tuple) {
res.push_back(sub[sub.size() - 1]);
}
return res;
}
| int main() {
assert(func0({"Mers", "for", "Vers"}) == vector<char>({'s', 'r', 's'}));
assert(func0({"Avenge", "for", "People"}) == vector<char>({'e', 'r', 'e'}));
assert(func0({"Gotta", "get", "go"}) == vector<char>({'a', 't', 'o'}));
return 0;
}
| 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 %r12
mov %rdi,%r12
push %rbp
push %rbx
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
movq $0x0... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r12
pxor xmm0, xmm0
push rbp
mov rbp, rdi
push rbx
mov rbx, [rsi]
mov r12, [rsi+8]
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
cmp r12, rbx
jz short loc_179D
xor ecx, ec... | long long func0(long long a1, long long a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r12
_BYTE *v4; // rcx
_BYTE *v5; // rsi
_BYTE *v6; // rdx
v2 = *(_QWORD **)a2;
v3 = *(_QWORD **)(a2 + 8);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
if ( v3 != v2 )
{
v4 = 0LL;
v5 = 0LL;
while ( 1 )... | func0:
ENDBR64
PUSH R12
PXOR XMM0,XMM0
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
CMP R12,RBX
JZ 0x0010179d
XOR ECX,ECX
XOR ESI,ESI
JMP 0x0010177b
LAB_00101760:
MOVZX EAX,byte ptr [RDX]
ADD RBX,0x20
MOV byte ptr [RSI],... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
char *pcVar1;
long *plVar2;
char *pcVar3;
long *plVar4;
long *in_RSI;
char *pcVar5;
plVar4 = (long *)*in_RSI;
plVar2 = (long *)in_RSI[1];
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])p... |
1,695 | func0 | #include <cassert>
#include <vector>
#include <string>
using namespace std;
| vector<char> func0(const vector<string>& test_tuple) {
vector<char> res;
for (const auto& sub : test_tuple) {
res.push_back(sub[sub.size() - 1]);
}
return res;
}
| int main() {
assert(func0({"Mers", "for", "Vers"}) == vector<char>({'s', 'r', 's'}));
assert(func0({"Avenge", "for", "People"}) == vector<char>({'e', 'r', 'e'}));
assert(func0({"Gotta", "get", "go"}) == vector<char>({'a', 't', 'o'}));
return 0;
}
| 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 %r12
pxor %xmm0,%xmm0
mov %rdi,%r12
push %rbp
push %rbx
mov (%rsi),%rbx
mov 0x8(%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, 28h
mov rbx, [rsi]
mov r13, [rsi+8]
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
cm... | long long func0(long long a1, long long a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r13
_BYTE *v4; // rsi
_BYTE *v5; // rcx
_BYTE *v6; // r12
void *v7; // r15
unsigned long long v8; // rcx
signed long long v9; // r14
long long v10; // rax
unsigned long long v11; // rdx
_BYTE *v12; // r8
_BYTE *v13;... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x28
MOV RBX,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
CMP R13,RBX
JZ 0x00101877
XOR ESI,ESI
XOR ECX,ECX
JMP 0x00101794
LAB_00101770:
MOVZX EAX,byte pt... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
int *puVar1;
long *plVar2;
void *__src;
ulong uVar3;
ulong uVar4;
int *puVar5;
vector *pvVar6;
int *puVar7;
ulong uVar8;
long *plVar9;
long *in_RSI;
char *pcVar10;
ulong local_50;
... |
1,696 | func0 | #include <vector>
#include <string>
#include <cassert>
template<typename T>
| int func0(const std::vector<std::vector<T>> &list1, T x) {
int ctr = 0;
for (const auto &sublist : list1) {
for (const auto &item : sublist) {
if (item == x) {
ctr++;
break;
}
}
}
return ctr;
}
| int main() {
assert(func0<int>({{1, 3}, {5, 7}, {1, 11}, {1, 15, 7}}, 1) == 3);
assert(func0<std::string>({{"A", "B"}, {"A", "C"}, {"A", "D", "E"}, {"B", "C", "D"}}, "A") == 3);
assert(func0<std::string>({{"A", "B"}, {"A", "C"}, {"A", "D", "E"}, {"B", "C", "D"}}, "E") == 1);
return 0;
}
| O0 | cpp | int func0<int>(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x60,%rsp
mov %rdi,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x4c... | _Z5func0IiEiRKSt6vectorIS0_IT_SaIS1_EESaIS3_EES1_:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_4C], 0
mov rax, [rbp+var_58]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]... | long long func0<int>(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-4Ch]
long long v4; // [rsp+18h] [rbp-48h] BYREF
long long v5; // [rsp+20h] [rbp-40h] BYREF
long long v6; // [rsp+28h] [rbp-38h] BYREF
_QWORD v7[2]; // [rsp+30h] [rbp-30h] BYREF
long long v8; // [rsp+40h] [rbp-20h]
long long v... | func0<int>:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x4c],0x0
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV... | /* int func0<int>(std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&, int) */
int func0<int>(vector *param_1,int param_2)
{
bool bVar1;
long in_FS_OFFSET;
int local_54;
int8 local_50;
int8 local_48;
int8 local_40;
int8 local_38;
vect... |
1,697 | func0 | #include <vector>
#include <string>
#include <cassert>
template<typename T>
| int func0(const std::vector<std::vector<T>> &list1, T x) {
int ctr = 0;
for (const auto &sublist : list1) {
for (const auto &item : sublist) {
if (item == x) {
ctr++;
break;
}
}
}
return ctr;
}
| int main() {
assert(func0<int>({{1, 3}, {5, 7}, {1, 11}, {1, 15, 7}}, 1) == 3);
assert(func0<std::string>({{"A", "B"}, {"A", "C"}, {"A", "D", "E"}, {"B", "C", "D"}}, "A") == 3);
assert(func0<std::string>({{"A", "B"}, {"A", "C"}, {"A", "D", "E"}, {"B", "C", "D"}}, "E") == 1);
return 0;
}
| O1 | cpp | int func0<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::vector<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::allocator<std::vec... | _Z5func0INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEiRKSt6vectorIS6_IT_SaIS7_EESaIS9_EES7_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r13, [rdi]
mov r15, [rdi+8]
cmp r15, r13
jz short loc_1DED
mov r14, rsi
mov [rsp+48h+var_3C]... | long long func0<std::string>(long long **a1, long long a2)
{
long long *v2; // r13
long long *v3; // r15
long long v4; // rbx
size_t v5; // rdx
long long v6; // rbp
long long v7; // r12
unsigned int v9; // [rsp+Ch] [rbp-3Ch]
v2 = *a1;
v3 = a1[1];
if ( v3 == *a1 )
{
return 0;
}
else
{
... | func0<std::string>:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R13,qword ptr [RDI]
MOV R15,qword ptr [RDI + 0x8]
CMP R15,R13
JZ 0x00101ded
MOV R14,RSI
MOV dword ptr [RSP + 0xc],0x0
JMP 0x00101dda
LAB_00101da6:
ADD RBX,0x20
CMP RBP,RBX
JZ 0x00101dd1
LAB_00101daf:
MOV RDX,qword ptr [RB... | /* int func0<std::string >(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&, std::string)
*/
int func0<std::string>(long *param_1,int8 *param_2)
{
int8 *puVar1;
size_t __n;
int8 *puVar2;
size_t sVar3;
... |
1,698 | func0 | #include <vector>
#include <string>
#include <cassert>
template<typename T>
| int func0(const std::vector<std::vector<T>> &list1, T x) {
int ctr = 0;
for (const auto &sublist : list1) {
for (const auto &item : sublist) {
if (item == x) {
ctr++;
break;
}
}
}
return ctr;
}
| int main() {
assert(func0<int>({{1, 3}, {5, 7}, {1, 11}, {1, 15, 7}}, 1) == 3);
assert(func0<std::string>({{"A", "B"}, {"A", "C"}, {"A", "D", "E"}, {"B", "C", "D"}}, "A") == 3);
assert(func0<std::string>({{"A", "B"}, {"A", "C"}, {"A", "D", "E"}, {"B", "C", "D"}}, "E") == 1);
return 0;
}
| O2 | cpp | int func0<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::vector<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::allocator<std::vec... | _Z5func0INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEiRKSt6vectorIS6_IT_SaIS7_EESaIS9_EES7_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, [rdi+8]
mov r15, [rdi]
mov [rsp+48h+var_40], rax
cmp rax, r15
jz short loc_1F1F
mov r14... | long long func0<std::string>(long long **a1, long long a2)
{
long long *v2; // r15
unsigned int v3; // r13d
long long v4; // rbx
long long v5; // r12
size_t v6; // rbp
long long *v8; // [rsp+8h] [rbp-40h]
v2 = *a1;
v8 = a1[1];
if ( v8 == *a1 )
{
return 0;
}
else
{
v3 = 0;
do
... | func0<std::string>:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr [RDI + 0x8]
MOV R15,qword ptr [RDI]
MOV qword ptr [RSP + 0x8],RAX
CMP RAX,R15
JZ 0x00101f1f
MOV R14,RSI
XOR R13D,R13D
NOP dword ptr [RAX]
LAB_00101ec0:
MOV RBX,qword ptr [R15]
MOV R12,qword ptr [R15 + 0x8]
C... | /* int func0<std::string >(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&, std::string)
*/
int func0<std::string>(long *param_1,int8 *param_2)
{
long *plVar1;
int8 *puVar2;
size_t __n;
int iVar3;
i... |
1,699 | func0 | #include <vector>
#include <string>
#include <cassert>
template<typename T>
| int func0(const std::vector<std::vector<T>> &list1, T x) {
int ctr = 0;
for (const auto &sublist : list1) {
for (const auto &item : sublist) {
if (item == x) {
ctr++;
break;
}
}
}
return ctr;
}
| int main() {
assert(func0<int>({{1, 3}, {5, 7}, {1, 11}, {1, 15, 7}}, 1) == 3);
assert(func0<std::string>({{"A", "B"}, {"A", "C"}, {"A", "D", "E"}, {"B", "C", "D"}}, "A") == 3);
assert(func0<std::string>({{"A", "B"}, {"A", "C"}, {"A", "D", "E"}, {"B", "C", "D"}}, "E") == 1);
return 0;
}
| O3 | cpp | int func0<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::vector<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::allocator<std::vec... | _Z5func0INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEiRKSt6vectorIS6_IT_SaIS7_EESaIS9_EES7_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, [rdi+8]
mov r15, [rdi]
mov [rsp+48h+var_40], rax
cmp rax, r15
jz short loc_202F
mov r14... | long long func0<std::string>(long long **a1, long long a2)
{
long long *v2; // r15
unsigned int v3; // r13d
long long v4; // rbx
long long v5; // r12
size_t v6; // rbp
long long *v8; // [rsp+8h] [rbp-40h]
v2 = *a1;
v8 = a1[1];
if ( v8 == *a1 )
{
return 0;
}
else
{
v3 = 0;
do
... | func0<std::string>:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr [RDI + 0x8]
MOV R15,qword ptr [RDI]
MOV qword ptr [RSP + 0x8],RAX
CMP RAX,R15
JZ 0x0010202f
MOV R14,RSI
XOR R13D,R13D
NOP dword ptr [RAX]
LAB_00101fd0:
MOV RBX,qword ptr [R15]
MOV R12,qword ptr [R15 + 0x8]
C... | /* int func0<std::string >(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&, std::string)
*/
int func0<std::string>(long *param_1,int8 *param_2)
{
long *plVar1;
int8 *puVar2;
size_t __n;
int iVar3;
i... |
1,700 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<int> func0(const std::vector<int>& nums) {
std::vector<int> odd_nums;
for (int num : nums) {
if (num % 2 != 0) {
odd_nums.push_back(num);
}
}
return odd_nums;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>{1,3,5,7,9}));
assert((func0({10,20,45,67,84,93}) == std::vector<int>{45,67,93}));
assert((func0({5,7,9,8,6,4,3}) == std::vector<int>{5,7,9,3}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 1a3e <_ZNSt6vectorIiSaIiEEC1Ev>
mov -0... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mo... | long long func0(long long a1, long long a2)
{
int v3; // [rsp+1Ch] [rbp-34h] BYREF
long long v4; // [rsp+20h] [rbp-30h] BYREF
_QWORD v5[4]; // [rsp+28h] [rbp-28h] BYREF
v5[2] = __readfsqword(0x28u);
std::vector<int>::vector(a1);
v5[1] = a2;
v4 = std::vector<int>::begin(a2);
v5[0] = std::vector<int>::e... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
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 0x00101a92
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x20],RAX
MO... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
bool bVar1;
uint *puVar2;
vector<int,std::allocator<int>> *in_RSI;
long in_FS_OFFSET;
uint local_3c;
int8 local_38;
int8 local_30;
vector<int,std::allocator<int>> *local_28;
long local_20;
local_20 = *(... |
1,701 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<int> func0(const std::vector<int>& nums) {
std::vector<int> odd_nums;
for (int num : nums) {
if (num % 2 != 0) {
odd_nums.push_back(num);
}
}
return odd_nums;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>{1,3,5,7,9}));
assert((func0({10,20,45,67,84,93}) == std::vector<int>{45,67,93}));
assert((func0({5,7,9,8,6,4,3}) == std::vector<int>{5,7,9,3}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbx
mov 0x8(%rsi),%r12
cmp %r1... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
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 r12, rbx
jn... | _QWORD * func0(_QWORD *a1, int **a2)
{
int *v2; // rbx
int *v3; // r12
int v5; // eax
_DWORD *v6; // rsi
int v7; // [rsp+4h] [rbp-24h] BYREF
unsigned long long v8; // [rsp+8h] [rbp-20h]
v8 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v2 = *a2;
v3 = a2[1];
if ( v3 != *a2 )
{
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,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 RBX,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
CMP R12,RBX
JNZ 0x001012b7
LAB_0010128b:
MOV... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
int8 *in_RSI;
long in_FS_OFFSET;
uint local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(... |
1,702 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<int> func0(const std::vector<int>& nums) {
std::vector<int> odd_nums;
for (int num : nums) {
if (num % 2 != 0) {
odd_nums.push_back(num);
}
}
return odd_nums;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>{1,3,5,7,9}));
assert((func0({10,20,45,67,84,93}) == std::vector<int>{45,67,93}));
assert((func0({5,7,9,8,6,4,3}) == std::vector<int>{5,7,9,3}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
cmp %rb... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r12
pxor xmm0, xmm0
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov r12, [rsi+8]
cmp r12, rbx
jnz ... | long long func0(long long a1, int **a2)
{
int *v2; // rbx
int *v3; // r12
int v4; // eax
_DWORD *v5; // rsi
int v7; // [rsp+0h] [rbp-24h] BYREF
unsigned long long v8; // [rsp+4h] [rbp-20h]
v8 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = *a2;
v3 = a2[1];
if ( v3... | func0:
ENDBR64
PUSH R12
PXOR XMM0,XMM0
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 R12,qword ptr [RSI + 0x8]
CMP R12,RBX
JNZ 0x00101679
JMP 0x001016a0
LAB_0010167... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
int8 *in_RSI;
long in_FS_OFFSET;
uint local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 ... |
1,703 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<int> func0(const std::vector<int>& nums) {
std::vector<int> odd_nums;
for (int num : nums) {
if (num % 2 != 0) {
odd_nums.push_back(num);
}
}
return odd_nums;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) == std::vector<int>{1,3,5,7,9}));
assert((func0({10,20,45,67,84,93}) == std::vector<int>{45,67,93}));
assert((func0({5,7,9,8,6,4,3}) == std::vector<int>{5,7,9,3}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
cmp %rbp,... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r12
pxor xmm0, xmm0
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov r12, [rsi+8]
cmp r12, rbx
jnz ... | long long func0(long long a1, int **a2)
{
int *v2; // rbx
int *v3; // r12
int v4; // eax
_DWORD *v5; // rsi
int v7; // [rsp+0h] [rbp-24h] BYREF
unsigned long long v8; // [rsp+4h] [rbp-20h]
v8 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = *a2;
v3 = a2[1];
if ( v3... | func0:
ENDBR64
PUSH R12
PXOR XMM0,XMM0
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 R12,qword ptr [RSI + 0x8]
CMP R12,RBX
JNZ 0x00101679
JMP 0x001016a0
LAB_0010167... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
int8 *in_RSI;
long in_FS_OFFSET;
uint local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 ... |
1,704 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& dt) {
std::regex date_pattern(R"((\d{4})-(\d{1,2})-(\d{1,2}))");
return std::regex_replace(dt, date_pattern, "$3-$2-$1");
}
| int main() {
assert(func0("2026-01-02") == "02-01-2026");
assert(func0("2020-11-13") == "13-11-2020");
assert(func0("2021-04-26") == "26-04-2021");
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 $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%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, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, aD4D12D12; "(\\d{4}... | long long func0(long long a1, long long a2)
{
_BYTE v3[40]; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v4; // [rsp+38h] [rbp-18h]
v4 = __readfsqword(0x28u);
std::basic_regex<char,std::regex_traits<char>>::basic_regex(v3, "(\\d{4})-(\\d{1,2})-(\\d{1,2})", 16LL);
std::regex_replace<std::regex_traits<char... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],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,[0x134051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b63:
CALL 0x00106152
MOV RAX,qword ptr ... | /* func0(std::string const&) */
string * func0(string *param_1)
{
int8 in_RSI;
long in_FS_OFFSET;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_48,"(\\d{4})-(\\d{1,2})-(\\d{1,2})",0x10);
/* try { // try from 00104b84 to ... |
1,705 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& dt) {
std::regex date_pattern(R"((\d{4})-(\d{1,2})-(\d{1,2}))");
return std::regex_replace(dt, date_pattern, "$3-$2-$1");
}
| int main() {
assert(func0("2026-01-02") == "02-01-2026");
assert(func0("2020-11-13") == "13-11-2020");
assert(func0("2021-04-26") == "26-04-2021");
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 $0x48,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%r13
mov %r13,%rdi
callq 4730 <_ZNS... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea r12, [rbp+var_50]
lea rdi, [rbp+var_48]; this
call __Z... | long long func0(long long a1, long long *a2)
{
long long v4; // rsi
_DWORD *v5; // rdi
volatile signed __int32 *v6; // rcx
long long v7; // rdx
signed __int32 v8; // eax
_BYTE v10[8]; // [rsp+0h] [rbp-50h] BYREF
_BYTE v11[8]; // [rsp+8h] [rbp-48h] BYREF
long long v12; // [rsp+10h] [rbp-40h]
long long... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x50]
LEA RDI,[RBP + -0x48]
CALL 0x00104710
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],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;
int iVar3;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int8 local_48;
_Sp_counted_base<(_Lock_policy)2> *local_40;
long... |
1,706 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& dt) {
std::regex date_pattern(R"((\d{4})-(\d{1,2})-(\d{1,2}))");
return std::regex_replace(dt, date_pattern, "$3-$2-$1");
}
| int main() {
assert(func0("2026-01-02") == "02-01-2026");
assert(func0("2020-11-13") == "13-11-2020");
assert(func0("2021-04-26") == "26-04-2021");
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 $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%rbp
lea 0x18(%rsp),%r13... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
mov r14, rsi
push r13
lea r13, [rbp+var_50]
push r12
lea r12, [rbp+var_48]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 30h
mov rax, fs:28h
mov [rbp+var_28], rax... | long long func0(long long a1, long long *a2)
{
long long v3; // rsi
long long v4; // rdi
long long v5; // rdx
volatile signed __int32 *v6; // rcx
signed __int32 v7; // eax
long long v9; // rax
_BYTE v10[8]; // [rsp+0h] [rbp-50h] BYREF
_BYTE v11[8]; // [rsp+8h] [rbp-48h] BYREF
__int128 v12; // [rsp+10... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
MOV R14,RSI
PUSH R13
LEA R13,[RBP + -0x50]
PUSH R12
LEA R12,[RBP + -0x48]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001046f0
LEA RDX,[0x11a66e]
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;
int iVar3;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int local_48 [24];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
std::locale::... |
1,707 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& dt) {
std::regex date_pattern(R"((\d{4})-(\d{1,2})-(\d{1,2}))");
return std::regex_replace(dt, date_pattern, "$3-$2-$1");
}
| int main() {
assert(func0("2026-01-02") == "02-01-2026");
assert(func0("2020-11-13") == "13-11-2020");
assert(func0("2021-04-26") == "26-04-2021");
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 $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%rbp
lea 0x18(%rsp),%r13... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
mov r12, rsi
push rbx
lea rbx, [rbp+var_E0]
sub rsp, 128h
mov [rbp+var_F8], rdi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea r... | long long * func0(long long a1, char **a2)
{
char *v2; // rbx
long long v3; // r13
char *v4; // r12
char v5; // al
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
long long v9; // r9
unsigned long long v10; // rsi
long long v11; // rbx
volatile signed __int32 *v12; // rdx
signed __... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBX
LEA RBX,[RBP + -0xe0]
SUB RSP,0x128
MOV qword ptr [RBP + -0xf8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xd8]
MOV qword ptr [RBP + -0x138],RBX
MOV RDI,RAX
MOV qword ptr [RBP +... | /* func0(std::string const&) */
string * func0(string *param_1)
{
string *psVar1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
string sVar3;
int8 uVar4;
bool bVar5;
char cVar6;
int iVar7;
int8 *puVar8;
string *psVar9;
long lVar10;
ulong uVar11;
string *psVar12;
long *plVar13;
long lVar14;
... |
1,708 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int>& my_list) {
size_t n = my_list.size();
size_t gap = n / 2;
while (gap > 0) {
for (size_t i = gap; i < n; i++) {
int current_item = my_list[i];
size_t j = i;
while (j >= gap && my_list[j - gap] > current_item) {
... | int main() {
std::vector<int> list1 = {12, 23, 4, 5, 3, 2, 12, 81, 56, 95};
std::vector<int> sorted_list1 = {2, 3, 4, 5, 12, 12, 23, 56, 81, 95};
assert(func0(list1) == sorted_list1);
std::vector<int> list2 = {24, 22, 39, 34, 87, 73, 68};
std::vector<int> sorted_list2 = {22, 24, 34, 39, 68, 7... | O0 | cpp | func0(std::vector<int, std::allocator<int> >&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 19fa <_ZNKSt6vectorIiSaIiEE4sizeEv>
mov %rax,-0x18(%rbp)
mov -0x18(%rbp),%rax
shr %rax
mov %rax,-... | _Z5func0RSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, [rbp+var_50]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
shr rax,... | long long func0(long long a1, long long a2)
{
int v2; // ebx
int v5; // [rsp+1Ch] [rbp-34h]
unsigned long long i; // [rsp+20h] [rbp-30h]
unsigned long long j; // [rsp+28h] [rbp-28h]
unsigned long long k; // [rsp+30h] [rbp-20h]
unsigned long long v9; // [rsp+38h] [rbp-18h]
v9 = std::vector<int>::size(a2)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00101a4e
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00101377
LAB_0010129e:
M... | /* func0(std::vector<int, std::allocator<int> >&) */
vector * func0(vector *param_1)
{
int iVar1;
int4 uVar2;
bool bVar3;
ulong uVar4;
int *piVar5;
int4 *puVar6;
vector<int,std::allocator<int>> *in_RSI;
ulong local_38;
ulong local_30;
ulong local_28;
uVar4 = std::vector<int,std::allocator<int... |
1,709 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int>& my_list) {
size_t n = my_list.size();
size_t gap = n / 2;
while (gap > 0) {
for (size_t i = gap; i < n; i++) {
int current_item = my_list[i];
size_t j = i;
while (j >= gap && my_list[j - gap] > current_item) {
... | int main() {
std::vector<int> list1 = {12, 23, 4, 5, 3, 2, 12, 81, 56, 95};
std::vector<int> sorted_list1 = {2, 3, 4, 5, 12, 12, 23, 56, 81, 95};
assert(func0(list1) == sorted_list1);
std::vector<int> list2 = {24, 22, 39, 34, 87, 73, 68};
std::vector<int> sorted_list2 = {22, 24, 34, 39, 68, 7... | O1 | cpp | func0(std::vector<int, std::allocator<int> >&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %rsi,%rbx
mov 0x8(%rsi),%rax
sub (%rsi),%rax
sar $0x2,%rax
mov %rax,%r14
mov %rax,%rdi
shr %rdi
cmp $0x1,%rax
ja 1384 <_Z5func0RSt6vectorIiSaIiEE+0x11b>
mo... | _Z5func0RSt6vectorIiSaIiEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbp, rdi
mov rbx, rsi
mov rax, [rsi+8]
sub rax, [rsi]
mov r14, rax
sar r14, 2
mov rdi, r14
shr rdi, 1
cmp rax, 4
ja loc_137E
loc_1299:
mov r13, [rbx+8]
sub r13, [rbx]
mov ... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
unsigned long long v4; // r14
unsigned long long v5; // rdi
unsigned long long v6; // r13
_DWORD *v7; // r12
_DWORD *v8; // rsi
signed long long v9; // rbx
unsigned long long v11; // r9
unsigned long long v12; // r12
long long v13; // r13
int v14; // r8d
lo... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV RBX,RSI
MOV RAX,qword ptr [RSI + 0x8]
SUB RAX,qword ptr [RSI]
MOV R14,RAX
SAR R14,0x2
MOV RDI,R14
SHR RDI,0x1
CMP RAX,0x4
JA 0x0010137e
LAB_00101299:
MOV R13,qword ptr [RBX + 0x8]
SUB R13,qword ptr [RBX]
MOV qword ptr [RBP],0x0
MOV qword ptr [R... | /* func0(std::vector<int, std::allocator<int> >&) */
vector * func0(vector *param_1)
{
int iVar1;
int iVar2;
int4 *__src;
ulong uVar3;
int4 *__dest;
long lVar4;
size_t __n;
long *in_RSI;
ulong uVar5;
ulong uVar6;
long lVar7;
ulong uVar8;
uVar8 = in_RSI[1] - *in_RSI >> 2;
uVar5 = uVar8;
... |
1,710 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int>& my_list) {
size_t n = my_list.size();
size_t gap = n / 2;
while (gap > 0) {
for (size_t i = gap; i < n; i++) {
int current_item = my_list[i];
size_t j = i;
while (j >= gap && my_list[j - gap] > current_item) {
... | int main() {
std::vector<int> list1 = {12, 23, 4, 5, 3, 2, 12, 81, 56, 95};
std::vector<int> sorted_list1 = {2, 3, 4, 5, 12, 12, 23, 56, 81, 95};
assert(func0(list1) == sorted_list1);
std::vector<int> list2 = {24, 22, 39, 34, 87, 73, 68};
std::vector<int> sorted_list2 = {22, 24, 34, 39, 68, 7... | O2 | cpp | func0(std::vector<int, std::allocator<int> >&):
endbr64
push %r15
push %r14
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov (%rsi),%r15
mov 0x8(%rsi),%rax
sub %r15,%rax
mov %rax,0x8(%rsp)
sar $0x2,%rax
mov %rax,%r8
mov %rax,%r14
shr %r8... | _Z5func0RSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 18h
mov rax, [rsi]
mov r14, [rsi+8]
sub r14, rax
mov r13, r14
mov rdx, r14
sar r13, 2
mov r8, r13
shr r8, 1
jz loc_17CC
nop ... | long long func0(long long a1, _QWORD *a2)
{
_DWORD *v4; // rax
long long v5; // r14
long long v6; // rdx
unsigned long long v7; // r13
unsigned long long v8; // r8
long long v9; // r10
unsigned long long v10; // r15
_DWORD *v11; // r14
int v12; // r11d
_DWORD *v13; // r9
_DWORD *v14; // rsi
uns... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x18
MOV RAX,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
SUB R14,RAX
MOV R13,R14
MOV RDX,R14
SAR R13,0x2
MOV R8,R13
SHR R8,0x1
JZ 0x001017cc
NOP dword ptr [RAX + RAX*0x1]
LAB_001016c0:
LEA R10,[R8*0x4]
MOV R15,R8
LEA ... | /* func0(std::vector<int, std::allocator<int> >&) */
vector * func0(vector *param_1)
{
int iVar1;
long lVar2;
int4 *__src;
int *piVar3;
int *piVar4;
int4 *__dest;
ulong uVar5;
size_t __n;
long *in_RSI;
int *piVar6;
ulong uVar7;
ulong uVar8;
ulong uVar9;
int *piVar10;
ulong uVar11;
l... |
1,711 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int>& my_list) {
size_t n = my_list.size();
size_t gap = n / 2;
while (gap > 0) {
for (size_t i = gap; i < n; i++) {
int current_item = my_list[i];
size_t j = i;
while (j >= gap && my_list[j - gap] > current_item) {
... | int main() {
std::vector<int> list1 = {12, 23, 4, 5, 3, 2, 12, 81, 56, 95};
std::vector<int> sorted_list1 = {2, 3, 4, 5, 12, 12, 23, 56, 81, 95};
assert(func0(list1) == sorted_list1);
std::vector<int> list2 = {24, 22, 39, 34, 87, 73, 68};
std::vector<int> sorted_list2 = {22, 24, 34, 39, 68, 7... | O3 | cpp | func0(std::vector<int, std::allocator<int> >&):
endbr64
push %r15
push %r14
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov (%rsi),%r15
mov 0x8(%rsi),%rax
sub %r15,%rax
mov %rax,0x8(%rsp)
sar $0x2,%rax
mov %rax,%r9
mov %rax,%r14
shr %r9... | _Z5func0RSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 18h
mov rax, [rsi]
mov r14, [rsi+8]
sub r14, rax
mov r13, r14
mov rcx, r14
sar r13, 2
mov rdx, r13
shr rdx, 1
jz loc_17BA
nop ... | long long func0(long long a1, _QWORD *a2)
{
_DWORD *v4; // rax
long long v5; // r14
long long v6; // rcx
unsigned long long v7; // r13
unsigned long long v8; // rdx
long long v9; // r9
unsigned long long v10; // r15
_DWORD *v11; // r14
int v12; // r11d
_DWORD *v13; // rdi
unsigned long long v14; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x18
MOV RAX,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
SUB R14,RAX
MOV R13,R14
MOV RCX,R14
SAR R13,0x2
MOV RDX,R13
SHR RDX,0x1
JZ 0x001017ba
NOP dword ptr [RAX + RAX*0x1]
LAB_001016c0:
LEA R9,[RDX*0x4]
MOV R15,RDX
L... | /* func0(std::vector<int, std::allocator<int> >&) */
vector * func0(vector *param_1)
{
int iVar1;
long lVar2;
int4 *__src;
int *piVar3;
int *piVar4;
int4 *__dest;
ulong uVar5;
size_t __n;
long *in_RSI;
ulong uVar6;
int *piVar7;
ulong uVar8;
ulong uVar9;
int *piVar10;
ulong uVar11;
l... |
1,712 | func0 |
#include <tuple>
#include <utility>
#include <assert.h>
| std::tuple<int, int, int, int> func0(std::tuple<int, int, int, int> test_tup1, std::tuple<int, int, int, int> test_tup2) {
return std::make_tuple(
std::get<0>(test_tup1) & std::get<0>(test_tup2),
std::get<1>(test_tup1) & std::get<1>(test_tup2),
std::get<2>(test_tup1) & std::get<2>(test_t... | int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(0, 0, 2, 1));
assert(func0(std::make_tuple(1, 2, 3, 4), std::make_tuple(5, 6, 7, 8)) == std::make_tuple(1, 2, 3, 0));
assert(func0(std::make_tuple(8, 9, 11, 12), std::make_tuple(7, 13, 14, 17)) == std:... | O0 | cpp | func0(std::tuple<int, int, int, int>, std::tuple<int, int, int, int>):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq ... | _Z5func0St5tupleIJiiiiEES0_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZSt3getILm3EJiiiiEERNSt13tuple_e... | long long func0(long long a1, long long a2, long long a3)
{
int v3; // ebx
int v4; // ebx
int v5; // ebx
int v6; // ebx
int v9; // [rsp+28h] [rbp-28h] BYREF
int v10; // [rsp+2Ch] [rbp-24h] BYREF
int v11; // [rsp+30h] [rbp-20h] BYREF
int v12; // [rsp+34h] [rbp-1Ch] BYREF
unsigned long long v13; // [rs... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x001016ed
MOV EBX,dword ptr [RAX]
MOV RAX,qw... | /* func0(std::tuple<int, int, int, int>, std::tuple<int, int, int, int>) */
int * func0(tuple param_1,tuple param_2)
{
uint uVar1;
type *ptVar2;
type *ptVar3;
type *ptVar4;
type *ptVar5;
tuple *in_RDX;
int4 in_register_00000034;
tuple *ptVar6;
int4 in_register_0000003c;
long in_FS_OFFSET;
uint l... |
1,713 | func0 |
#include <tuple>
#include <utility>
#include <assert.h>
| std::tuple<int, int, int, int> func0(std::tuple<int, int, int, int> test_tup1, std::tuple<int, int, int, int> test_tup2) {
return std::make_tuple(
std::get<0>(test_tup1) & std::get<0>(test_tup2),
std::get<1>(test_tup1) & std::get<1>(test_tup2),
std::get<2>(test_tup1) & std::get<2>(test_t... | int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(0, 0, 2, 1));
assert(func0(std::make_tuple(1, 2, 3, 4), std::make_tuple(5, 6, 7, 8)) == std::make_tuple(1, 2, 3, 0));
assert(func0(std::make_tuple(8, 9, 11, 12), std::make_tuple(7, 13, 14, 17)) == std:... | O1 | cpp | func0(std::tuple<int, int, int, int>, std::tuple<int, int, int, int>):
endbr64
mov %rdi,%rax
mov 0x4(%rsi),%r8d
and 0x4(%rdx),%r8d
mov 0x8(%rsi),%edi
and 0x8(%rdx),%edi
mov 0xc(%rsi),%ecx
and 0xc(%rdx),%ecx
mov (%rsi),%esi
and (%rdx),%esi
mov %esi,(%rax)
mov %r8d,0x4(%rax)
mov %edi,0... | _Z5func0St5tupleIJiiiiEES0_:
endbr64
mov rax, rdi
mov r8d, [rsi+4]
and r8d, [rdx+4]
mov edi, [rsi+8]
and edi, [rdx+8]
mov ecx, [rsi+0Ch]
and ecx, [rdx+0Ch]
mov esi, [rsi]
and esi, [rdx]
mov [rax], esi
mov [rax+4], r8d
mov [rax+8], edi
mov [rax+0Ch], ecx
retn | int * func0(int *a1, _DWORD *a2, _DWORD *a3)
{
int *result; // rax
int v4; // r8d
int v5; // edi
int v6; // ecx
result = a1;
v4 = a3[1] & a2[1];
v5 = a3[2] & a2[2];
v6 = a3[3] & a2[3];
*result = *a3 & *a2;
result[1] = v4;
result[2] = v5;
result[3] = v6;
return result;
} | func0:
ENDBR64
MOV RAX,RDI
MOV R8D,dword ptr [RSI + 0x4]
AND R8D,dword ptr [RDX + 0x4]
MOV EDI,dword ptr [RSI + 0x8]
AND EDI,dword ptr [RDX + 0x8]
MOV ECX,dword ptr [RSI + 0xc]
AND ECX,dword ptr [RDX + 0xc]
MOV ESI,dword ptr [RSI]
AND ESI,dword ptr [RDX]
MOV dword ptr [RAX],ESI
MOV dword ptr [RAX + 0x4],R8D
MOV dword p... | /* func0(std::tuple<int, int, int, int>, std::tuple<int, int, int, int>) */
void func0(tuple param_1,tuple param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
uint *in_RDX;
int4 in_register_00000034;
uint *puVar7;
int4 in_register_0000003c;
uint *puVar8;
puVar... |
1,714 | func0 |
#include <tuple>
#include <utility>
#include <assert.h>
| std::tuple<int, int, int, int> func0(std::tuple<int, int, int, int> test_tup1, std::tuple<int, int, int, int> test_tup2) {
return std::make_tuple(
std::get<0>(test_tup1) & std::get<0>(test_tup2),
std::get<1>(test_tup1) & std::get<1>(test_tup2),
std::get<2>(test_tup1) & std::get<2>(test_t... | int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(0, 0, 2, 1));
assert(func0(std::make_tuple(1, 2, 3, 4), std::make_tuple(5, 6, 7, 8)) == std::make_tuple(1, 2, 3, 0));
assert(func0(std::make_tuple(8, 9, 11, 12), std::make_tuple(7, 13, 14, 17)) == std:... | O2 | cpp | func0(std::tuple<int, int, int, int>, std::tuple<int, int, int, int>):
endbr64
mov 0x8(%rsi),%rcx
mov %rdi,%rax
mov 0x8(%rdx),%rdi
mov (%rsi),%rsi
and (%rdx),%rsi
and %rdi,%rcx
mov %rsi,(%rax)
mov %rcx,0x8(%rax)
retq
| _Z5func0St5tupleIJiiiiEES0_:
endbr64
movdqu xmm0, xmmword ptr [rsi]
movdqu xmm1, xmmword ptr [rdx]
mov rax, rdi
pand xmm0, xmm1
movups xmmword ptr [rdi], xmm0
retn | __m128i * func0(__m128i *a1, const __m128i *a2, const __m128i *a3)
{
__m128i *result; // rax
result = a1;
*a1 = _mm_and_si128(_mm_loadu_si128(a2), _mm_loadu_si128(a3));
return result;
} | func0:
ENDBR64
MOVDQU XMM0,xmmword ptr [RSI]
MOVDQU XMM1,xmmword ptr [RDX]
MOV RAX,RDI
PAND XMM0,XMM1
MOVUPS xmmword ptr [RDI],XMM0
RET | /* func0(std::tuple<int, int, int, int>, std::tuple<int, int, int, int>) */
int8 func0(tuple param_1,tuple param_2)
{
ulong uVar1;
ulong uVar2;
ulong *in_RDX;
int4 in_register_00000034;
int4 in_register_0000003c;
uVar1 = ((ulong *)CONCAT44(in_register_00000034,param_2))[1];
uVar2 = in_RDX[1];
*(ulo... |
1,715 | func0 |
#include <tuple>
#include <utility>
#include <assert.h>
| std::tuple<int, int, int, int> func0(std::tuple<int, int, int, int> test_tup1, std::tuple<int, int, int, int> test_tup2) {
return std::make_tuple(
std::get<0>(test_tup1) & std::get<0>(test_tup2),
std::get<1>(test_tup1) & std::get<1>(test_tup2),
std::get<2>(test_tup1) & std::get<2>(test_t... | int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(0, 0, 2, 1));
assert(func0(std::make_tuple(1, 2, 3, 4), std::make_tuple(5, 6, 7, 8)) == std::make_tuple(1, 2, 3, 0));
assert(func0(std::make_tuple(8, 9, 11, 12), std::make_tuple(7, 13, 14, 17)) == std:... | O3 | cpp | func0(std::tuple<int, int, int, int>, std::tuple<int, int, int, int>):
endbr64
movdqu (%rsi),%xmm0
movdqu (%rdx),%xmm1
mov %rdi,%rax
pand %xmm1,%xmm0
movups %xmm0,(%rdi)
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0St5tupleIJiiiiEES0_:
endbr64
movdqu xmm0, xmmword ptr [rsi]
movdqu xmm1, xmmword ptr [rdx]
mov rax, rdi
pand xmm0, xmm1
movups xmmword ptr [rdi], xmm0
retn | __m128i * func0(__m128i *a1, const __m128i *a2, const __m128i *a3)
{
__m128i *result; // rax
result = a1;
*a1 = _mm_and_si128(_mm_loadu_si128(a2), _mm_loadu_si128(a3));
return result;
} | func0:
ENDBR64
MOVDQU XMM0,xmmword ptr [RSI]
MOVDQU XMM1,xmmword ptr [RDX]
MOV RAX,RDI
PAND XMM0,XMM1
MOVUPS xmmword ptr [RDI],XMM0
RET | /* func0(std::tuple<int, int, int, int>, std::tuple<int, int, int, int>) */
int8 func0(tuple param_1,tuple param_2)
{
ulong uVar1;
ulong uVar2;
ulong *in_RDX;
int4 in_register_00000034;
int4 in_register_0000003c;
uVar1 = ((ulong *)CONCAT44(in_register_00000034,param_2))[1];
uVar2 = in_RDX[1];
*(ulo... |
1,716 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
int directrix = c - ((b * b) + 1) * 4 * a;
return directrix;
}
| int main() {
assert(func0(5, 3, 2) == -198);
assert(func0(9, 8, 4) == -2336);
assert(func0(2, 4, 6) == -130);
return 0;
}
| O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x18(%rbp),%eax
imul %eax,%eax
add $0x1,%eax
imul -0x14(%rbp),%eax
lea 0x0(,%rax,4),%edx
mov -0x1c(%rbp),%eax
sub %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),... | _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov eax, [rbp+var_18]
imul eax, eax
add eax, 1
imul eax, [rbp+var_14]
lea edx, ds:0[rax*4]
mov eax, [rbp+var_1C]
sub eax, edx
mov [rbp+var_4], eax
mov eax, [r... | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a3 - 4 * a1 * (a2 * a2 + 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x18]
IMUL EAX,EAX
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x14]
LEA EDX,[RAX*0x4]
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV E... | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
return param_3 + (param_2 * param_2 + 1) * param_1 * -4;
} |
1,717 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
int directrix = c - ((b * b) + 1) * 4 * a;
return directrix;
}
| int main() {
assert(func0(5, 3, 2) == -198);
assert(func0(9, 8, 4) == -2336);
assert(func0(2, 4, 6) == -130);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
imul %esi,%esi
add $0x1,%esi
imul %edi,%esi
shl $0x2,%esi
mov %edx,%eax
sub %esi,%eax
retq
| _Z5func0iii:
endbr64
imul esi, esi
add esi, 1
imul esi, edi
shl esi, 2
mov eax, edx
sub eax, esi
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a3 - 4 * a1 * (a2 * a2 + 1));
} | func0:
ENDBR64
IMUL ESI,ESI
ADD ESI,0x1
IMUL ESI,EDI
SHL ESI,0x2
MOV EAX,EDX
SUB EAX,ESI
RET | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
return param_3 + (param_2 * param_2 + 1) * param_1 * -4;
} |
1,718 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
int directrix = c - ((b * b) + 1) * 4 * a;
return directrix;
}
| int main() {
assert(func0(5, 3, 2) == -198);
assert(func0(9, 8, 4) == -2336);
assert(func0(2, 4, 6) == -130);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
imul %esi,%esi
mov %edx,%eax
add $0x1,%esi
imul %edi,%esi
shl $0x2,%esi
sub %esi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0iii:
endbr64
imul esi, esi
mov eax, edx
add esi, 1
imul esi, edi
shl esi, 2
sub eax, esi
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a3 - 4 * a1 * (a2 * a2 + 1));
} | func0:
ENDBR64
IMUL ESI,ESI
MOV EAX,EDX
ADD ESI,0x1
IMUL ESI,EDI
SHL ESI,0x2
SUB EAX,ESI
RET | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
return param_3 + (param_2 * param_2 + 1) * param_1 * -4;
} |
1,719 | func0 | #include <assert.h>
| int func0(int a, int b, int c) {
int directrix = c - ((b * b) + 1) * 4 * a;
return directrix;
}
| int main() {
assert(func0(5, 3, 2) == -198);
assert(func0(9, 8, 4) == -2336);
assert(func0(2, 4, 6) == -130);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
imul %esi,%esi
mov %edx,%eax
add $0x1,%esi
imul %edi,%esi
shl $0x2,%esi
sub %esi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0iii:
endbr64
imul esi, esi
mov eax, edx
add esi, 1
imul esi, edi
shl esi, 2
sub eax, esi
retn | long long func0(int a1, int a2, int a3)
{
return (unsigned int)(a3 - 4 * a1 * (a2 * a2 + 1));
} | func0:
ENDBR64
IMUL ESI,ESI
MOV EAX,EDX
ADD ESI,0x1
IMUL ESI,EDI
SHL ESI,0x2
SUB EAX,ESI
RET | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
return param_3 + (param_2 * param_2 + 1) * param_1 * -4;
} |
1,720 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
bool common_element(const vector<char>& list1, const vector<char>& list2) {
for (char x : list1) {
for (char y : list2) {
if (x == y) {
return true;
}
}
}
ret... | bool func0(const vector<int>& list1, const vector<int>& list2) {
for (int x : list1) {
for (int y : list2) {
if (x == y) {
return true;
}
}
}
return false;
}
| int main() {
vector<int> list1 = {1,2,3,4,5};
vector<int> list2 = {5,6,7,8,9};
vector<int> list3 = {6,7,8,9};
vector<char> list4 = {'a','b','c'};
vector<char> list5 = {'d','b','e'};
assert(func0(list1, list2) == true);
assert(func0(list1, list3) == false);
assert(comm... | O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
mov %rax,-0x18(%rbp)
mov ... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_48]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vectorIiSa... | long long func0(long long a1, long long a2)
{
int v3; // [rsp+10h] [rbp-40h]
long long v4; // [rsp+18h] [rbp-38h] BYREF
long long v5; // [rsp+20h] [rbp-30h] BYREF
long long v6; // [rsp+28h] [rbp-28h] BYREF
_QWORD v7[2]; // [rsp+30h] [rbp-20h] BYREF
long long v8; // [rsp+40h] [rbp-10h]
unsigned long long ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101a02
MOV qword pt... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int8 func0(vector *param_1,vector *param_2)
{
int iVar1;
bool bVar2;
int *piVar3;
int8 uVar4;
long in_FS_OFFSET;
int8 local_40;
int8 local_38;
int8 local_30;
int8 local_28;
vector<int,std::... |
1,721 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
bool common_element(const vector<char>& list1, const vector<char>& list2) {
for (char x : list1) {
for (char y : list2) {
if (x == y) {
return true;
}
}
}
ret... | bool func0(const vector<int>& list1, const vector<int>& list2) {
for (int x : list1) {
for (int y : list2) {
if (x == y) {
return true;
}
}
}
return false;
}
| int main() {
vector<int> list1 = {1,2,3,4,5};
vector<int> list2 = {5,6,7,8,9};
vector<int> list3 = {6,7,8,9};
vector<char> list4 = {'a','b','c'};
vector<char> list5 = {'d','b','e'};
assert(func0(list1, list2) == true);
assert(func0(list1, list3) == false);
assert(comm... | O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
mov %rsi,%rax
mov (%rdi),%rsi
mov 0x8(%rdi),%r8
cmp %r8,%rsi
je 12d6 <_Z5func0RKSt6vectorIiSaIiEES3_+0x40>
mov (%rax),%rdi
mov 0x8(%rax),%rdx
mov (%rsi),%ecx
cmp %rdi,%rdx
je 12c7... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
mov rax, rsi
mov rsi, [rdi]
mov r8, [rdi+8]
cmp r8, rsi
jz short loc_1296
mov rdi, [rax]
mov rdx, [rax+8]
loc_1270:
mov ecx, [rsi]
cmp rdi, rdx
jz short loc_1287
mov rax, rdi
loc_127A:
cmp ecx, [rax]
jz short loc_129C
add ... | long long func0(long long a1, _QWORD *a2)
{
_DWORD *v3; // rsi
_DWORD *v4; // r8
_DWORD *v5; // rdi
_DWORD *v6; // rdx
_DWORD *v7; // rax
v3 = *(_DWORD **)a1;
v4 = *(_DWORD **)(a1 + 8);
if ( v4 == *(_DWORD **)a1 )
return 0LL;
v5 = (_DWORD *)*a2;
v6 = (_DWORD *)a2[1];
while ( v5 == v6 )
{
L... | func0:
ENDBR64
MOV RAX,RSI
MOV RSI,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
CMP R8,RSI
JZ 0x00101296
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
LAB_00101270:
MOV ECX,dword ptr [RSI]
CMP RDI,RDX
JZ 0x00101287
MOV RAX,RDI
LAB_0010127a:
CMP ECX,dword ptr [RAX]
JZ 0x0010129c
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x001... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int8 func0(vector *param_1,vector *param_2)
{
int *piVar1;
int *piVar2;
piVar2 = *(int **)param_1;
if (*(int **)(param_1 + 8) == piVar2) {
return 0;
}
do {
for (piVar1 = *(int **)param_2... |
1,722 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
bool common_element(const vector<char>& list1, const vector<char>& list2) {
for (char x : list1) {
for (char y : list2) {
if (x == y) {
return true;
}
}
}
ret... | bool func0(const vector<int>& list1, const vector<int>& list2) {
for (int x : list1) {
for (int y : list2) {
if (x == y) {
return true;
}
}
}
return false;
}
| int main() {
vector<int> list1 = {1,2,3,4,5};
vector<int> list2 = {5,6,7,8,9};
vector<int> list3 = {6,7,8,9};
vector<char> list4 = {'a','b','c'};
vector<char> list5 = {'d','b','e'};
assert(func0(list1, list2) == true);
assert(func0(list1, list3) == false);
assert(comm... | O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
mov %rsi,%rax
mov 0x8(%rdi),%r8
mov (%rdi),%rsi
cmp %r8,%rsi
je 16c1 <_Z5func0RKSt6vectorIiSaIiEES3_+0x51>
mov (%rax),%rdi
mov 0x8(%rax),%rdx
mov (%rsi),%ecx
cmp %rdx,%rdi
je 16b8... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
mov rax, rsi
mov r8, [rdi+8]
mov rsi, [rdi]
cmp r8, rsi
jz short loc_1541
mov rdi, [rax]
mov rdx, [rax+8]
loc_150A:
mov ecx, [rsi]
cmp rdi, rdx
jz short loc_1538
mov rax, rdi
jmp short loc_1529
loc_1520:
add rax, 4
cmp rdx... | long long func0(long long a1, _QWORD *a2)
{
_DWORD *v3; // r8
_DWORD *v4; // rsi
_DWORD *v5; // rdi
_DWORD *v6; // rdx
_DWORD *v7; // rax
v3 = *(_DWORD **)(a1 + 8);
v4 = *(_DWORD **)a1;
if ( v3 == *(_DWORD **)a1 )
return 0LL;
v5 = (_DWORD *)*a2;
v6 = (_DWORD *)a2[1];
while ( v5 == v6 )
{
L... | func0:
ENDBR64
MOV RAX,RSI
MOV R8,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
CMP R8,RSI
JZ 0x00101541
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
LAB_0010150a:
MOV ECX,dword ptr [RSI]
CMP RDI,RDX
JZ 0x00101538
MOV RAX,RDI
JMP 0x00101529
LAB_00101520:
ADD RAX,0x4
CMP RDX,RAX
JZ 0x00101538
LAB_00101529:
CMP ... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int8 func0(vector *param_1,vector *param_2)
{
int *piVar1;
int *piVar2;
piVar2 = *(int **)param_1;
if (*(int **)(param_1 + 8) != piVar2) {
do {
for (piVar1 = *(int **)param_2; piVar1 != *(... |
1,723 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
bool common_element(const vector<char>& list1, const vector<char>& list2) {
for (char x : list1) {
for (char y : list2) {
if (x == y) {
return true;
}
}
}
ret... | bool func0(const vector<int>& list1, const vector<int>& list2) {
for (int x : list1) {
for (int y : list2) {
if (x == y) {
return true;
}
}
}
return false;
}
| int main() {
vector<int> list1 = {1,2,3,4,5};
vector<int> list2 = {5,6,7,8,9};
vector<int> list3 = {6,7,8,9};
vector<char> list4 = {'a','b','c'};
vector<char> list5 = {'d','b','e'};
assert(func0(list1, list2) == true);
assert(func0(list1, list3) == false);
assert(comm... | O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
mov %rsi,%rax
mov 0x8(%rdi),%r8
mov (%rdi),%rsi
cmp %r8,%rsi
je 1681 <_Z5func0RKSt6vectorIiSaIiEES3_+0x51>
mov (%rax),%rdi
mov 0x8(%rax),%rdx
mov (%rsi),%ecx
cmp %rdx,%rdi
je 1678... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
mov rax, rsi
mov r8, [rdi+8]
mov rsi, [rdi]
cmp r8, rsi
jz short loc_15D1
mov rdi, [rax]
mov rdx, [rax+8]
loc_159A:
mov ecx, [rsi]
cmp rdi, rdx
jz short loc_15C8
mov rax, rdi
jmp short loc_15B9
loc_15B0:
add rax, 4
cmp rdx... | long long func0(long long a1, _QWORD *a2)
{
_DWORD *v3; // r8
_DWORD *v4; // rsi
_DWORD *v5; // rdi
_DWORD *v6; // rdx
_DWORD *v7; // rax
v3 = *(_DWORD **)(a1 + 8);
v4 = *(_DWORD **)a1;
if ( v3 == *(_DWORD **)a1 )
return 0LL;
v5 = (_DWORD *)*a2;
v6 = (_DWORD *)a2[1];
while ( v5 == v6 )
{
L... | func0:
ENDBR64
MOV RAX,RSI
MOV R8,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
CMP R8,RSI
JZ 0x001015d1
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
LAB_0010159a:
MOV ECX,dword ptr [RSI]
CMP RDI,RDX
JZ 0x001015c8
MOV RAX,RDI
JMP 0x001015b9
LAB_001015b0:
ADD RAX,0x4
CMP RDX,RAX
JZ 0x001015c8
LAB_001015b9:
CMP ... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int8 func0(vector *param_1,vector *param_2)
{
int *piVar1;
int *piVar2;
piVar2 = *(int **)param_1;
if (*(int **)(param_1 + 8) != piVar2) {
do {
for (piVar1 = *(int **)param_2; piVar1 != *(... |
1,724 | func0 |
#include <assert.h>
| double func0(double base1, double base2, double height) {
double median = 0.5 * (base1 + base2);
return median;
}
| int main() {
assert(func0(15, 25, 35) == 20);
assert(func0(10, 20, 30) == 15);
assert(func0(6, 9, 4) == 7.5);
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 0xf2a(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq... | _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 [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1, double a2, double a3)
{
return 0.5 * (a1 + a2);
} | 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 qword ptr [RBP + -0x8],XMM0
MOVSD XM... | /* func0(double, double, double) */
double func0(double param_1,double param_2,double param_3)
{
return DAT_00102080 * (param_1 + param_2);
} |
1,725 | func0 |
#include <assert.h>
| double func0(double base1, double base2, double height) {
double median = 0.5 * (base1 + base2);
return median;
}
| int main() {
assert(func0(15, 25, 35) == 20);
assert(func0(10, 20, 30) == 15);
assert(func0(6, 9, 4) == 7.5);
return 0;
}
| O1 | cpp | func0(double, double, double):
endbr64
addsd %xmm1,%xmm0
mulsd 0xecf(%rip),%xmm0
retq
| _Z5func0ddd:
endbr64
addsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
retn | double func0(double a1, double a2, double a3)
{
return (a1 + a2) * 0.5;
} | func0:
ENDBR64
ADDSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
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;
} |
1,726 | func0 |
#include <assert.h>
| double func0(double base1, double base2, double height) {
double median = 0.5 * (base1 + base2);
return median;
}
| int main() {
assert(func0(15, 25, 35) == 20);
assert(func0(10, 20, 30) == 15);
assert(func0(6, 9, 4) == 7.5);
return 0;
}
| O2 | cpp | func0(double, double, double):
endbr64
addsd %xmm1,%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0ddd:
endbr64
addsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
retn | double func0(double a1, double a2, double a3)
{
return (a1 + a2) * 0.5;
} | func0:
ENDBR64
ADDSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
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;
} |
1,727 | func0 |
#include <assert.h>
| double func0(double base1, double base2, double height) {
double median = 0.5 * (base1 + base2);
return median;
}
| int main() {
assert(func0(15, 25, 35) == 20);
assert(func0(10, 20, 30) == 15);
assert(func0(6, 9, 4) == 7.5);
return 0;
}
| O3 | cpp | func0(double, double, double):
endbr64
addsd %xmm1,%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0ddd:
endbr64
addsd xmm0, xmm1
mulsd xmm0, cs:qword_2008
retn | double func0(double a1, double a2, double a3)
{
return (a1 + a2) * 0.5;
} | func0:
ENDBR64
ADDSD XMM0,XMM1
MULSD XMM0,qword ptr [0x00102008]
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;
} |
1,728 | func0 |
#include <vector>
#include <algorithm>
#include <string>
#include <assert.h>
| std::string func0(const std::vector<int>& arr, int number) {
std::vector<int> sorted_arr = arr;
std::sort(sorted_arr.begin(), sorted_arr.end());
if (number > sorted_arr.back()) {
return "Yes, the entered number is greater than those in the array";
} else {
return "No, entered numbe... | int main() {
assert(func0({1, 2, 3, 4, 5}, 4) == "No, entered number is less than those in the array");
assert(func0({2, 3, 4, 5, 6}, 8) == "Yes, the entered number is greater than those in the array");
assert(func0({9, 7, 4, 8, 6, 1}, 11) == "Yes, the entered number is greater than those in the array");... | O0 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&, 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 -0x50(%rbp),%rdx
lea -0x30(%rbp),%rax
m... | _Z5func0B5cxx11RKSt6vectorIiSaIiEEi:
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 rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rdx, [rbp+var_60]
lea rax, [rbp+var_30]
mov rsi, rdx
mov ... | long long func0[abi:cxx11](long long a1, long long a2, int a3)
{
long long v3; // rbx
long long v4; // rax
char v7; // [rsp+2Fh] [rbp-41h] BYREF
char *v8; // [rsp+30h] [rbp-40h]
char *v9; // [rsp+38h] [rbp-38h]
_BYTE v10[24]; // [rsp+40h] [rbp-30h] BYREF
unsigned long long v11; // [rsp+58h] [rbp-18h]
... | func0[abi:cxx11]:
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 RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RBP + -0x60]
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
LAB_0... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&, int) */
vector * func0_abi_cxx11_(vector *param_1,int param_2)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
int *piVar3;
int in_EDX;
int4 in_register_00000034;
long in_FS_OFFSET;
allocator local_49;
allocator *local_48;
alloca... |
1,729 | func0 |
#include <vector>
#include <algorithm>
#include <string>
#include <assert.h>
| std::string func0(const std::vector<int>& arr, int number) {
std::vector<int> sorted_arr = arr;
std::sort(sorted_arr.begin(), sorted_arr.end());
if (number > sorted_arr.back()) {
return "Yes, the entered number is greater than those in the array";
} else {
return "No, entered numbe... | int main() {
assert(func0({1, 2, 3, 4, 5}, 4) == "No, entered number is less than those in the array");
assert(func0({2, 3, 4, 5, 6}, 8) == "Yes, the entered number is greater than those in the array");
assert(func0({9, 7, 4, 8, 6, 1}, 11) == "Yes, the entered number is greater than those in the array");... | O1 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %rsi,%rbx
mov %edx,%r13d
mov 0x8(%rsi),%rdi
sub (%rsi),%rdi
mov %rdi,%rax
sar $0x2,%rax
je 135f <_Z5func0B5cxx11RKSt6vectorIiSaIiEEi+0xb6>
... | _Z5func0B5cxx11RKSt6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r13, rdi
mov rbx, rsi
mov r15d, edx
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov r14, [rsi+8]
sub r14, [rsi]
jz loc_13B9
mov ra... | _QWORD * func0[abi:cxx11](_QWORD *a1, _QWORD *a2, int a3, long long a4, long long a5, long long a6)
{
unsigned long long v8; // r14
int *v9; // rbp
_DWORD *v10; // rsi
signed long long v11; // rbx
int *v12; // r12
unsigned long long v13; // rax
int *v14; // rbx
int *v15; // rsi
int *v16; // rax
int ... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R13,RDI
MOV RBX,RSI
MOV R15D,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV R14,qword ptr [RSI + 0x8]
SUB R14,qword ptr [RSI]
JZ 0x001013b9
MOV RAX,0x7ffffffffffffffc
CMP RAX,R14
JC 0x0010139... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&, int) */
vector * func0_abi_cxx11_(vector *param_1,int param_2,int param_3,int param_4,
int param_5,int param_6,int param_7,int param_8,
int8 param_9)
{
int iVar1;
int iVar2;
long lVar3;
int4 *_... |
1,730 | func0 |
#include <vector>
#include <algorithm>
#include <string>
#include <assert.h>
| std::string func0(const std::vector<int>& arr, int number) {
std::vector<int> sorted_arr = arr;
std::sort(sorted_arr.begin(), sorted_arr.end());
if (number > sorted_arr.back()) {
return "Yes, the entered number is greater than those in the array";
} else {
return "No, entered numbe... | int main() {
assert(func0({1, 2, 3, 4, 5}, 4) == "No, entered number is less than those in the array");
assert(func0({2, 3, 4, 5, 6}, 8) == "Yes, the entered number is greater than those in the array");
assert(func0({9, 7, 4, 8, 6, 1}, 11) == "Yes, the entered number is greater than those in the array");... | O2 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
push %r14
mov %edx,%r14d
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
mov 0x8(%rbx),%rax
mov (%rsi),%rsi
mov %rax,%r12
sub %rsi,%r12
mov %r12,%rdx
sar $0... | _Z5func0B5cxx11RKSt6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
mov r13d, edx
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
mov r12, [rsi+8]
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
sub r12, [rsi]
jz loc_1AE0
mov rax, 7FFFFFFFFFFFFF... | _QWORD * func0[abi:cxx11](_QWORD *a1, _QWORD *a2, int a3)
{
unsigned long long v5; // r12
_DWORD *v7; // rax
long long v8; // rcx
long long v9; // r8
long long v10; // r9
_DWORD *v11; // rsi
_DWORD *v12; // rbx
signed long long v13; // r14
_DWORD *v14; // r15
unsigned long long v15; // rdx
long lo... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13D,EDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x28
MOV R12,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
SUB R12,qword ptr [RSI]
JZ 0x00101ae0
MOV RAX,0x7ffffffffffffffc
CMP RAX,R12
JC 0x00101b38
MOV R14,RS... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&, int) */
vector * func0_abi_cxx11_(vector *param_1,int param_2,int param_3,int param_4,
int param_5,int param_6,int param_7,int param_8,
int8 param_9)
{
int iVar1;
int iVar2;
long lVar3;
int *__... |
1,731 | func0 |
#include <vector>
#include <algorithm>
#include <string>
#include <assert.h>
| std::string func0(const std::vector<int>& arr, int number) {
std::vector<int> sorted_arr = arr;
std::sort(sorted_arr.begin(), sorted_arr.end());
if (number > sorted_arr.back()) {
return "Yes, the entered number is greater than those in the array";
} else {
return "No, entered numbe... | int main() {
assert(func0({1, 2, 3, 4, 5}, 4) == "No, entered number is less than those in the array");
assert(func0({2, 3, 4, 5, 6}, 8) == "Yes, the entered number is greater than those in the array");
assert(func0({9, 7, 4, 8, 6, 1}, 11) == "Yes, the entered number is greater than those in the array");... | O3 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x28,%rsp
mov (%rsi),%rsi
mov %edx,0xc(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov 0x8(%rbx)... | _Z5func0B5cxx11RKSt6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 48h
mov r12, [rsi+8]
mov [rsp+78h+var_6C], edx
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
sub r12, [rsi]
jz loc_1980
mov rax, 7F... | long long * func0[abi:cxx11](long long *a1, _QWORD *a2, int a3)
{
_DWORD *v3; // rbx
long long v4; // r14
_DWORD *v5; // r15
long long v6; // r12
unsigned long long v7; // r12
_QWORD *v8; // r14
_DWORD *v9; // rax
long long v10; // r9
signed long long v11; // r9
bool v12; // zf
_DWORD *v13; // r13... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x48
MOV R12,qword ptr [RSI + 0x8]
MOV dword ptr [RSP + 0xc],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
SUB R12,qword ptr [RSI]
JZ 0x00101980
MOV RAX,0x7ffffffffffffffc
CMP RAX,R12
JC 0x00... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&, int) */
vector * func0_abi_cxx11_(vector *param_1,int param_2,int param_3,int param_4,
int param_5,int param_6,int param_7,int param_8,
... |
1,732 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
using namespace std;
| string func0(string text) {
regex pattern("ab+?");
if (regex_search(text, pattern)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Not matched!");
assert(func0("dc") == "Not matched!");
assert(func0("abba") == "Found a match!");
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 %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov $0x10,%edx
lea 0x2b3e... | _Z5func0NSt7__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, aAb; "ab+?"
mov r... | 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) */
string * func0(string *param_1,string *param_2)
{
bool bVar1;
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,"ab+?",0x10);
... |
1,733 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
using namespace std;
| string func0(string text) {
regex pattern("ab+?");
if (regex_search(text, pattern)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Not matched!");
assert(func0("dc") == "Not matched!");
assert(func0("abba") == "Found a match!");
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 $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 <_ZNSt6loca... | _Z5func0NSt7__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 __ZNS... | 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) */
long * func0(long *param_1,int8 *param_2)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
bool bVar3;
int iVar4;
long in_FS_OFFSET;
regex local_78 [8];
int local_70 [8];
int8 local_68;
_Sp_counted_base<(_Lock_policy)2> *local_60;
voi... | |
1,734 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
using namespace std;
| string func0(string text) {
regex pattern("ab+?");
if (regex_search(text, pattern)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Not matched!");
assert(func0("dc") == "Not matched!");
assert(func0("abba") == "Found a match!");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
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
mov ... | _Z5func0NSt7__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
x... | 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,[0x118607]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,... | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
bool bVar3;
int iVar4;
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;
local_30 = *(lo... |
1,735 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
using namespace std;
| string func0(string text) {
regex pattern("ab+?");
if (regex_search(text, pattern)) {
return "Found a match!";
} else {
return "Not matched!";
}
}
| int main() {
assert(func0("ac") == "Not matched!");
assert(func0("dc") == "Not matched!");
assert(func0("abba") == "Found a match!");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
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
mov ... | _Z5func0NSt7__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
cal... | 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,[0x11a64c]
PXOR XMM0,XMM0
LEA RDI,[RSP + 0x110]
MOV R8D,0x10
MOV RCX,R14
LEA RSI,[RD... | /* func0(std::string) */
long * func0(long *param_1,ulong *param_2)
{
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;
uint *puVar14;
_Match_mode _Var15;
long ... |
1,736 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
return (n % 10);
}
| int main() {
assert(func0(123) == 3);
assert(func0(25) == 5);
assert(func0(30) == 0);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%ecx
movslq %ecx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar $0x2,%edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
sub ... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov ecx, [rbp+var_4]
movsxd rax, ecx
imul rax, 66666667h
shr rax, 20h
mov edx, eax
sar edx, 2
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov eax, edx
shl eax, 2
add eax, edx
add eax, eax
sub ecx, eax... | long long func0(int a1)
{
return (unsigned int)(a1 % 10);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV ECX,dword ptr [RBP + -0x4]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x2
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL EAX,0x2
ADD EAX,EDX
ADD EAX,EAX
SUB ECX,EAX
MOV EDX,ECX
MOV EAX,EDX
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 % 10;
} |
1,737 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
return (n % 10);
}
| int main() {
assert(func0(123) == 3);
assert(func0(25) == 5);
assert(func0(30) == 0);
return 0;
}
| O1 | cpp | func0(int):
endbr64
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%edi
mov %edi,%eax
retq
| _Z5func0i:
endbr64
movsxd rax, edi
imul rax, 66666667h
sar rax, 22h
mov edx, edi
sar edx, 1Fh
sub eax, edx
lea edx, [rax+rax*4]
add edx, edx
mov eax, edi
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)(a1 % 10);
} | func0:
ENDBR64
MOVSXD RAX,EDI
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDX,EDI
SAR EDX,0x1f
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x4]
ADD EDX,EDX
MOV EAX,EDI
SUB EAX,EDX
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 % 10;
} |
1,738 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
return (n % 10);
}
| int main() {
assert(func0(123) == 3);
assert(func0(25) == 5);
assert(func0(30) == 0);
return 0;
}
| O2 | cpp | func0(int):
endbr64
movslq %edi,%rax
mov %edi,%edx
imul $0x66666667,%rax,%rax
sar $0x1f,%edx
sar $0x22,%rax
sub %edx,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%edi
mov %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0i:
endbr64
movsxd rax, edi
mov edx, edi
imul rax, 66666667h
sar edx, 1Fh
sar rax, 22h
sub eax, edx
lea edx, [rax+rax*4]
mov eax, edi
add edx, edx
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)(a1 % 10);
} | func0:
ENDBR64
MOVSXD RAX,EDI
MOV EDX,EDI
IMUL RAX,RAX,0x66666667
SAR EDX,0x1f
SAR RAX,0x22
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x4]
MOV EAX,EDI
ADD EDX,EDX
SUB EAX,EDX
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 % 10;
} |
1,739 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
return (n % 10);
}
| int main() {
assert(func0(123) == 3);
assert(func0(25) == 5);
assert(func0(30) == 0);
return 0;
}
| O3 | cpp | func0(int):
endbr64
movslq %edi,%rax
mov %edi,%edx
imul $0x66666667,%rax,%rax
sar $0x1f,%edx
sar $0x22,%rax
sub %edx,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%edi
mov %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0i:
endbr64
movsxd rax, edi
mov edx, edi
imul rax, 66666667h
sar edx, 1Fh
sar rax, 22h
sub eax, edx
lea edx, [rax+rax*4]
mov eax, edi
add edx, edx
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)(a1 % 10);
} | func0:
ENDBR64
MOVSXD RAX,EDI
MOV EDX,EDI
IMUL RAX,RAX,0x66666667
SAR EDX,0x1f
SAR RAX,0x22
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x4]
MOV EAX,EDI
ADD EDX,EDX
SUB EAX,EDX
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 % 10;
} |
1,740 | func0 |
#include <cassert>
#include <vector>
| int func0(const std::vector<int>& list1) {
for (int num : list1) {
if (num < 0) {
return num;
}
}
return 0; // If no negative number found, return 0 (not present in Python version, required for all control paths to return a value in C++)
}
| int main() {
assert(func0({-1, 4, 5, -6}) == -1);
assert(func0({-1, -2, 3, 4}) == -1);
assert(func0({-7, -6, 8, 9}) == -7);
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
mov -0x38(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 156c <_ZNKSt6vectorIiSaIiEE5be... | _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 rax, [rbp+var_38]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int... | long long func0(long long a1)
{
int v2; // [rsp+1Ch] [rbp-24h]
long long v3; // [rsp+20h] [rbp-20h] BYREF
_QWORD v4[3]; // [rsp+28h] [rbp-18h] BYREF
v4[2] = __readfsqword(0x28u);
v4[1] = a1;
v3 = std::vector<int>::begin(a1);
v4[0] = std::vector<int>::end(a1);
while ( (unsigned __int8)__gnu_cxx::operat... | 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 RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x001015f0
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qwor... | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
bool bVar1;
int iVar2;
int *piVar3;
long in_FS_OFFSET;
int8 local_28;
int8 local_20;
vector<int,std::allocator<int>> *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = (vector<in... |
1,741 | func0 |
#include <cassert>
#include <vector>
| int func0(const std::vector<int>& list1) {
for (int num : list1) {
if (num < 0) {
return num;
}
}
return 0; // If no negative number found, return 0 (not present in Python version, required for all control paths to return a value in C++)
}
| int main() {
assert(func0({-1, 4, 5, -6}) == -1);
assert(func0({-1, -2, 3, 4}) == -1);
assert(func0({-7, -6, 8, 9}) == -7);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rcx
cmp %rcx,%rax
je 1230 <_Z5func0RKSt6vectorIiSaIiEE+0x27>
mov (%rax),%edx
test %edx,%edx
js 122d <_Z5func0RKSt6vectorIiSaIiEE+0x24>
add $0x4,%rax
cmp %rax,%rcx
jne 1219 <_Z5func0RKSt6vectorIiSa... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rax, [rdi]
mov rcx, [rdi+8]
cmp rcx, rax
jz short loc_1230
loc_1219:
mov edx, [rax]
test edx, edx
js short loc_122D
add rax, 4
cmp rcx, rax
jnz short loc_1219
mov edx, 0
loc_122D:
mov eax, edx
retn
loc_1230:
mov edx, 0
jmp ... | long long func0(unsigned int **a1)
{
unsigned int *v1; // rax
unsigned int *v2; // rcx
unsigned int v3; // edx
v1 = *a1;
v2 = a1[1];
if ( v2 == *a1 )
{
return 0;
}
else
{
while ( 1 )
{
v3 = *v1;
if ( (*v1 & 0x80000000) != 0 )
break;
if ( v2 == ++v1 )
r... | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
CMP RCX,RAX
JZ 0x00101230
LAB_00101219:
MOV EDX,dword ptr [RAX]
TEST EDX,EDX
JS 0x0010122d
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x00101219
MOV EDX,0x0
LAB_0010122d:
MOV EAX,EDX
RET
LAB_00101230:
MOV EDX,0x0
JMP 0x0010122d | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
int *piVar1;
piVar1 = *(int **)param_1;
while( true ) {
if (*(int **)(param_1 + 8) == piVar1) {
return 0;
}
if (*piVar1 < 0) break;
piVar1 = piVar1 + 1;
}
return *piVar1;
} |
1,742 | func0 |
#include <cassert>
#include <vector>
| int func0(const std::vector<int>& list1) {
for (int num : list1) {
if (num < 0) {
return num;
}
}
return 0; // If no negative number found, return 0 (not present in Python version, required for all control paths to return a value in C++)
}
| int main() {
assert(func0({-1, 4, 5, -6}) == -1);
assert(func0({-1, -2, 3, 4}) == -1);
assert(func0({-7, -6, 8, 9}) == -7);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
cmp %rdx,%rax
jne 1431 <_Z5func0RKSt6vectorIiSaIiEE+0x21>
jmp 1440 <_Z5func0RKSt6vectorIiSaIiEE+0x30>
nopw 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %rax,%rdx
je 1440 <_Z5func0RKSt6vectorIiSaIiEE+0x30>
m... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rax, [rdi]
mov rcx, [rdi+8]
cmp rcx, rax
jnz short loc_13F1
jmp short loc_1400
loc_13E8:
add rax, 4
cmp rcx, rax
jz short loc_1400
loc_13F1:
mov edx, [rax]
test edx, edx
jns short loc_13E8
mov eax, edx
retn
loc_1400:
xor edx, e... | long long func0(unsigned int **a1)
{
unsigned int *v1; // rax
unsigned int *v2; // rcx
v1 = *a1;
v2 = a1[1];
if ( v2 == *a1 )
return 0LL;
while ( (*v1 & 0x80000000) == 0 )
{
if ( v2 == ++v1 )
return 0LL;
}
return *v1;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
CMP RCX,RAX
JNZ 0x001013f1
JMP 0x00101400
LAB_001013e8:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x00101400
LAB_001013f1:
MOV EDX,dword ptr [RAX]
TEST EDX,EDX
JNS 0x001013e8
MOV EAX,EDX
RET
LAB_00101400:
XOR EDX,EDX
MOV EAX,EDX
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
int *piVar1;
piVar1 = *(int **)param_1;
while( true ) {
if (*(int **)(param_1 + 8) == piVar1) {
return 0;
}
if (*piVar1 < 0) break;
piVar1 = piVar1 + 1;
}
return *piVar1;
} |
1,743 | func0 |
#include <cassert>
#include <vector>
| int func0(const std::vector<int>& list1) {
for (int num : list1) {
if (num < 0) {
return num;
}
}
return 0; // If no negative number found, return 0 (not present in Python version, required for all control paths to return a value in C++)
}
| int main() {
assert(func0({-1, 4, 5, -6}) == -1);
assert(func0({-1, -2, 3, 4}) == -1);
assert(func0({-7, -6, 8, 9}) == -7);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
cmp %rdx,%rax
jne 1401 <_Z5func0RKSt6vectorIiSaIiEE+0x21>
jmp 1410 <_Z5func0RKSt6vectorIiSaIiEE+0x30>
nopw 0x0(%rax,%rax,1)
add $0x4,%rax
cmp %rax,%rdx
je 1410 <_Z5func0RKSt6vectorIiSaIiEE+0x30>
m... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rax, [rdi]
mov rcx, [rdi+8]
cmp rcx, rax
jnz short loc_13F1
jmp short loc_1400
loc_13E8:
add rax, 4
cmp rcx, rax
jz short loc_1400
loc_13F1:
mov edx, [rax]
test edx, edx
jns short loc_13E8
mov eax, edx
retn
loc_1400:
xor edx, e... | long long func0(unsigned int **a1)
{
unsigned int *v1; // rax
unsigned int *v2; // rcx
v1 = *a1;
v2 = a1[1];
if ( v2 == *a1 )
return 0LL;
while ( (*v1 & 0x80000000) == 0 )
{
if ( v2 == ++v1 )
return 0LL;
}
return *v1;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
CMP RCX,RAX
JNZ 0x001013f1
JMP 0x00101400
LAB_001013e8:
ADD RAX,0x4
CMP RCX,RAX
JZ 0x00101400
LAB_001013f1:
MOV EDX,dword ptr [RAX]
TEST EDX,EDX
JNS 0x001013e8
MOV EAX,EDX
RET
LAB_00101400:
XOR EDX,EDX
MOV EAX,EDX
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
int *piVar1;
piVar1 = *(int **)param_1;
while( true ) {
if (*(int **)(param_1 + 8) == piVar1) {
return 0;
}
if (*piVar1 < 0) break;
piVar1 = piVar1 + 1;
}
return *piVar1;
} |
1,744 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(const std::string& str1) {
std::string str2 = "";
for (int i = 1; i <= str1.length(); ++i) {
if (i % 2 == 0) {
str2 += str1[i - 1];
}
}
return str2;
}
| int main() {
assert(func0("python") == "yhn");
assert(func0("program") == "rga");
assert(func0("language") == "agae");
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 $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x1d(%rbp),%rax
mov %rax,%rdi
callq ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_25]
mov [rbp+var_20], rax
nop
nop
lea rdx, [r... | long long func0(long long a1, long long a2)
{
char *v2; // rax
unsigned long long v3; // rbx
char v5; // [rsp+1Bh] [rbp-25h] BYREF
int i; // [rsp+1Ch] [rbp-24h]
char *v7; // [rsp+20h] [rbp-20h]
unsigned long long v8; // [rsp+28h] [rbp-18h]
v8 = __readfsqword(0x28u);
v7 = &v5;
std::string::basic_stri... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x25]
MOV qword ptr [RBP + -0x20],RAX
NOP
NOP
LEA RDX,[RBP + -0x25]
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[0... | /* func0(std::string const&) */
string * func0(string *param_1)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
ulong in_RSI;
long in_FS_OFFSET;
allocator local_2d;
uint local_2c;
allocator *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = &local_2d;
... |
1,745 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(const std::string& str1) {
std::string str2 = "";
for (int i = 1; i <= str1.length(); ++i) {
if (i % 2 == 0) {
str2 += str1[i - 1];
}
}
return str2;
}
| int main() {
assert(func0("python") == "yhn");
assert(func0("program") == "rga");
assert(func0("language") == "agae");
return 0;
}
| O1 | cpp | func0(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 $0x18,%rsp
mov %rdi,%rbp
mov %rsi,%r12
lea 0x10(%rdi),%rax
mov %rax,0x8(%rsp)
mov %rax,(%rdi)
lea 0xdd2(%rip),%rdx
mov ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
mov r12, rsi
lea rax, [rdi+10h]
mov [rsp+48h+var_40], rax
mov [rdi], rax
lea rsi, aFunc0ProgramRg+19h; ""
mov rdx, rsi... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
long long i; // rbx
unsigned long long v3; // rax
char v4; // r15
long long v5; // r13
unsigned long long v6; // r14
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "", "");
if ( a2[1] )
{
for ( i = 0LL; ; ++i )
{
if ( (i & 1) != 0 )
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
MOV R12,RSI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RDI],RAX
LEA RSI,[0x1020b4]
MOV RDX,RSI
LAB_00101297:
CALL 0x001015ac
CMP qword ptr [R12 + 0x8],0x0
JZ 0x0010133c
MOV EBX,0x0
JMP 0x001012de
LAB_001... | /* func0(std::string const&) */
string * func0(string *param_1)
{
int uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
long *in_RSI;
*(string **)param_1 = param_1 + 0x10;
std::string::_M_construct<char_const*>((char *)param_1,"",0x1020b4);
if (in_RSI[1] != 0) {
uVar4 = 0;
do {
if ((uVar4... |
1,746 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(const std::string& str1) {
std::string str2 = "";
for (int i = 1; i <= str1.length(); ++i) {
if (i % 2 == 0) {
str2 += str1[i - 1];
}
}
return str2;
}
| int main() {
assert(func0("python") == "yhn");
assert(func0("program") == "rga");
assert(func0("language") == "agae");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
lea 0x10(%rdi),%rax
push %r14
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov $0x2,%ebx
sub $0x18,%rsp
mov %rax,(%rdi)
mov %rax,0x8(%rsp)
movq $0x0,... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
lea rax, [rdi+10h]
push r14
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
xor ebx, ebx
sub rsp, 18h
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
cmp qword ptr [rsi+8],... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
long long v2; // rbx
bool v3; // zf
long long v4; // rax
long long v5; // r13
char v6; // r15
unsigned long long v7; // r14
long long v8; // rax
unsigned long long v9; // rdx
long long v10; // rax
v2 = 0LL;
a1[1] = 0LL;
*((_BYTE *)a1 + 16) = 0;
v3 = a2... | func0:
ENDBR64
PUSH R15
LEA RAX,[RDI + 0x10]
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x18
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],0x0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RDI],RAX
JNZ 0x001014a2
JMP 0x001014ed
LAB_001... | /* func0(std::string const&) */
string * func0(string *param_1)
{
string sVar1;
ulong uVar2;
long lVar3;
string *psVar4;
ulong uVar5;
ulong uVar6;
long *in_RSI;
uVar5 = 0;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string)0x0;
lVar3 = in_RSI[1];
*(string **)param_1 = param_1 + 0x10;
if ... |
1,747 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(const std::string& str1) {
std::string str2 = "";
for (int i = 1; i <= str1.length(); ++i) {
if (i % 2 == 0) {
str2 += str1[i - 1];
}
}
return str2;
}
| int main() {
assert(func0("python") == "yhn");
assert(func0("program") == "rga");
assert(func0("language") == "agae");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
lea 0x10(%rdi),%rax
push %r14
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov $0x2,%ebx
sub $0x18,%rsp
mov %rax,(%rdi)
mov %rax,0x8(%rsp)
movq $0x0,... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
lea rax, [rdi+10h]
push r14
push r13
mov r13, rsi
push r12
push rbp
mov rbp, rdi
push rbx
xor ebx, ebx
sub rsp, 18h
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdx, [rsi+8]
mov ... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
long long v2; // rbx
unsigned long long v3; // rdx
long long v4; // rax
long long v5; // r12
char v6; // r15
unsigned long long v7; // r14
long long v8; // rax
unsigned long long v9; // rdx
long long v10; // rax
v2 = 0LL;
a1[1] = 0LL;
*((_BYTE *)a1 + 16)... | func0:
ENDBR64
PUSH R15
LEA RAX,[RDI + 0x10]
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x18
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RDI],RAX
TEST RDX,RDX
JNZ 0x001014a0
JMP 0x001... | /* func0(std::string const&) */
string * func0(string *param_1)
{
string sVar1;
string *psVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
long *in_RSI;
uVar3 = 0;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string)0x0;
uVar4 = in_RSI[1];
*(string **)param_1 = param_1 + 0x10;
if (uVar4 == 0) {... |
1,748 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::string func0(const std::vector<std::pair<int, int>>& test_list) {
int res = 0;
for (size_t idx = 0; idx < test_list.size(); ++idx) {
for (size_t iidx = idx + 1; iidx < test_list.size(); ++iidx) {
if (test_list[iidx].first == test_list[idx].second && test_list[idx].second == test_lis... | int main() {
assert(func0({{5, 6}, {1, 2}, {6, 5}, {9, 1}, {6, 5}, {2, 1}}) == "3");
assert(func0({{5, 6}, {1, 3}, {6, 5}, {9, 1}, {6, 5}, {2, 1}}) == "2");
assert(func0({{5, 6}, {1, 2}, {6, 5}, {9, 2}, {6, 5}, {2, 1}}) == "4");
return 0;
}
| O0 | cpp | func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x2c(%rbp)
movq $0x0,-0x28(%rb... | _Z5func0B5cxx11RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_2C], 0
mov [rbp+var_28], 0
jmp loc_1426
loc_1381:
mov rax, [rb... | std::__cxx11 * func0[abi:cxx11](std::__cxx11 *a1, long long a2)
{
unsigned long long i; // rax
int v3; // ebx
int v4; // ebx
int v7; // [rsp+14h] [rbp-2Ch]
unsigned long long v8; // [rsp+18h] [rbp-28h]
unsigned long long j; // [rsp+20h] [rbp-20h]
v7 = 0;
v8 = 0LL;
for ( i = std::vector<std::pair<int,... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x2c],0x0
MOV qword ptr [RBP + -0x28],0x0
JMP 0x00101426
LAB_00101381:
MOV RAX,qword ptr [RBP... | /* func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)
*/
vector * func0_abi_cxx11_(vector *param_1)
{
int iVar1;
long lVar2;
int *piVar3;
long lVar4;
ulong uVar5;
vector<std::pair<int,int>,std::allocator<std::pair<int,int>>> *in_RSI;
long in_FS_OFFSET;
... |
1,749 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::string func0(const std::vector<std::pair<int, int>>& test_list) {
int res = 0;
for (size_t idx = 0; idx < test_list.size(); ++idx) {
for (size_t iidx = idx + 1; iidx < test_list.size(); ++iidx) {
if (test_list[iidx].first == test_list[idx].second && test_list[idx].second == test_lis... | int main() {
assert(func0({{5, 6}, {1, 2}, {6, 5}, {9, 1}, {6, 5}, {2, 1}}) == "3");
assert(func0({{5, 6}, {1, 3}, {6, 5}, {9, 1}, {6, 5}, {2, 1}}) == "2");
assert(func0({{5, 6}, {1, 2}, {6, 5}, {9, 2}, {6, 5}, {2, 1}}) == "4");
return 0;
}
| O1 | cpp | func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %rbx
sub $0x10,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rsi),%rax
mov 0x8(%rsi),%rsi
sub %rax,%rsi
mov %rsi,%rdx
sar $0x3,%rdx
je 12fd <_Z... | _Z5func0B5cxx11RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 0E8h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+108h+var_30], rax
xor eax, eax
mov rax, [rsi+8]
mov rdi, [rsi]
mov rdx, rax
sub rdx, rdi
mov r10, rdx
sar r10, 3
cmp ... | _QWORD * func0[abi:cxx11](_QWORD *a1, _QWORD *a2)
{
long long v2; // r8
long long v3; // r9
int v4; // edx
_DWORD *v5; // rax
unsigned int v6; // ebx
unsigned __int8 v7; // r13
unsigned int v8; // r12d
char *v9; // r13
char v10; // dl
unsigned int v12; // eax
unsigned int v13; // ecx
unsigned in... | func0[abi:cxx11]:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xe8
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xd8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI + 0x8]
MOV RDI,qword ptr [RSI]
MOV RDX,RAX
SUB RDX,RDI
MOV R10,RDX
SAR R10,0x3
CMP RDI,RAX
JZ 0x001012f7
LEA R8,[RDI + 0x8]
ADD RDI,RDX
MOV... | /* func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)
*/
vector * func0_abi_cxx11_(vector *param_1)
{
int *piVar1;
int *piVar2;
int *piVar3;
int *piVar4;
char cVar5;
uint uVar6;
uint uVar7;
long lVar8;
int8 *in_RSI;
int *piVar9;
ulong uVar10;
u... |
1,750 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::string func0(const std::vector<std::pair<int, int>>& test_list) {
int res = 0;
for (size_t idx = 0; idx < test_list.size(); ++idx) {
for (size_t iidx = idx + 1; iidx < test_list.size(); ++iidx) {
if (test_list[iidx].first == test_list[idx].second && test_list[idx].second == test_lis... | int main() {
assert(func0({{5, 6}, {1, 2}, {6, 5}, {9, 1}, {6, 5}, {2, 1}}) == "3");
assert(func0({{5, 6}, {1, 3}, {6, 5}, {9, 1}, {6, 5}, {2, 1}}) == "2");
assert(func0({{5, 6}, {1, 2}, {6, 5}, {9, 2}, {6, 5}, {2, 1}}) == "4");
return 0;
}
| O2 | cpp | func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r12
mov %rdi,%r12
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rsi),%rax
mov 0x8(%rsi),%rsi
sub %rax,%rsi
mov %rsi,%r11
sar $0x3,%r11
je 1600 <_Z... | _Z5func0B5cxx11RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 0E0h
mov rdi, [rsi]
mov rax, fs:28h
mov [rsp+108h+var_30], rax
mov rax, [rsi+8]
mov rdx, rax
sub rdx, rdi
mov r10, rdx
sar r10, 3
cmp rdi,... | long long * func0[abi:cxx11](long long *a1, long long *a2, long long a3, unsigned long long a4, _DWORD *a5)
{
long long v6; // rdi
unsigned long long v7; // r10
int v8; // edx
unsigned long long i; // r9
_DWORD *v10; // rax
unsigned int v11; // ebx
long long v12; // r14
int v13; // edx
unsigned int v1... | func0[abi:cxx11]:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0xe0
MOV RDI,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV RDX,RAX
SUB RDX,RDI
MOV R10,RDX
SAR R10,0x3
CMP RDI,RAX
JZ 0x0010183f
XOR R9D,R9D
LEA R8,[RDI + 0x8]
ADD RD... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)
*/
vector * func0_abi_cxx11_(vector *param_1)
{
uint uVar1;
int *piVar2;
int *piVar3;
uint uVar4;
int iVar5;
int *piV... |
1,751 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::string func0(const std::vector<std::pair<int, int>>& test_list) {
int res = 0;
for (size_t idx = 0; idx < test_list.size(); ++idx) {
for (size_t iidx = idx + 1; iidx < test_list.size(); ++iidx) {
if (test_list[iidx].first == test_list[idx].second && test_list[idx].second == test_lis... | int main() {
assert(func0({{5, 6}, {1, 2}, {6, 5}, {9, 1}, {6, 5}, {2, 1}}) == "3");
assert(func0({{5, 6}, {1, 3}, {6, 5}, {9, 1}, {6, 5}, {2, 1}}) == "2");
assert(func0({{5, 6}, {1, 2}, {6, 5}, {9, 2}, {6, 5}, {2, 1}}) == "4");
return 0;
}
| O3 | cpp | func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r12
mov %rdi,%r12
push %rbx
sub $0x18,%rsp
mov (%rsi),%r11
mov 0x8(%rsi),%r10
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
sub %r11,%r10
sar $0x3,%r10
je 179d <_Z5func... | _Z5func0B5cxx11RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0E0h
mov r11, [rsi]
mov rax, fs:28h
mov [rsp+108h+var_30], rax
mov rax, [rsi+8]
mov r10, rax
sub r10, r11
sar r10, 3
cmp rax, r11
jz loc_... | long long * func0[abi:cxx11](long long *a1, long long *a2)
{
long long v3; // r11
unsigned long long v4; // r10
unsigned long long v5; // rdi
const __m128i *v6; // r8
int v7; // edx
unsigned long long i; // r9
unsigned int v9; // esi
__m128i v10; // xmm1
const __m128i *v11; // rax
__m128i v12; // xm... | func0[abi:cxx11]:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xe0
MOV R11,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV R10,RAX
SUB R10,R11
SAR R10,0x3
CMP RAX,R11
JZ 0x00101911
XOR R9D,R9D
LEA RDI,[R10 + -0x2]
LEA R8,[R11 + 0x... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&)
*/
vector * func0_abi_cxx11_(vector *param_1)
{
uint uVar1;
int *piVar2;
int iVar3;
int *piVar4;
int iVar5;
int *piVa... |
1,752 | func0 |
#include <vector>
#include <string>
#include <cassert>
| int func0(const std::vector<int>& L) {
std::string result;
for (int num : L) {
result += std::to_string(num);
}
return std::stoi(result);
}
| int main() {
assert(func0(std::vector<int>{11, 33, 50}) == 113350);
assert(func0(std::vector<int>{-1, 2, 3, 4, 5, 6}) == -123456);
assert(func0(std::vector<int>{10, 15, 20, 25}) == 10152025);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x88,%rsp
mov %rdi,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 2390 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev@p... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_88], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_60]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string... | long long func0(long long a1)
{
unsigned int v1; // ebx
int v3; // [rsp+14h] [rbp-7Ch]
long long v4; // [rsp+18h] [rbp-78h] BYREF
_QWORD v5[2]; // [rsp+20h] [rbp-70h] BYREF
_BYTE v6[32]; // [rsp+30h] [rbp-60h] BYREF
_BYTE v7[40]; // [rsp+50h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+78h] [rbp-18h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x00101270
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RDI,RAX
... | /* func0(std::vector<int, std::allocator<int> > const&) */
int4 func0(vector *param_1)
{
bool bVar1;
int4 uVar2;
long in_FS_OFFSET;
int8 local_80;
int8 local_78;
vector<int,std::allocator<int>> *local_70;
string local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFS... |
1,753 | func0 |
#include <vector>
#include <string>
#include <cassert>
| int func0(const std::vector<int>& L) {
std::string result;
for (int num : L) {
result += std::to_string(num);
}
return std::stoi(result);
}
| int main() {
assert(func0(std::vector<int>{11, 33, 50}) == 113350);
assert(func0(std::vector<int>{-1, 2, 3, 4, 5, 6}) == -123456);
assert(func0(std::vector<int>{10, 15, 20, 25}) == 10152025);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rax
mov %rax,0x10(%rsp)
movq $0x0,0x18(%rsp)
movb $0x0,0x20(%rsp)
mov (%rdi),%rbx
mov 0x8(%rdi),%rb... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 130h
mov rax, fs:28h
mov [rsp+158h+var_30], rax
xor eax, eax
lea rax, [rsp+158h+var_138]
mov [rsp+158h+var_148], rax
mov [rsp+158h+var_140], 0
mov byte ptr [rsp+158h+var_138], 0
mov ... | long long func0(unsigned int **a1)
{
unsigned int *v1; // r13
unsigned int *v2; // r14
void *v3; // rbx
int *v4; // rbp
int v5; // r12d
long long v6; // rax
unsigned int v7; // ebx
unsigned int v9; // ebx
char *v10; // r12
int v11; // ebp
char v12; // bp
unsigned int v13; // eax
unsigned int ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x130
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],0x0
MOV byte ptr [RSP + 0x20],0x0
MOV R13,qword ptr [RDI]
MOV R14,qword ptr [RDI + 0x8]
CMP R14... | /* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
int iVar1;
uint *puVar2;
int *puVar3;
uint uVar4;
int *piVar5;
ulong uVar6;
int8 uVar7;
uint uVar8;
ulong uVar9;
uint uVar10;
char cVar11;
uint uVar12;
char *pcVar13;
uint *puVar14;
long in_FS_OFFSE... |
1,754 | func0 |
#include <vector>
#include <string>
#include <cassert>
| int func0(const std::vector<int>& L) {
std::string result;
for (int num : L) {
result += std::to_string(num);
}
return std::stoi(result);
}
| int main() {
assert(func0(std::vector<int>{11, 33, 50}) == 113350);
assert(func0(std::vector<int>{-1, 2, 3, 4, 5, 6}) == -123456);
assert(func0(std::vector<int>{10, 15, 20, 25}) == 10152025);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r15
movb $0x0,0x20(%rsp)
mov %r15,0x10(%rs... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 158h
mov rbx, [rdi]
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
lea rax, [rsp+188h+var_148]
mov byte ptr [rsp+188h+var_148], 0
mov [rsp+188h+var_170], rax
mov... | long long func0(unsigned int **a1)
{
unsigned int *v1; // rbx
unsigned int *v2; // rax
unsigned int v3; // r15d
unsigned int v4; // ecx
unsigned int v5; // r13d
unsigned int v6; // r12d
int v7; // esi
unsigned int v8; // r14d
__int8 *v9; // r15
unsigned int v10; // eax
unsigned int v11; // esi
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x158
MOV RBX,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RDI + 0x8... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
uint uVar1;
uint *puVar2;
int *puVar3;
uint uVar4;
int *piVar5;
ulong uVar6;
char cVar7;
uint uVar8;
uint *puVar9;
int iVar... |
1,755 | func0 |
#include <vector>
#include <string>
#include <cassert>
| int func0(const std::vector<int>& L) {
std::string result;
for (int num : L) {
result += std::to_string(num);
}
return std::stoi(result);
}
| int main() {
assert(func0(std::vector<int>{11, 33, 50}) == 113350);
assert(func0(std::vector<int>{-1, 2, 3, 4, 5, 6}) == -123456);
assert(func0(std::vector<int>{10, 15, 20, 25}) == 10152025);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%rax
movb $0x0,0x30(%rsp)
mov %rax,0x8(%rsp... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 158h
mov rbx, [rdi]
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
lea rax, [rsp+188h+var_148]
mov byte ptr [rsp+188h+var_148], 0
mov [rsp+188h+var_170], rax
mov... | long long func0(unsigned int **a1)
{
unsigned int *v1; // rbx
unsigned int *v2; // rax
unsigned int v3; // r15d
unsigned int v4; // ecx
unsigned int v5; // r14d
unsigned int v6; // r12d
int v7; // esi
unsigned int v8; // r13d
__int8 *v9; // r15
unsigned int v10; // eax
unsigned int v11; // esi
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x158
MOV RBX,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RDI + 0x8... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
uint uVar1;
uint *puVar2;
int *puVar3;
uint uVar4;
int *piVar5;
ulong uVar6;
char cVar7;
uint uVar8;
uint *puVar9;
int iVar... |
1,756 | func0 |
#include <iostream>
#include <regex>
#include <tuple>
#include <assert.h>
| std::tuple<int, int, std::string> func0(const std::string& text) {
std::regex word_regex("\\w+ly");
std::smatch match;
if (std::regex_search(text, match, word_regex)) {
return {match.position(0), match.position(0) + match.length(0), match.str(0)};
}
return {-1, -1, ""}; // return an in... | int main() {
assert(func0("clearly!! we can see the sky") == std::make_tuple(0, 7, "clearly"));
assert(func0("seriously!! there are many roses") == std::make_tuple(0, 9, "seriously"));
assert(func0("unfortunately!! sita is going to home") == std::make_tuple(0, 13, "unfortunately"));
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 $0x98,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x80(%rbp),%rax
mov $0x10,%edx
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_80]
mov edx, 10h
lea rcx, aWLy; "\\w+ly"
mov ... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v4; // [rsp+10h] [rbp-90h] BYREF
long long v5; // [rsp+18h] [rbp-88h] BYREF
_BYTE v6[32]; // [rsp+20h] [rbp-80h] BYREF
_BYTE v7[32]; // [rsp+40h] [rbp-60h] BYREF
_BYTE v8[40]; // [rsp+60h] [rbp-40h] BYREF
unsigned long long v9; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x80]
MOV EDX,0x10
LEA RCX,[0x134051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b6c:
CALL 0x001063c8
LEA RAX,[RBP + -0x... | /* func0(std::string const&) */
string * func0(string *param_1)
{
bool bVar1;
long lVar2;
long lVar3;
string *in_RSI;
long in_FS_OFFSET;
long local_98;
long local_90;
regex local_88 [32];
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_co... |
1,757 | func0 |
#include <iostream>
#include <regex>
#include <tuple>
#include <assert.h>
| std::tuple<int, int, std::string> func0(const std::string& text) {
std::regex word_regex("\\w+ly");
std::smatch match;
if (std::regex_search(text, match, word_regex)) {
return {match.position(0), match.position(0) + match.length(0), match.str(0)};
}
return {-1, -1, ""}; // return an in... | int main() {
assert(func0("clearly!! we can see the sky") == std::make_tuple(0, 7, "clearly"));
assert(func0("seriously!! there are many roses") == std::make_tuple(0, 9, "seriously"));
assert(func0("unfortunately!! sita is going to home") == std::make_tuple(0, 13, "unfortunately"));
return 0;
}
| O1 | cpp | func0(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 $0x1f0,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x1e8(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%r13
mov %r13,%rdi
ca... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1F8h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea r12, [rbp+var_208]
mov rdi, r12;... | long long func0(long long a1, long long a2)
{
char *v4; // rsi
long long v5; // rdx
long long v6; // rax
long long v7; // r12
volatile signed __int32 *v8; // rcx
long long v9; // rdx
signed __int32 v10; // eax
_QWORD *v12; // rax
long long v13; // r12
_QWORD *v14; // rcx
long long v15; // rsi
l... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1f8
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x208]
MOV RDI,R12
CALL 0x001046f0
MOV qword ptr [RBP + -0x200],0x0
MOV qword ptr [RBP + -0x1f8],0x0
LEA RDI,[RBP... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int *__src;
_Sp_counted_base<(_Lock_policy)2> *this;
bool bVar2;
uint uVar3;
int8 *puVar4;
ulong uVar5;
int8 *puVar6;
uint uVar7;
long lVar8;
int iVar9;
int8 *in_RSI;
int iVar10;
lo... |
1,758 | func0 |
#include <iostream>
#include <regex>
#include <tuple>
#include <assert.h>
| std::tuple<int, int, std::string> func0(const std::string& text) {
std::regex word_regex("\\w+ly");
std::smatch match;
if (std::regex_search(text, match, word_regex)) {
return {match.position(0), match.position(0) + match.length(0), match.str(0)};
}
return {-1, -1, ""}; // return an in... | int main() {
assert(func0("clearly!! we can see the sky") == std::make_tuple(0, 7, "clearly"));
assert(func0("seriously!! there are many roses") == std::make_tuple(0, 9, "seriously"));
assert(func0("unfortunately!! sita is going to home") == std::make_tuple(0, 13, "unfortunately"));
return 0;
}
| O2 | cpp | func0(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
mov %rsi,%rbx
sub $0x218,%rsp
mov %fs:0x28,%rax
mov %rax,0x208(%rsp)
xor %eax,%eax
lea 0x50(%rsp),%r13
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
lea r15, [rbp+var_208]
push r13
lea r13, [rbp+var_1D0]
push r12
mov r12, rsi
push rbx
mov rbx, rdi
mov rdi, r15; this
sub rsp, 228h
mov rax, fs:28h
mov [r... | long long func0(long long a1, long long *a2)
{
char *v4; // rsi
__m128i v5; // xmm0
volatile signed __int32 *v6; // r14
long long v7; // rdx
volatile signed __int32 *v8; // rcx
signed __int32 v9; // eax
long long v10; // r14
long long v11; // rdx
volatile signed __int32 *v12; // rcx
signed __int32 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
LEA R15,[RBP + -0x208]
PUSH R13
LEA R13,[RBP + -0x1d0]
PUSH R12
MOV R12,RSI
PUSH RBX
MOV RBX,RDI
MOV RDI,R15
SUB RSP,0x228
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV qword ptr [RBP + -0x228],R15
CALL 0x001036d0
PXOR XMM0,XMM0
MOV RCX... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int *__src;
int8 uVar2;
int8 uVar3;
bool bVar4;
long lVar5;
int8 *puVar6;
string *psVar7;
ulong uVar8;
uint uVar9;
long lVar10;
int iVar11;
uint uVar12;
int8 *in_RSI;
ulong uVar13... |
1,759 | func0 |
#include <iostream>
#include <regex>
#include <tuple>
#include <assert.h>
| std::tuple<int, int, std::string> func0(const std::string& text) {
std::regex word_regex("\\w+ly");
std::smatch match;
if (std::regex_search(text, match, word_regex)) {
return {match.position(0), match.position(0) + match.length(0), match.str(0)};
}
return {-1, -1, ""}; // return an in... | int main() {
assert(func0("clearly!! we can see the sky") == std::make_tuple(0, 7, "clearly"));
assert(func0("seriously!! there are many roses") == std::make_tuple(0, 9, "seriously"));
assert(func0("unfortunately!! sita is going to home") == std::make_tuple(0, 13, "unfortunately"));
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
mov %rsi,%r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x218,%rsp
mov %fs:0x28,%rax
mov %rax,0x208(%rsp)
xor %eax,%eax
lea 0x50(%rsp),%r13
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
mov r15, rsi
push r14
lea r14, [rbp+var_208]
push r13
push r12
lea r12, [rbp+var_1D0]
push rbx
mov rbx, rdi
mov rdi, r14; this
sub rsp, 218h
mov rax, fs:28h
mov [r... | long long func0(long long a1, long long *a2)
{
__m128i v3; // xmm0
long long v4; // rdi
void *v5; // rdi
void **v6; // r13
unsigned long long v7; // r14
void *v8; // rdi
long long v9; // rdi
long long v10; // rsi
long long v11; // rax
long long v12; // rcx
long long v13; // rdi
long long v14; /... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
MOV R15,RSI
PUSH R14
LEA R14,[RBP + -0x208]
PUSH R13
PUSH R12
LEA R12,[RBP + -0x1d0]
PUSH RBX
MOV RBX,RDI
MOV RDI,R14
SUB RSP,0x218
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV qword ptr [RBP + -0x228],R14
CALL 0x00104710
PXOR XMM0,XMM0
MOV RCX... | /* func0(std::string const&) */
string * func0(string *param_1)
{
char cVar1;
int *__src;
int8 this;
int auVar2 [16];
bool bVar3;
ulong __n;
int8 *puVar4;
long lVar5;
int8 *in_RSI;
long lVar6;
int iVar7;
int8 *puVar8;
int iVar9;
long in_FS_OFFSET;
int local_238;
ulong local_220;
int4... |
1,760 | func0 |
#include <cassert>
| int func0(int l) {
int surfacearea = 6 * l * l;
return surfacearea;
}
| int main() {
assert(func0(5) == 150);
assert(func0(3) == 54);
assert(func0(10) == 600);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
imul %eax,%eax
mov %eax,%edx
mov %edx,%eax
add %eax,%eax
add %edx,%eax
add %eax,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
imul eax, eax
mov edx, eax
mov eax, edx
add eax, eax
add eax, edx
add eax, eax
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(6 * a1 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,EAX
MOV EDX,EAX
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
ADD EAX,EAX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1 * 6;
} |
1,761 | func0 |
#include <cassert>
| int func0(int l) {
int surfacearea = 6 * l * l;
return surfacearea;
}
| int main() {
assert(func0(5) == 150);
assert(func0(3) == 54);
assert(func0(10) == 600);
return 0;
}
| O1 | cpp | func0(int):
endbr64
imul %edi,%edi
lea (%rdi,%rdi,2),%eax
add %eax,%eax
retq
| _Z5func0i:
endbr64
imul edi, edi
lea eax, [rdi+rdi*2]
add eax, eax
retn | long long func0(int a1)
{
return (unsigned int)(6 * a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
LEA EAX,[RDI + RDI*0x2]
ADD EAX,EAX
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1 * 6;
} |
1,762 | func0 |
#include <cassert>
| int func0(int l) {
int surfacearea = 6 * l * l;
return surfacearea;
}
| int main() {
assert(func0(5) == 150);
assert(func0(3) == 54);
assert(func0(10) == 600);
return 0;
}
| O2 | cpp | func0(int):
endbr64
imul %edi,%edi
lea (%rdi,%rdi,2),%eax
add %eax,%eax
retq
nopl (%rax)
| _Z5func0i:
endbr64
imul edi, edi
lea eax, [rdi+rdi*2]
add eax, eax
retn | long long func0(int a1)
{
return (unsigned int)(6 * a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
LEA EAX,[RDI + RDI*0x2]
ADD EAX,EAX
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1 * 6;
} |
1,763 | func0 |
#include <cassert>
| int func0(int l) {
int surfacearea = 6 * l * l;
return surfacearea;
}
| int main() {
assert(func0(5) == 150);
assert(func0(3) == 54);
assert(func0(10) == 600);
return 0;
}
| O3 | cpp | func0(int):
endbr64
imul %edi,%edi
lea (%rdi,%rdi,2),%eax
add %eax,%eax
retq
nopl (%rax)
| _Z5func0i:
endbr64
imul edi, edi
lea eax, [rdi+rdi*2]
add eax, eax
retn | long long func0(int a1)
{
return (unsigned int)(6 * a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
LEA EAX,[RDI + RDI*0x2]
ADD EAX,EAX
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1 * 6;
} |
1,764 | func0 | #include <vector>
#include <cassert>
#include <cmath>
| double func0(const std::vector<int>& nums) {
int n = nums.size();
int n1 = 0;
for (int x : nums) {
if (x > 0) {
n1 += 1;
}
}
return round(n1 * 100.0 / n) / 100.0;
}
| int main() {
assert(func0({0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8}) == 0.54);
assert(func0({2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8}) == 0.69);
assert(func0({2, 4, -6, -9, 11, -12, 14, -5, 17}) == 0.56);
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
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 16da <_ZNKSt6vectorIiSaIiEE4sizeEv>
mov %eax,-0x28(%rbp)
movl $0x0,-0x2c(... | _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 rax, [rbp+var_38]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov [rbp+var_28], eax
mov [rbp+... | unsigned long long func0(long long a1)
{
int v2; // [rsp+14h] [rbp-2Ch]
int v3; // [rsp+18h] [rbp-28h]
long long v4; // [rsp+20h] [rbp-20h] BYREF
_QWORD v5[2]; // [rsp+28h] [rbp-18h] BYREF
unsigned long long v6; // [rsp+38h] [rbp-8h]
v6 = __readfsqword(0x28u);
v3 = std::vector<int>::size(a1);
v2 = 0;
... | 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 RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x0010178c
MOV dword ptr [RBP + -0x28],EAX
MOV dword ptr [RBP + -0x2c],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword pt... | /* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
bool bVar1;
int iVar2;
int *piVar3;
long in_FS_OFFSET;
double dVar4;
int local_34;
int8 local_28;
int8 local_20;
vector<int,std::allocator<int>> *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFS... |
1,765 | func0 | #include <vector>
#include <cassert>
#include <cmath>
| double func0(const std::vector<int>& nums) {
int n = nums.size();
int n1 = 0;
for (int x : nums) {
if (x > 0) {
n1 += 1;
}
}
return round(n1 * 100.0 / n) / 100.0;
}
| int main() {
assert(func0({0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8}) == 0.54);
assert(func0({2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8}) == 0.69);
assert(func0({2, 4, -6, -9, 11, -12, 14, -5, 17}) == 0.56);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
sub $0x8,%rsp
mov 0x8(%rdi),%rsi
mov (%rdi),%rax
mov %rsi,%rdi
sub %rax,%rdi
sar $0x2,%rdi
cmp %rax,%rsi
je 128e <_Z5func0RKSt6vectorIiSaIiEE+0x65>
mov $0x0,%edx
cmpl $0x0,(%rax)
setg %cl
movzbl %cl,%ecx
add %ecx,%edx
add ... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
sub rsp, 8
mov rsi, [rdi+8]
mov rax, [rdi]
mov rdi, rsi
sub rdi, rax
sar rdi, 2
cmp rsi, rax
jz short loc_128E
mov edx, 0
loc_124C:
cmp dword ptr [rax], 0
setnle cl
movzx ecx, cl
add edx, ecx
add rax, 4
cmp rax, rsi
jnz sho... | double func0(long long a1)
{
_DWORD *v1; // rsi
_DWORD *v2; // rax
long long v3; // rdi
int v4; // edx
v1 = *(_DWORD **)(a1 + 8);
v2 = *(_DWORD **)a1;
v3 = ((long long)v1 - *(_QWORD *)a1) >> 2;
if ( v1 == v2 )
{
v4 = 0;
}
else
{
v4 = 0;
do
v4 += *v2++ > 0;
while ( v2 != v... | func0:
ENDBR64
SUB RSP,0x8
MOV RSI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RDI]
MOV RDI,RSI
SUB RDI,RAX
SAR RDI,0x2
CMP RSI,RAX
JZ 0x0010128e
MOV EDX,0x0
LAB_0010124c:
CMP dword ptr [RAX],0x0
SETG CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x0010124c
LAB_00101260:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
MULSD XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
int *piVar1;
int *piVar2;
int iVar3;
long lVar4;
double dVar5;
piVar1 = *(int **)(param_1 + 8);
piVar2 = *(int **)param_1;
... |
1,766 | func0 | #include <vector>
#include <cassert>
#include <cmath>
| double func0(const std::vector<int>& nums) {
int n = nums.size();
int n1 = 0;
for (int x : nums) {
if (x > 0) {
n1 += 1;
}
}
return round(n1 * 100.0 / n) / 100.0;
}
| int main() {
assert(func0({0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8}) == 0.54);
assert(func0({2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8}) == 0.69);
assert(func0({2, 4, -6, -9, 11, -12, 14, -5, 17}) == 0.56);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
sub $0x18,%rsp
mov 0x8(%rdi),%rsi
mov (%rdi),%rax
mov %rsi,%rdi
sub %rax,%rdi
sar $0x2,%rdi
cmp %rsi,%rax
je 1510 <_Z5func0RKSt6vectorIiSaIiEE+0x70>
xor %edx,%edx
mov (%rax),%r8d
xor %ecx,%ecx
test %r8d,%r8d
setg %cl
add... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
sub rsp, 18h
mov rsi, [rdi+8]
mov rax, [rdi]
mov rdi, rsi
sub rdi, rax
sar rdi, 2
cmp rsi, rax
jz short loc_1470
xor edx, edx
loc_1420:
mov r8d, [rax]
xor ecx, ecx
test r8d, r8d
setnle cl
add rax, 4
add edx, ecx
cmp rax, r... | double func0(long long a1)
{
_DWORD *v1; // rsi
_DWORD *v2; // rax
long long v3; // rdi
int v4; // edx
int v5; // ecx
double v6; // xmm0_8
v1 = *(_DWORD **)(a1 + 8);
v2 = *(_DWORD **)a1;
v3 = ((long long)v1 - *(_QWORD *)a1) >> 2;
if ( v1 == v2 )
{
v6 = 0.0;
}
else
{
v4 = 0;
do
... | func0:
ENDBR64
SUB RSP,0x18
MOV RSI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RDI]
MOV RDI,RSI
SUB RDI,RAX
SAR RDI,0x2
CMP RSI,RAX
JZ 0x00101470
XOR EDX,EDX
LAB_00101420:
MOV R8D,dword ptr [RAX]
XOR ECX,ECX
TEST R8D,R8D
SETG CL
ADD RAX,0x4
ADD EDX,ECX
CMP RAX,RSI
JNZ 0x00101420
PXOR XMM0,XMM0
MOVSD XMM1,qword ptr [0x001... | /* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
int iVar1;
int *piVar2;
double dVar3;
int *piVar4;
int iVar5;
long lVar6;
double dVar7;
dVar3 = DAT_00102120;
piVar2 = *(int **)(param_1 + 8);
piVar4 = *(int **)param_1;
lVar6 = (long)piVar2 - (long)piV... |
1,767 | func0 | #include <vector>
#include <cassert>
#include <cmath>
| double func0(const std::vector<int>& nums) {
int n = nums.size();
int n1 = 0;
for (int x : nums) {
if (x > 0) {
n1 += 1;
}
}
return round(n1 * 100.0 / n) / 100.0;
}
| int main() {
assert(func0({0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8}) == 0.54);
assert(func0({2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8}) == 0.69);
assert(func0({2, 4, -6, -9, 11, -12, 14, -5, 17}) == 0.56);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
sub $0x18,%rsp
mov 0x8(%rdi),%r8
mov (%rdi),%rdx
mov %r8,%rsi
sub %rdx,%rsi
sar $0x2,%rsi
cmp %r8,%rdx
je 1540 <_Z5func0RKSt6vectorIiSaIiEE+0x130>
lea -0x4(%r8),%rcx
mov %rdx,%rax
movabs $0x3ffffffffffffffc,%r9
sub %rdx,%rcx... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
sub rsp, 18h
mov r8, [rdi+8]
mov rdx, [rdi]
mov rdi, r8
sub rdi, rdx
sar rdi, 2
cmp r8, rdx
jz loc_1510
lea rcx, [r8-4]
mov rax, rdx
sub rcx, rdx
mov rsi, rcx
shr rsi, 2
add rsi, 1
cmp rcx, 8
jbe loc_151E
mov rcx, ... | double func0(const __m128i **a1)
{
const __m128i *v1; // r8
const __m128i *v2; // rdx
long long v3; // rdi
const __m128i *v4; // rax
unsigned long long v5; // rsi
__m128i v6; // xmm0
__m128i v7; // xmm1
__m128i v8; // xmm0
int v9; // eax
double v10; // xmm0_8
v1 = a1[1];
v2 = *a1;
v3 = ((cha... | func0:
ENDBR64
SUB RSP,0x18
MOV R8,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RDI,R8
SUB RDI,RDX
SAR RDI,0x2
CMP R8,RDX
JZ 0x00101510
LEA RCX,[R8 + -0x4]
MOV RAX,RDX
SUB RCX,RDX
MOV RSI,RCX
SHR RSI,0x2
ADD RSI,0x1
CMP RCX,0x8
JBE 0x0010151e
MOV RCX,RSI
PXOR XMM0,XMM0
SHR RCX,0x2
MOVDQA XMM2,XMM0
SHL RCX,0x4
ADD ... | /* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
double dVar6;
int *piVar7;
ulong uVar8;
int *piVar9;
ulong uVar10;
long lVar11;
int iVar12;
int iVar14;
double dVar13;
int iVar15;
i... |
1,768 | func0 | #include <vector>
#include <assert.h>
| int func0(std::vector<int> list1) {
int max = list1[0];
for(int x : list1) {
if(x < max) {
max = x;
}
}
return max;
}
| int main() {
assert(func0({1,2,3,-4,-6}) == -6);
assert(func0({1,2,3,-8,-9}) == -9);
assert(func0({1,2,3,4,-1}) == -1);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 1598 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
mov %eax,-0x28... | _Z5func0St6vectorIiSaIiEE:
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 rax, [rbp+var_38]
mov esi, 0
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
mov ... | 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 = *(_DWORD *)std::vector<int>::operator[](a1, 0LL);
v5[1] = a1;
v4 = std::vector... | 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 RAX,qword ptr [RBP + -0x38]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x0010161c
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qwor... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
bool bVar1;
int *piVar2;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_30;
int8 local_28;
int8 local_20;
vector<int,std::allocator<int>> *local_18;
long local_10;
t... |
1,769 | func0 | #include <vector>
#include <assert.h>
| int func0(std::vector<int> list1) {
int max = list1[0];
for(int x : list1) {
if(x < max) {
max = x;
}
}
return max;
}
| int main() {
assert(func0({1,2,3,-4,-6}) == -6);
assert(func0({1,2,3,-8,-9}) == -9);
assert(func0({1,2,3,4,-1}) == -1);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rax
mov (%rax),%edx
mov 0x8(%rdi),%rsi
cmp %rsi,%rax
je 122b <_Z5func0St6vectorIiSaIiEE+0x22>
mov (%rax),%ecx
cmp %ecx,%edx
cmovg %ecx,%edx
add $0x4,%rax
cmp %rax,%rsi
jne 121b <_Z5func0St6vectorIiSaIiEE+0x12>
mov %edx... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi]
mov edx, [rax]
mov rsi, [rdi+8]
cmp rax, rsi
jz short loc_122B
loc_121B:
mov ecx, [rax]
cmp edx, ecx
cmovg edx, ecx
add rax, 4
cmp rax, rsi
jnz short loc_121B
loc_122B:
mov eax, edx
retn | long long func0(unsigned int **a1)
{
unsigned int *v1; // rax
unsigned int v2; // edx
int *v3; // rsi
v1 = *a1;
v2 = **a1;
v3 = (int *)a1[1];
if ( *a1 != (unsigned int *)v3 )
{
do
{
if ( (int)v2 > (int)*v1 )
v2 = *v1;
++v1;
}
while ( v1 != (unsigned int *)v3 );
}
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV EDX,dword ptr [RAX]
MOV RSI,qword ptr [RDI + 0x8]
CMP RAX,RSI
JZ 0x0010122b
LAB_0010121b:
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
CMOVG EDX,ECX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x0010121b
LAB_0010122b:
MOV EAX,EDX
RET | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int *piVar1;
int iVar2;
int4 in_register_0000003c;
piVar1 = *(int **)CONCAT44(in_register_0000003c,param_1);
iVar2 = *piVar1;
for (; piVar1 != *(int **)(CONCAT44(in_register_0000003c,param_1) + 8); piVar1 = piVar1 + 1) {
... |
1,770 | func0 | #include <vector>
#include <assert.h>
| int func0(std::vector<int> list1) {
int max = list1[0];
for(int x : list1) {
if(x < max) {
max = x;
}
}
return max;
}
| int main() {
assert(func0({1,2,3,-4,-6}) == -6);
assert(func0({1,2,3,-8,-9}) == -9);
assert(func0({1,2,3,4,-1}) == -1);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rcx
mov (%rax),%r8d
cmp %rax,%rcx
je 1442 <_Z5func0St6vectorIiSaIiEE+0x32>
add $0x4,%rax
mov %r8d,%edx
jmp 1436 <_Z5func0St6vectorIiSaIiEE+0x26>
nopl 0x0(%rax)
mov (%rax),%edx
add $0x4,%rax
cmp %edx... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi]
mov rsi, [rdi+8]
mov edx, [rax]
cmp rax, rsi
jz short loc_1488
mov rcx, rsi
sub rcx, rax
and ecx, 4
jz short loc_1470
mov ecx, [rax]
cmp edx, ecx
cmovg edx, ecx
add rax, 4
cmp rax, rsi
jz short loc_1488
nop ... | long long func0(signed int **a1)
{
signed int *v1; // rax
int *v2; // rsi
signed int v3; // edx
v1 = *a1;
v2 = a1[1];
v3 = **a1;
if ( *a1 != v2 )
{
if ( (((_BYTE)v2 - (_BYTE)v1) & 4) == 0 )
goto LABEL_14;
if ( v3 > *v1 )
v3 = *v1;
if ( ++v1 != v2 )
{
LABEL_14:
do
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV EDX,dword ptr [RAX]
CMP RAX,RSI
JZ 0x00101488
MOV RCX,RSI
SUB RCX,RAX
AND ECX,0x4
JZ 0x00101470
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
CMOVG EDX,ECX
ADD RAX,0x4
CMP RAX,RSI
JZ 0x00101488
NOP dword ptr [RAX]
LAB_00101470:
MOV ECX,dword ptr [RAX]
CMP E... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int *piVar1;
int *piVar2;
int iVar3;
int4 in_register_0000003c;
piVar2 = *(int **)CONCAT44(in_register_0000003c,param_1);
piVar1 = *(int **)(CONCAT44(in_register_0000003c,param_1) + 8);
iVar3 = *piVar2;
if (piVar2 != pi... |
1,771 | func0 | #include <vector>
#include <assert.h>
| int func0(std::vector<int> list1) {
int max = list1[0];
for(int x : list1) {
if(x < max) {
max = x;
}
}
return max;
}
| int main() {
assert(func0({1,2,3,-4,-6}) == -6);
assert(func0({1,2,3,-8,-9}) == -9);
assert(func0({1,2,3,4,-1}) == -1);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%r8
mov (%rcx),%eax
cmp %rcx,%r8
je 16f8 <_Z5func0St6vectorIiSaIiEE+0xe8>
lea -0x4(%r8),%rdi
mov %rcx,%rdx
sub %rcx,%rdi
mov %rdi,%rsi
shr $0x2,%rsi
add $0x1,%rsi
cmp $0x8,%rdi
jbe 16cf <_Z5func0... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rcx, [rdi]
mov r8, [rdi+8]
mov eax, [rcx]
cmp rcx, r8
jz locret_1706
lea rdi, [r8-4]
mov rdx, rcx
sub rdi, rcx
mov rsi, rdi
shr rsi, 2
add rsi, 1
cmp rdi, 8
jbe loc_16DD
movd xmm4, eax
mov rax, rsi
shr rax, 2
pshufd ... | long long func0(const __m128i **a1)
{
int *v1; // rcx
unsigned int *v2; // r8
long long result; // rax
const __m128i *v4; // rdx
unsigned long long v5; // rsi
__m128i v6; // xmm0
__m128i v7; // xmm1
__m128i v8; // xmm3
__m128i v9; // xmm1
__m128i v10; // xmm2
__m128i v11; // xmm1
__m128i v12; /... | func0:
ENDBR64
MOV RCX,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
MOV EAX,dword ptr [RCX]
CMP RCX,R8
JZ 0x00101706
LEA RDI,[R8 + -0x4]
MOV RDX,RCX
SUB RDI,RCX
MOV RSI,RDI
SHR RSI,0x2
ADD RSI,0x1
CMP RDI,0x8
JBE 0x001016dd
MOVD XMM4,EAX
MOV RAX,RSI
SHR RAX,0x2
PSHUFD XMM0,XMM4,0x0
SHL RAX,0x4
ADD RAX,RCX
NOP dword ptr... | /* func0(std::vector<int, std::allocator<int> >) */
uint func0(vector param_1)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
uint uVar6;
uint *puVar7;
uint *puVar8;
uint *puVar9;
uint uVar10;
uint *puVar11;
uint *puVar12;
ulong uVar13;
int4 in_register_0000003c;
u... |
1,772 | func0 |
#include <bits/stdc++.h>
#include <cassert>
#include <string>
using namespace std;
| string func0(const vector<vector<int>>& test_list, int K) {
vector<vector<int>> res;
for (const auto& ele : test_list) {
int N = ele.size();
if (K > N - K) {
res.emplace_back(); // empty tuple
continue;
}
vector<int> trimmed(ele.begin() + K, ele.be... | int main(){
assert(func0({{5, 3, 2, 1, 4}, {3, 4, 9, 2, 1}, {9, 1, 2, 3, 5}, {4, 8, 2, 1, 7}}, 2) == "[(2), (9), (2), (2)]");
assert(func0({{5, 3, 2, 1, 4}, {3, 4, 9, 2, 1}, {9, 1, 2, 3, 5}, {4, 8, 2, 1, 7}}, 1) == "[(3, 2, 1), (4, 9, 2), (1, 2, 3), (8, 2, 1)]");
assert(func0({{7, 8, 4, 9}, {11, 8, 12, 4... | O0 | cpp | func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0xe0,%rsp
mov %rdi,-0xd8(%rbp)
mov %rsi,-0xe0(%rbp)
mov %edx,-0xe4(%rbp)
mov %fs:0x28,%rax
mov ... | _Z5func0B5cxx11RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 0F0h
mov [rbp+var_E8], rdi
mov [rbp+var_F0], rsi
mov [rbp+var_F4], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_80]
mov rdi, rax
call _... | long long func0[abi:cxx11](long long a1, long long a2, int a3)
{
long long v3; // r12
long long v4; // r12
long long v5; // rax
long long v6; // rax
int *v7; // rax
long long v8; // rax
long long v9; // rax
long long v10; // rax
unsigned long long v11; // rax
long long v12; // rax
unsigned long l... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0xf0
MOV qword ptr [RBP + -0xe8],RDI
MOV qword ptr [RBP + -0xf0],RSI
MOV dword ptr [RBP + -0xf4],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x80]
MOV RDI,RAX
CALL 0x001038d8
MOV RAX,qword ptr [RBP +... | /* func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&, int) */
vector * func0_abi_cxx11_(vector *param_1,int param_2)
{
bool bVar1;
int8 uVar2;
int8 uVar3;
vector<int,std::allocator<int>> *pvVar4;
long lVar5;
ulong uVar6... |
1,773 | func0 |
#include <bits/stdc++.h>
#include <cassert>
#include <string>
using namespace std;
| string func0(const vector<vector<int>>& test_list, int K) {
vector<vector<int>> res;
for (const auto& ele : test_list) {
int N = ele.size();
if (K > N - K) {
res.emplace_back(); // empty tuple
continue;
}
vector<int> trimmed(ele.begin() + K, ele.be... | int main(){
assert(func0({{5, 3, 2, 1, 4}, {3, 4, 9, 2, 1}, {9, 1, 2, 3, 5}, {4, 8, 2, 1, 7}}, 2) == "[(2), (9), (2), (2)]");
assert(func0({{5, 3, 2, 1, 4}, {3, 4, 9, 2, 1}, {9, 1, 2, 3, 5}, {4, 8, 2, 1, 7}}, 1) == "[(3, 2, 1), (4, 9, 2), (1, 2, 3), (8, 2, 1)]");
assert(func0({{7, 8, 4, 9}, {11, 8, 12, 4... | O1 | cpp | func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
mov... | _Z5func0B5cxx11RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 178h
mov r15, rdi
mov dword ptr [rsp+1A8h+var_198], edx
mov rax, fs:28h
mov [rsp+1A8h+var_40], rax
xor eax, eax
mov [rsp+1A8h+var_178], 0
mov [rsp+1A8h... | long long func0[abi:cxx11](long long a1, long long a2, int a3)
{
_QWORD *v4; // rbp
long long v5; // r14
char *v6; // rsi
_DWORD *v7; // r12
char *v8; // r13
char *v9; // r13
char *v10; // rsi
long long v11; // rdx
unsigned long long i; // r13
unsigned int v13; // ebx
char *v14; // r12
int v15;... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x178
MOV R15,RDI
MOV dword ptr [RSP + 0x10],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x168],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x0
MOV RBP,qword ptr ... | /* func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&, int) */
vector * func0_abi_cxx11_(vector *param_1,int param_2)
{
int4 *puVar1;
void *pvVar2;
long *plVar3;
uint uVar4;
int iVar5;
int8 uVar6;
int4 *puVar7;
int4 ... |
1,774 | func0 |
#include <bits/stdc++.h>
#include <cassert>
#include <string>
using namespace std;
| string func0(const vector<vector<int>>& test_list, int K) {
vector<vector<int>> res;
for (const auto& ele : test_list) {
int N = ele.size();
if (K > N - K) {
res.emplace_back(); // empty tuple
continue;
}
vector<int> trimmed(ele.begin() + K, ele.be... | int main(){
assert(func0({{5, 3, 2, 1, 4}, {3, 4, 9, 2, 1}, {9, 1, 2, 3, 5}, {4, 8, 2, 1, 7}}, 2) == "[(2), (9), (2), (2)]");
assert(func0({{5, 3, 2, 1, 4}, {3, 4, 9, 2, 1}, {9, 1, 2, 3, 5}, {4, 8, 2, 1, 7}}, 1) == "[(3, 2, 1), (4, 9, 2), (1, 2, 3), (8, 2, 1)]");
assert(func0({{7, 8, 4, 9}, {11, 8, 12, 4... | O2 | cpp | func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x98,%rsp
mov (%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
x... | _Z5func0B5cxx11RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rdi
push r14
mov r14d, edx
push r13
push r12
push rbp
push rbx
sub rsp, 188h
mov rbx, [rsi+8]
mov rbp, [rsi]
mov rax, fs:28h
mov [rsp+1B8h+var_40], rax
xor eax, eax
movsxd rax,... | long long func0[abi:cxx11](long long a1, long long **a2, int a3)
{
long long *v5; // rbx
long long *v6; // rbp
unsigned long long v7; // rbx
_DWORD *v8; // r13
_DWORD *v9; // rsi
long long v10; // r12
long long v11; // r12
long long v12; // rax
long long v13; // rsi
long long v14; // rsi
void **v... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV R15,RDI
PUSH R14
MOV R14D,EDX
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x188
MOV RBX,qword ptr [RSI + 0x8]
MOV RBP,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x178],RAX
XOR EAX,EAX
MOVSXD RAX,EDX
MOVAPS xmmword ptr [RSP + 0x40],XMM0
SHL RAX,... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&, int) */
vector * func0_abi_cxx11_(vector *param_1,int param_2)
{
vector<std::vector<int,st... |
1,775 | func0 |
#include <bits/stdc++.h>
#include <cassert>
#include <string>
using namespace std;
| string func0(const vector<vector<int>>& test_list, int K) {
vector<vector<int>> res;
for (const auto& ele : test_list) {
int N = ele.size();
if (K > N - K) {
res.emplace_back(); // empty tuple
continue;
}
vector<int> trimmed(ele.begin() + K, ele.be... | int main(){
assert(func0({{5, 3, 2, 1, 4}, {3, 4, 9, 2, 1}, {9, 1, 2, 3, 5}, {4, 8, 2, 1, 7}}, 2) == "[(2), (9), (2), (2)]");
assert(func0({{5, 3, 2, 1, 4}, {3, 4, 9, 2, 1}, {9, 1, 2, 3, 5}, {4, 8, 2, 1, 7}}, 1) == "[(3, 2, 1), (4, 9, 2), (1, 2, 3), (8, 2, 1)]");
assert(func0({{7, 8, 4, 9}, {11, 8, 12, 4... | O3 | cpp | func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x98,%rsp
mov (%rsi),%rbp
mov %fs:0x28,%rax
mov ... | _Z5func0B5cxx11RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r15
mov r15, rdi
pxor xmm0, xmm0
push r14
mov r14d, edx
push r13
push r12
push rbp
push rbx
sub rsp, 188h
mov rdi, [rsi+8]
mov rbp, [rsi]
mov rax, fs:28h
mov [rsp+1B8h+var_40], rax
xor eax, eax
movsxd rax,... | long long func0[abi:cxx11](long long a1, long long **a2, int a3)
{
long long *v5; // rdi
long long *v6; // rbp
unsigned long long v7; // rbx
_DWORD *v8; // r13
_DWORD *v9; // rsi
long long v10; // r12
long long v11; // r12
long long v12; // rax
long long v13; // rsi
long long v14; // rsi
void **v... | func0[abi:cxx11]:
ENDBR64
PUSH R15
MOV R15,RDI
PXOR XMM0,XMM0
PUSH R14
MOV R14D,EDX
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x188
MOV RDI,qword ptr [RSI + 0x8]
MOV RBP,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x178],RAX
XOR EAX,EAX
MOVSXD RAX,EDX
MOVAPS xmmword ptr [RSP + 0x40],XMM0
SHL RAX,... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&, int) */
vector * func0_abi_cxx11_(vector *param_1,int param_2)
{
void *pvVar1;
uint uVar... |
1,776 | func0 | #include <cassert>
#include <vector>
using namespace std;
| vector<vector<int>> func0(const vector<vector<int>>& test_tup1, const vector<vector<int>>& test_tup2) {
vector<vector<int>> res;
for (size_t i = 0; i < test_tup1.size() && i < test_tup2.size(); i++) {
vector<int> inner;
for (size_t j = 0; j < test_tup1[i].size() && j < test_tup2[i].size(); j... | int main() {
{
vector<vector<int>> tup1 = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
vector<vector<int>> tup2 = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
vector<vector<int>> expected = {{6, 21}, {12, 45}, {2, 9}, {7, 30}};
assert(func0(tup1, tup2) == expected);
}
{
vector<vec... | O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, 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 $0x68,%rsp
mov %rd... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EES5_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_58]
mov rdi, rax
call _ZNSt6vectorIS_IiSa... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rax
int v4; // ebx
long long v5; // rax
long long v6; // rax
unsigned long long v7; // rax
long long v8; // rax
unsigned long long v9; // rax
unsigned long long v11; // rax
unsigned long long v12; // rax
int v16; // [rsp+2... | 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 qword ptr [RBP + -0x68],RDX
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 0x001032e4
MOV qword ptr [RBP + -0x40],0x0
JM... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
... |
1,777 | func0 | #include <cassert>
#include <vector>
using namespace std;
| vector<vector<int>> func0(const vector<vector<int>>& test_tup1, const vector<vector<int>>& test_tup2) {
vector<vector<int>> res;
for (size_t i = 0; i < test_tup1.size() && i < test_tup2.size(); i++) {
vector<int> inner;
for (size_t j = 0; j < test_tup1[i].size() && j < test_tup2[i].size(); j... | int main() {
{
vector<vector<int>> tup1 = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
vector<vector<int>> tup2 = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
vector<vector<int>> expected = {{6, 21}, {12, 45}, {2, 9}, {7, 30}};
assert(func0(tup1, tup2) == expected);
}
{
vector<vec... | O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %r... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EES5_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov r15, rdi
mov r12, rsi
mov r13, rdx
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov ... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
unsigned long long v5; // r14
unsigned long long v7; // rbx
long long *v8; // rax
long long v9; // rdx
_QWORD *v10; // rax
int v11; // eax
int *v12; // rsi
_QWORD *v13; // rbx
int *v14; // rax
signed long long v15; // rbp
_DWORD *v16; // rax
s... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV R15,RDI
MOV R12,RSI
MOV R13,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV R14D,0x0
LEA RAX,[RSP + 0x2c]
MOV qword pt... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
long lVar1;
... |
1,778 | func0 | #include <cassert>
#include <vector>
using namespace std;
| vector<vector<int>> func0(const vector<vector<int>>& test_tup1, const vector<vector<int>>& test_tup2) {
vector<vector<int>> res;
for (size_t i = 0; i < test_tup1.size() && i < test_tup2.size(); i++) {
vector<int> inner;
for (size_t j = 0; j < test_tup1[i].size() && j < test_tup2[i].size(); j... | int main() {
{
vector<vector<int>> tup1 = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
vector<vector<int>> tup2 = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
vector<vector<int>> expected = {{6, 21}, {12, 45}, {2, 9}, {7, 30}};
assert(func0(tup1, tup2) == expected);
}
{
vector<vec... | O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %r... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EES5_:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rdi
push r14
mov r14, rsi
push r13
xor r13d, r13d
push r12
mov r12, rdx
push rbp
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea rax, [rsp+88h+va... | long long func0(long long a1, long long *a2, long long *a3)
{
unsigned long long v5; // r13
long long v7; // rax
long long v8; // rax
long long v9; // rdx
unsigned long long v10; // rbx
long long v11; // rbp
long long *v12; // rsi
long long v13; // rcx
_QWORD *v14; // rax
int v15; // eax
char *v1... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV R15,RDI
PUSH R14
MOV R14,RSI
PUSH R13
XOR R13D,R13D
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x2c]
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [R... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
long lVar1;
... |
1,779 | func0 | #include <cassert>
#include <vector>
using namespace std;
| vector<vector<int>> func0(const vector<vector<int>>& test_tup1, const vector<vector<int>>& test_tup2) {
vector<vector<int>> res;
for (size_t i = 0; i < test_tup1.size() && i < test_tup2.size(); i++) {
vector<int> inner;
for (size_t j = 0; j < test_tup1[i].size() && j < test_tup2[i].size(); j... | int main() {
{
vector<vector<int>> tup1 = {{1, 3}, {4, 5}, {2, 9}, {1, 10}};
vector<vector<int>> tup2 = {{6, 7}, {3, 9}, {1, 1}, {7, 3}};
vector<vector<int>> expected = {{6, 21}, {12, 45}, {2, 9}, {7, 30}};
assert(func0(tup1, tup2) == expected);
}
{
vector<vec... | O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
pu... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EES5_:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rsi
push r14
mov r14, rdi
push r13
xor r13d, r13d
push r12
mov r12, rdx
push rbp
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea rax, [rsp+88h+va... | long long func0(long long a1, long long *a2, long long *a3)
{
unsigned long long v5; // r13
long long v7; // rdx
long long v8; // rax
unsigned long long v9; // rbx
long long v10; // rbp
long long *v11; // rsi
long long v12; // rcx
_QWORD *v13; // rax
int v14; // eax
char *v15; // rsi
_QWORD *v16;... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV R15,RSI
PUSH R14
MOV R14,RDI
PUSH R13
XOR R13D,R13D
PUSH R12
MOV R12,RDX
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x2c]
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
long lVar1;
... |
1,780 | func0 |
#include <vector>
#include <cassert>
| int func0(const std::vector<char>& tup, const std::vector<char>& lst) {
int count = 0;
for (char item : tup) {
for (char val : lst) {
if (item == val) {
count++;
break;
}
}
}
return count;
}
| int main() {
assert(func0({'a', 'a', 'c', 'b', 'd'}, {'a', 'b'}) == 3);
assert(func0({1, 2, 3, 1, 4, 6, 7, 1, 4}, {1, 4, 7}) == 6);
assert(func0({1, 2, 3, 4, 5, 6}, {1, 2}) == 2);
return 0;
}
| O0 | cpp | func0(std::vector<char, std::allocator<char> > const&, std::vector<char, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x3c(%rbp)
mov -0x48(%rbp),%rax
mov... | _Z5func0RKSt6vectorIcSaIcEES3_:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_3C], 0
mov rax, [rbp+var_48]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdi, rax
c... | long long func0(long long a1, long long a2)
{
char v3; // [rsp+12h] [rbp-3Eh]
unsigned int v4; // [rsp+14h] [rbp-3Ch]
long long v5; // [rsp+18h] [rbp-38h] BYREF
long long v6; // [rsp+20h] [rbp-30h] BYREF
long long v7; // [rsp+28h] [rbp-28h] BYREF
_QWORD v8[2]; // [rsp+30h] [rbp-20h] BYREF
long long v9; /... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,... | /* func0(std::vector<char, std::allocator<char> > const&, std::vector<char, std::allocator<char> >
const&) */
int func0(vector *param_1,vector *param_2)
{
char cVar1;
bool bVar2;
char *pcVar3;
long in_FS_OFFSET;
int local_44;
int8 local_40;
int8 local_38;
int8 local_30;
int8 local_28;
vector<ch... |
1,781 | func0 |
#include <vector>
#include <cassert>
| int func0(const std::vector<char>& tup, const std::vector<char>& lst) {
int count = 0;
for (char item : tup) {
for (char val : lst) {
if (item == val) {
count++;
break;
}
}
}
return count;
}
| int main() {
assert(func0({'a', 'a', 'c', 'b', 'd'}, {'a', 'b'}) == 3);
assert(func0({1, 2, 3, 1, 4, 6, 7, 1, 4}, {1, 4, 7}) == 6);
assert(func0({1, 2, 3, 4, 5, 6}, {1, 2}) == 2);
return 0;
}
| O1 | cpp | func0(std::vector<char, std::allocator<char> > const&, std::vector<char, std::allocator<char> > const&):
endbr64
mov %rsi,%rax
mov (%rdi),%rsi
mov 0x8(%rdi),%r8
cmp %r8,%rsi
je 1252 <_Z5func0RKSt6vectorIcSaIcEES3_+0x49>
mov (%rax),%rdi
mov 0x8(%rax),%rcx
mov $0x0,%r9d
jmp 1238 <_Z5func0RKSt6... | _Z5func0RKSt6vectorIcSaIcEES3_:
endbr64
mov rax, rsi
mov rsi, [rdi]
mov r8, [rdi+8]
cmp r8, rsi
jz short loc_1252
mov rdi, [rax]
mov rcx, [rax+8]
mov r9d, 0
jmp short loc_1238
loc_122B:
add r9d, 1
loc_122F:
add rsi, 1
cmp r8, rsi
jz short loc_1258
loc_1238:
movzx ... | long long func0(long long a1, _QWORD *a2)
{
_BYTE *v3; // rsi
_BYTE *v4; // r8
_BYTE *v5; // rdi
_BYTE *v6; // rcx
unsigned int v7; // r9d
_BYTE *v8; // rax
v3 = *(_BYTE **)a1;
v4 = *(_BYTE **)(a1 + 8);
if ( v4 == *(_BYTE **)a1 )
{
return 0;
}
else
{
v5 = (_BYTE *)*a2;
v6 = (_BYT... | func0:
ENDBR64
MOV RAX,RSI
MOV RSI,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
CMP R8,RSI
JZ 0x00101252
MOV RDI,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
MOV R9D,0x0
JMP 0x00101238
LAB_0010122b:
ADD R9D,0x1
LAB_0010122f:
ADD RSI,0x1
CMP R8,RSI
JZ 0x00101258
LAB_00101238:
MOVZX EDX,byte ptr [RSI]
CMP RDI,RCX
JZ 0x0... | /* func0(std::vector<char, std::allocator<char> > const&, std::vector<char, std::allocator<char> >
const&) */
int func0(vector *param_1,vector *param_2)
{
char *pcVar1;
char *pcVar2;
int iVar3;
pcVar2 = *(char **)param_1;
if (*(char **)(param_1 + 8) == pcVar2) {
iVar3 = 0;
}
else {
iVar3 =... |
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.