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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
2,482 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <cctype>
#include <algorithm>
using namespace std;
| vector<string> func0(const vector<string>& test_list, int K) {
vector<string> res;
for (const auto &ele : test_list) {
if (!ele.empty() && all_of(ele.begin(), ele.end(), [](char c){ return isdigit(c); })) {
int num = stoi(ele);
res.push_back(to_string(num + K));
} e... | int main() {
{
vector<string> input = {"MSM", "234", "is", "98", "123", "best", "4"};
vector<string> expected = {"MSM", "240", "is", "104", "129", "best", "10"};
assert(func0(input, 6) == expected);
}
{
vector<string> input = {"Dart", "356", "is", "88", "169", "Super",... | 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&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x5... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 148h
mov [rsp+178h+var_16C], edx
mov rax, fs:28h
mov [rsp+178h+var_40], rax
xor eax, eax
mov... | long long func0(long long a1, char ***a2, int a3)
{
char **v4; // r13
char **i; // rbx
long long v6; // rdx
char *v7; // r15
char *v8; // rcx
char *v9; // r8
char *v10; // rax
_QWORD *v11; // rdi
int *v13; // r12
int v14; // eax
long long v15; // rax
int v16; // eax
unsigned int v17; // r12d
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x148
MOV dword ptr [RSP + 0xc],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x138],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RSP + 0x38]
MOVUPS xmmword ptr [RDI],XMM0
MOV R13,qword ptr [RSI + 0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::string, std::allocator<std::string > > const&, int) */
vector * func0(vector *param_1,int param_2)
{
uint uVar1;
char *pcVar2;
char cVar3;
string *psVar4;
char *pcVar5;
int8 uVar6;
int8 uVar7;
... |
2,483 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <cctype>
#include <algorithm>
using namespace std;
| vector<string> func0(const vector<string>& test_list, int K) {
vector<string> res;
for (const auto &ele : test_list) {
if (!ele.empty() && all_of(ele.begin(), ele.end(), [](char c){ return isdigit(c); })) {
int num = stoi(ele);
res.push_back(to_string(num + K));
} e... | int main() {
{
vector<string> input = {"MSM", "234", "is", "98", "123", "best", "4"};
vector<string> expected = {"MSM", "240", "is", "104", "129", "best", "10"};
assert(func0(input, 6) == expected);
}
{
vector<string> input = {"Dart", "356", "is", "88", "169", "Super",... | 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&, int):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 138h
mov [rsp+168h+var_160], edx
mov rax, fs:28h
mov [rsp+168h+var_40], rax
xor eax, eax
mov... | long long func0(long long a1, char ***a2, int a3, unsigned long long a4)
{
char **v5; // r14
char **i; // rbp
signed long long v7; // rbx
char *v8; // r15
char *v9; // rdx
char *v10; // rsi
char *v11; // rax
long long v12; // r12
long long v13; // rsi
void *v14; // rdi
char *v15; // r15
long lo... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x138
MOV dword ptr [RSP + 0x8],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RSP + 0x28]
MOVUPS xmmword ptr [RDI],XMM0
MOV R14,qword ptr [RSI + 0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::string, std::allocator<std::string > > const&, int) */
vector * func0(vector *param_1,int param_2)
{
char *pcVar1;
string *psVar2;
char *pcVar3;
int *__src;
uint uVar4;
int8 uVar5;
int8 uVar6;
... |
2,484 | func0 |
#include <iostream>
#include <cassert>
using namespace std;
| double func0(int arr1[], int arr2[], int n) {
int i = 0;
int j = 0;
int m1 = -1;
int m2 = -1;
int count = 0;
while (count < n + 1) {
count++;
if (i == n) {
m1 = m2;
m2 = arr2[0];
break;
} else if (j == n) {
m1 =... | int main() {
int arr1A[] = {1, 12, 15, 26, 38};
int arr2A[] = {2, 13, 17, 30, 45};
assert(func0(arr1A, arr2A, 5) == 16.0);
int arr1B[] = {2, 4, 8, 9};
int arr2B[] = {7, 13, 19, 28};
assert(func0(arr1B, arr2B, 4) == 8.5);
int arr1C[] = {3, 6, 14, 23, 36, 42};
int arr2C[] = {2,... | O0 | cpp | func0(int*, int*, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %edx,-0x34(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0xffffffff,-0xc(%rbp)
movl $0xffffffff,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x34(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 12... | _Z5func0PiS_i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_34], edx
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0FFFFFFFFh
mov [rbp+var_8], 0FFFFFFFFh
mov [rbp+var_4], 0
jmp loc_1298
loc_11E4:
add [rbp+var_4], 1
mov ... | double func0(int *a1, int *a2, int a3)
{
int v4; // [rsp+20h] [rbp-14h]
int v5; // [rsp+24h] [rbp-10h]
int v6; // [rsp+28h] [rbp-Ch]
int v7; // [rsp+2Ch] [rbp-8h]
int v8; // [rsp+30h] [rbp-4h]
v4 = 0;
v5 = 0;
v6 = -1;
v7 = -1;
v8 = 0;
while ( a3 >= v8 )
{
++v8;
if ( v4 == a3 )
{
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x34],EDX
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0xffffffff
MOV dword ptr [RBP + -0x8],0xffffffff
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101298
LA... | /* func0(int*, int*, int) */
double func0(int *param_1,int *param_2,int param_3)
{
int local_1c;
int local_18;
int local_14;
int local_10;
int local_c;
local_1c = 0;
local_18 = 0;
local_14 = -1;
local_10 = -1;
local_c = 0;
do {
if (param_3 < local_c) {
LAB_001012a4:
return (double)(... |
2,485 | func0 |
#include <iostream>
#include <cassert>
using namespace std;
| double func0(int arr1[], int arr2[], int n) {
int i = 0;
int j = 0;
int m1 = -1;
int m2 = -1;
int count = 0;
while (count < n + 1) {
count++;
if (i == n) {
m1 = m2;
m2 = arr2[0];
break;
} else if (j == n) {
m1 =... | int main() {
int arr1A[] = {1, 12, 15, 26, 38};
int arr2A[] = {2, 13, 17, 30, 45};
assert(func0(arr1A, arr2A, 5) == 16.0);
int arr1B[] = {2, 4, 8, 9};
int arr2B[] = {7, 13, 19, 28};
assert(func0(arr1B, arr2B, 4) == 8.5);
int arr1C[] = {3, 6, 14, 23, 36, 42};
int arr2C[] = {2,... | O1 | cpp | func0(int*, int*, int):
endbr64
test %edx,%edx
js 1265 <_Z5func0PiS_i+0x7c>
je 120c <_Z5func0PiS_i+0x23>
mov $0x1,%r9d
mov $0xffffffff,%r11d
mov $0x0,%r8d
mov $0x0,%ecx
jmp 124d <_Z5func0PiS_i+0x64>
mov $0xffffffff,%eax
mov %eax,%r11d
mov (%rsi),%eax
add %r11d,%eax
pxor %xmm0,%xmm... | _Z5func0PiS_i:
endbr64
test edx, edx
js short loc_1225
jz short loc_11CC
mov r9d, 1
mov r11d, 0FFFFFFFFh
mov r8d, 0
mov ecx, 0
jmp short loc_120B
loc_11CC:
mov eax, 0FFFFFFFFh
loc_11D1:
mov r11d, eax
mov eax, [rsi]
loc_11D6:
add r11d, eax
pxor xmm0, xmm0
cvtsi2sd xmm0... | double func0(int *a1, int *a2, int a3)
{
int v3; // r9d
int v4; // r11d
int v5; // r8d
int v6; // ecx
int v7; // eax
int v9; // r10d
if ( a3 < 0 )
{
v7 = -1;
v4 = -1;
}
else if ( a3 )
{
v3 = 1;
v4 = -1;
v5 = 0;
v6 = 0;
while ( 1 )
{
v9 = a1[v6];
v7 = a... | func0:
ENDBR64
TEST EDX,EDX
JS 0x00101225
JZ 0x001011cc
MOV R9D,0x1
MOV R11D,0xffffffff
MOV R8D,0x0
MOV ECX,0x0
JMP 0x0010120b
LAB_001011cc:
MOV EAX,0xffffffff
LAB_001011d1:
MOV R11D,EAX
MOV EAX,dword ptr [RSI]
LAB_001011d6:
ADD R11D,EAX
PXOR XMM0,XMM0
CVTSI2SD XMM0,R11D
MULSD XMM0,qword ptr [0x001020a8]
RET
LAB_001011... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int*, int*, int) */
double func0(int *param_1,int *param_2,int param_3)
{
int iVar1;
int iVar2;
long lVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
if (param_3 < 0) {
iVar2 = -1;
iVar7 = -1;
... |
2,486 | func0 |
#include <iostream>
#include <cassert>
using namespace std;
| double func0(int arr1[], int arr2[], int n) {
int i = 0;
int j = 0;
int m1 = -1;
int m2 = -1;
int count = 0;
while (count < n + 1) {
count++;
if (i == n) {
m1 = m2;
m2 = arr2[0];
break;
} else if (j == n) {
m1 =... | int main() {
int arr1A[] = {1, 12, 15, 26, 38};
int arr2A[] = {2, 13, 17, 30, 45};
assert(func0(arr1A, arr2A, 5) == 16.0);
int arr1B[] = {2, 4, 8, 9};
int arr2B[] = {7, 13, 19, 28};
assert(func0(arr1B, arr2B, 4) == 8.5);
int arr1C[] = {3, 6, 14, 23, 36, 42};
int arr2C[] = {2,... | O2 | cpp | func0(int*, int*, int):
endbr64
test %edx,%edx
js 14f4 <_Z5func0PiS_i+0xa4>
je 14fd <_Z5func0PiS_i+0xad>
push %rbx
mov $0x1,%r9d
mov $0xffffffff,%ebx
xor %r8d,%r8d
xor %ecx,%ecx
jmp 1492 <_Z5func0PiS_i+0x42>
nopl (%rax)
add $0x1,%ecx
mov %r10d,%eax
cmp %r9d,%edx
jl 14ae <_Z5fun... | _Z5func0PiS_i:
endbr64
test edx, edx
js loc_14E3
jz short loc_14B2
mov r9d, 1
mov r11d, 0FFFFFFFFh
xor r8d, r8d
xor ecx, ecx
jmp short loc_1480
loc_1468:
add ecx, 1
cmp edx, r9d
jl short loc_149E
loc_1470:
add r9d, 1
cmp ecx, edx
jz short loc_14B7
cmp edx, ... | double func0(int *a1, int *a2, int a3)
{
int v3; // r9d
int v4; // r11d
int v5; // r8d
int v6; // ecx
int v7; // eax
int v8; // r10d
if ( a3 < 0 )
return -1.0;
if ( a3 )
{
v3 = 1;
v4 = -1;
v5 = 0;
v6 = 0;
while ( 1 )
{
v7 = a1[v6];
v8 = a2[v5];
if ( v7 <... | func0:
ENDBR64
TEST EDX,EDX
JS 0x001014e3
JZ 0x001014b2
MOV R9D,0x1
MOV R11D,0xffffffff
XOR R8D,R8D
XOR ECX,ECX
JMP 0x00101480
LAB_00101468:
ADD ECX,0x1
CMP EDX,R9D
JL 0x0010149e
LAB_00101470:
ADD R9D,0x1
CMP ECX,EDX
JZ 0x001014b7
CMP EDX,R8D
JZ 0x001014d0
MOV R11D,EAX
LAB_00101480:
MOVSXD RAX,ECX
MOVSXD R10,R8D
MOV EA... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int*, int*, int) */
double func0(int *param_1,int *param_2,int param_3)
{
int iVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_3 < 0) {
return DAT_001020a8;
}
if (param_3 == 0... |
2,487 | func0 |
#include <iostream>
#include <cassert>
using namespace std;
| double func0(int arr1[], int arr2[], int n) {
int i = 0;
int j = 0;
int m1 = -1;
int m2 = -1;
int count = 0;
while (count < n + 1) {
count++;
if (i == n) {
m1 = m2;
m2 = arr2[0];
break;
} else if (j == n) {
m1 =... | int main() {
int arr1A[] = {1, 12, 15, 26, 38};
int arr2A[] = {2, 13, 17, 30, 45};
assert(func0(arr1A, arr2A, 5) == 16.0);
int arr1B[] = {2, 4, 8, 9};
int arr2B[] = {7, 13, 19, 28};
assert(func0(arr1B, arr2B, 4) == 8.5);
int arr1C[] = {3, 6, 14, 23, 36, 42};
int arr2C[] = {2,... | O3 | cpp | func0(int*, int*, int):
endbr64
test %edx,%edx
js 1494 <_Z5func0PiS_i+0xa4>
je 149d <_Z5func0PiS_i+0xad>
push %rbx
mov $0x1,%r9d
mov $0xffffffff,%ebx
xor %r8d,%r8d
xor %ecx,%ecx
jmp 1432 <_Z5func0PiS_i+0x42>
nopl (%rax)
add $0x1,%ecx
mov %r10d,%eax
cmp %r9d,%edx
jl 144e <_Z5fun... | _Z5func0PiS_i:
endbr64
test edx, edx
js loc_14D3
jz short loc_14A2
mov r9d, 1
mov r11d, 0FFFFFFFFh
xor r8d, r8d
xor ecx, ecx
jmp short loc_1470
loc_1458:
add ecx, 1
cmp edx, r9d
jl short loc_148E
loc_1460:
add r9d, 1
cmp ecx, edx
jz short loc_14A7
cmp edx, ... | double func0(int *a1, int *a2, int a3)
{
int v3; // r9d
int v4; // r11d
int v5; // r8d
int v6; // ecx
int v7; // eax
int v8; // r10d
if ( a3 < 0 )
return -1.0;
if ( a3 )
{
v3 = 1;
v4 = -1;
v5 = 0;
v6 = 0;
while ( 1 )
{
v7 = a1[v6];
v8 = a2[v5];
if ( v7 <... | func0:
ENDBR64
TEST EDX,EDX
JS 0x001014d3
JZ 0x001014a2
MOV R9D,0x1
MOV R11D,0xffffffff
XOR R8D,R8D
XOR ECX,ECX
JMP 0x00101470
LAB_00101458:
ADD ECX,0x1
CMP EDX,R9D
JL 0x0010148e
LAB_00101460:
ADD R9D,0x1
CMP ECX,EDX
JZ 0x001014a7
CMP EDX,R8D
JZ 0x001014c0
MOV R11D,EAX
LAB_00101470:
MOVSXD RAX,ECX
MOVSXD R10,R8D
MOV EA... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int*, int*, int) */
double func0(int *param_1,int *param_2,int param_3)
{
int iVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
if (param_3 < 0) {
return DAT_001020b0;
}
if (param_3 == 0... |
2,488 | func0 |
#include <vector>
#include <cmath>
#include <assert.h>
| std::vector<int> func0(const std::vector<int>& nums, int n) {
std::vector<int> result;
for (int num : nums) {
result.push_back(std::pow(num, n));
}
return result;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 2) == std::vector<int>{1, 4, 9, 16, 25, 36, 49, 64, 81, 100}));
assert((func0({10, 20, 30}, 3) == std::vector<int>{1000, 8000, 27000}));
assert((func0({12, 15}, 5) == std::vector<int>{248832, 759375}));
return 0;
}
| O0 | cpp | func0(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 -0x48(%rbp),%rax
mov %rax,%rdi
callq 1a4e <_ZNSt6... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov [rbp+var_54], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::v... | long long func0(long long a1, long long a2, unsigned int a3)
{
int v5; // [rsp+28h] [rbp-38h] BYREF
unsigned int v6; // [rsp+2Ch] [rbp-34h]
long long v7; // [rsp+30h] [rbp-30h] BYREF
_QWORD v8[4]; // [rsp+38h] [rbp-28h] BYREF
v8[2] = __readfsqword(0x28u);
std::vector<int>::vector(a1);
v8[1] = a2;
v7 =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV dword ptr [RBP + -0x54],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00101ad2
MOV RAX,qword ptr [RBP + -0x50]
MO... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
vector * func0(vector *param_1,int param_2)
{
bool bVar1;
int *piVar2;
int in_EDX;
int4 in_register_00000034;
long in_FS_OFFSET;
double extraout_XMM0_Qa;
int local_40;
int local_3c;
int8 local_38;
int8 local_30;
vector<int,std::allo... |
2,489 | func0 |
#include <vector>
#include <cmath>
#include <assert.h>
| std::vector<int> func0(const std::vector<int>& nums, int n) {
std::vector<int> result;
for (int num : nums) {
result.push_back(std::pow(num, n));
}
return result;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 2) == std::vector<int>{1, 4, 9, 16, 25, 36, 49, 64, 81, 100}));
assert((func0({10, 20, 30}, 3) == std::vector<int>{1000, 8000, 27000}));
assert((func0({12, 15}, 5) == std::vector<int>{248832, 759375}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbp
mov 0x8(%rsi),%r12
cmp %r12,%rbp... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r14
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rbp, [rsi]
mov r12, [rsi+8]
cmp ... | _QWORD * func0(_QWORD *a1, int **a2, int a3)
{
int *v3; // rbp
int *v4; // r12
double v5; // r14
int v6; // eax
int *v7; // rsi
int v9; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v10; // [rsp+8h] [rbp-30h]
v10 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v3 = *a2;
v4 = a2[... | func0:
ENDBR64
PUSH R14
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBP,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
CMP R12,RBP
JZ 0x0010132c
PXOR XMM2... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
vector * func0(vector *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int in_EDX;
int *piVar3;
int4 in_register_00000034;
long in_FS_OFFSET;
double dVar4;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
... |
2,490 | func0 |
#include <vector>
#include <cmath>
#include <assert.h>
| std::vector<int> func0(const std::vector<int>& nums, int n) {
std::vector<int> result;
for (int num : nums) {
result.push_back(std::pow(num, n));
}
return result;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 2) == std::vector<int>{1, 4, 9, 16, 25, 36, 49, 64, 81, 100}));
assert((func0({10, 20, 30}, 3) == std::vector<int>{1000, 8000, 27000}));
assert((func0({12, 15}, 5) == std::vector<int>{248832, 759375}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
cmp ... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov r12, [rsi+8]... | long long func0(long long a1, int **a2, int a3)
{
int *v3; // rbx
int *v4; // r12
double v5; // r14
double v6; // xmm0_8
_DWORD *v7; // rsi
int v9; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v10; // [rsp+4h] [rbp-30h]
v10 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RBX,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
CMP R12,RBX
JZ 0x001016f8
PXOR XMM2... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
vector * func0(vector *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int in_EDX;
int *piVar3;
int4 in_register_00000034;
long in_FS_OFFSET;
double dVar4;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
... |
2,491 | func0 |
#include <vector>
#include <cmath>
#include <assert.h>
| std::vector<int> func0(const std::vector<int>& nums, int n) {
std::vector<int> result;
for (int num : nums) {
result.push_back(std::pow(num, n));
}
return result;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 2) == std::vector<int>{1, 4, 9, 16, 25, 36, 49, 64, 81, 100}));
assert((func0({10, 20, 30}, 3) == std::vector<int>{1000, 8000, 27000}));
assert((func0({12, 15}, 5) == std::vector<int>{248832, 759375}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
cmp ... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov r12, [rsi+8]... | long long func0(long long a1, int **a2, int a3)
{
int *v3; // rbx
int *v4; // r12
double v5; // r14
double v6; // xmm0_8
_DWORD *v7; // rsi
int v9; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v10; // [rsp+4h] [rbp-30h]
v10 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RBX,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
CMP R12,RBX
JZ 0x001016f8
PXOR XMM2... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
vector * func0(vector *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int in_EDX;
int *piVar3;
int4 in_register_00000034;
long in_FS_OFFSET;
double dVar4;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
... |
2,492 | func0 |
#include <iostream>
#include <string>
#include <cassert>
#include <cctype>
| std::string func0(const std::string& string) {
std::string result = "";
for (char c : string) {
result += toupper(c);
}
return result;
}
| int main() {
assert(func0("person") == "PERSON");
assert(func0("final") == "FINAL");
assert(func0("Valid") == "VALID");
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 -0x28(%rbp),%rax
mov %rax,%rdi
callq ... | _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_30]
mov [rbp+var_20], rax
nop
nop
lea rdx, [r... | long long func0(long long a1, long long a2)
{
char v2; // al
char v4; // [rsp+17h] [rbp-39h]
long long v5; // [rsp+18h] [rbp-38h] BYREF
long long v6; // [rsp+20h] [rbp-30h] BYREF
long long v7; // [rsp+28h] [rbp-28h]
long long *v8; // [rsp+30h] [rbp-20h]
unsigned long long v9; // [rsp+38h] [rbp-18h]
v9... | 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 + -0x30]
MOV qword ptr [RBP + -0x20],RAX
NOP
NOP
LEA RDX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x48]
LEA RCX,[0... | /* func0(std::string const&) */
string * func0(string *param_1)
{
bool bVar1;
int iVar2;
char *pcVar3;
long in_FS_OFFSET;
int8 local_40;
int8 local_38 [2];
int8 *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = local_38;
/* try { // try from 001... |
2,493 | func0 |
#include <iostream>
#include <string>
#include <cassert>
#include <cctype>
| std::string func0(const std::string& string) {
std::string result = "";
for (char c : string) {
result += toupper(c);
}
return result;
}
| int main() {
assert(func0("person") == "PERSON");
assert(func0("final") == "FINAL");
assert(func0("Valid") == "VALID");
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,%rbx
mov %rsi,%r12
lea 0x10(%rdi),%r15
mov %r15,(%rdi)
lea 0xde3(%rip),%rdx
mov %rdx,%rsi
callq 15e... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov r12, rsi
lea r15, [rdi+10h]
mov [rdi], r15
lea rsi, aFunc0ValidVali+19h; ""
mov rdx, rsi
call _ZNSt7__cxx1112basic_... | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v2; // rbp
unsigned long long v4; // rax
char v5; // r13
long long v6; // r12
unsigned long long v7; // r14
char *v8; // [rsp+8h] [rbp-40h]
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "", "");
v2 = *a2;
v8 = &(*a2)[(_QWORD)a2[1]];
if ( v8... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R12,RSI
LEA R15,[RDI + 0x10]
MOV qword ptr [RDI],R15
LEA RSI,[0x1020e0]
MOV RDX,RSI
LAB_001012b2:
CALL 0x001015ba
MOV RBP,qword ptr [R12]
MOV RAX,RBP
ADD RAX,qword ptr [R12 + 0x8]
MOV qword ptr [RSP + 0x8],RAX
CMP RAX,RBP
... | /* func0(std::string const&) */
string * func0(string *param_1)
{
ulong uVar1;
int iVar2;
char *pcVar3;
ulong uVar4;
char *pcVar5;
int8 *in_RSI;
*(string **)param_1 = param_1 + 0x10;
std::string::_M_construct<char_const*>((char *)param_1,"",0x1020e0);
pcVar5 = (char *)*in_RSI;
pcVar3 = pcVar5 +... |
2,494 | func0 |
#include <iostream>
#include <string>
#include <cassert>
#include <cctype>
| std::string func0(const std::string& string) {
std::string result = "";
for (char c : string) {
result += toupper(c);
}
return result;
}
| int main() {
assert(func0("person") == "PERSON");
assert(func0("final") == "FINAL");
assert(func0("Valid") == "VALID");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
lea 0x10(%rdi),%r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movb $0x0,0x10(%rdi)
mov %r15,(%rdi)
mov (%rsi),%rbx
movq $0x0,0x8(%rdi)
mov ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
lea r15, [rdi+10h]
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
mov byte ptr [rdi+10h], 0
mov [rdi], r15
mov rbp, [rsi]
mov qword ptr [rdi+8], 0
mov rax, [rsi+8]
m... | long long * func0(long long *a1, char **a2)
{
long long *v2; // r15
char *v3; // rbp
long long v4; // r14
long long v5; // rax
unsigned long long v6; // r12
char v7; // r13
unsigned long long v8; // rax
char *v10; // [rsp+0h] [rbp-48h]
v2 = a1 + 2;
*((_BYTE *)a1 + 16) = 0;
*a1 = (long long)(a1 + ... | func0:
ENDBR64
PUSH R15
LEA R15,[RDI + 0x10]
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV byte ptr [RDI + 0x10],0x0
MOV qword ptr [RDI],R15
MOV RBP,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],0x0
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],R15
ADD RAX,RBP
MOV qword ptr [RSP],RAX
C... | /* func0(std::string const&) */
string * func0(string *param_1)
{
string *psVar1;
ulong uVar2;
int iVar3;
char *pcVar4;
ulong uVar5;
char *pcVar6;
int8 *in_RSI;
ulong uVar7;
string *psVar8;
psVar1 = param_1 + 0x10;
param_1[0x10] = (string)0x0;
*(string **)param_1 = psVar1;
pcVar6 = (char ... |
2,495 | func0 |
#include <iostream>
#include <string>
#include <cassert>
#include <cctype>
| std::string func0(const std::string& string) {
std::string result = "";
for (char c : string) {
result += toupper(c);
}
return result;
}
| int main() {
assert(func0("person") == "PERSON");
assert(func0("final") == "FINAL");
assert(func0("Valid") == "VALID");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
lea 0x10(%rdi),%r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movb $0x0,0x10(%rdi)
mov %r15,(%rdi)
mov (%rsi),%rbx
movq $0x0,0x8(%rdi)
mov ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
lea r15, [rdi+10h]
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
mov byte ptr [rdi+10h], 0
mov [rdi], r15
mov rbp, [rsi]
mov qword ptr [rdi+8], 0
mov rax, [rsi+8]
m... | long long * func0(long long *a1, char **a2)
{
long long *v2; // r15
char *v3; // rbp
long long v4; // r14
long long v5; // rax
unsigned long long v6; // r12
char v7; // r13
unsigned long long v8; // rax
char *v10; // [rsp+0h] [rbp-48h]
v2 = a1 + 2;
*((_BYTE *)a1 + 16) = 0;
*a1 = (long long)(a1 + ... | func0:
ENDBR64
PUSH R15
LEA R15,[RDI + 0x10]
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV byte ptr [RDI + 0x10],0x0
MOV qword ptr [RDI],R15
MOV RBP,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],0x0
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],R15
ADD RAX,RBP
MOV qword ptr [RSP],RAX
C... | /* func0(std::string const&) */
string * func0(string *param_1)
{
string *psVar1;
ulong uVar2;
int iVar3;
char *pcVar4;
ulong uVar5;
char *pcVar6;
int8 *in_RSI;
ulong uVar7;
string *psVar8;
psVar1 = param_1 + 0x10;
param_1[0x10] = (string)0x0;
*(string **)param_1 = psVar1;
pcVar6 = (char ... |
2,496 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> newList) {
int size = newList.size();
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
assert((func0({1,2,3}) == std::vector<int>{3,2,1}));
assert((func0({1,2,3,4,4}) == std::vector<int>{4,2,3,4,1}));
assert((func0({4,5,6}) == std::vector<int>{6,5,4}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 1970 <_ZNKSt6vectorIiSaIiEE4sizeEv>
mov %eax,-0x18(%rbp)
mov -0x30(%rbp),%rax
mov $0x0,%esi
mov %r... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, [rbp+var_30]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov [rbp+var_18], eax
mov rax, [rbp+var_30]
mov esi, ... | long long func0(long long a1, long long a2)
{
int v2; // ebx
int v4; // [rsp+18h] [rbp-18h]
int v5; // [rsp+1Ch] [rbp-14h]
v4 = std::vector<int>::size(a2);
v5 = *(_DWORD *)std::vector<int>::operator[](a2, 0LL);
v2 = *(_DWORD *)std::vector<int>::operator[](a2, v4 - 1);
*(_DWORD *)std::vector<int>::operat... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001019de
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101a06
MOV EAX,dword ptr [RAX]
MOV dword ... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int4 uVar1;
int4 uVar2;
int iVar3;
int4 *puVar4;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
iVar3 = std::vector<int,std::allocator<int>>::size(in_RSI);
puVar4 = (in... |
2,497 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> newList) {
int size = newList.size();
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
assert((func0({1,2,3}) == std::vector<int>{3,2,1}));
assert((func0({1,2,3,4,4}) == std::vector<int>{4,2,3,4,1}));
assert((func0({4,5,6}) == std::vector<int>{6,5,4}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov %rdi,%rax
mov (%rsi),%rcx
mov (%rcx),%edi
mov 0x8(%rsi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
sub $0x1,%edx
movslq %edx,%rdx
lea (%rcx,%rdx,4),%rdx
mov (%rdx),%r8d
mov %r8d,(%rcx)
mov %edi,(%rdx)
mov %rcx,(%rax)
mov 0x8(%rsi),%... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, rdi
mov rcx, [rsi]
mov edi, [rcx]
mov rdx, [rsi+8]
sub rdx, rcx
sar rdx, 2
sub edx, 1
movsxd rdx, edx
mov r8d, [rcx+rdx*4]
mov [rcx], r8d
mov rcx, [rsi]
mov [rcx+rdx*4], edi
mov rdx, [rsi]
mov [rax], rdx
mov rdx, [rsi+8... | int ** func0(int **a1, int **a2)
{
int **result; // rax
int v3; // edi
int v4; // edx
result = a1;
v3 = **a2;
v4 = a2[1] - *a2 - 1;
**a2 = (*a2)[v4];
(*a2)[v4] = v3;
*result = *a2;
result[1] = a2[1];
result[2] = a2[2];
a2[2] = 0LL;
a2[1] = 0LL;
*a2 = 0LL;
return result;
} | func0:
ENDBR64
MOV RAX,RDI
MOV RCX,qword ptr [RSI]
MOV EDI,dword ptr [RCX]
MOV RDX,qword ptr [RSI + 0x8]
SUB RDX,RCX
SAR RDX,0x2
SUB EDX,0x1
MOVSXD RDX,EDX
MOV R8D,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RCX],R8D
MOV RCX,qword ptr [RSI]
MOV dword ptr [RCX + RDX*0x4],EDI
MOV RDX,qword ptr [RSI]
MOV qword ptr [RAX],RDX
... | /* func0(std::vector<int, std::allocator<int> >) */
void func0(vector param_1)
{
int4 uVar1;
int4 *puVar2;
long lVar3;
long *in_RSI;
int4 in_register_0000003c;
long *plVar4;
plVar4 = (long *)CONCAT44(in_register_0000003c,param_1);
puVar2 = (int4 *)*in_RSI;
uVar1 = *puVar2;
lVar3 = (long)((int)(... |
2,498 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> newList) {
int size = newList.size();
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
assert((func0({1,2,3}) == std::vector<int>{3,2,1}));
assert((func0({1,2,3,4,4}) == std::vector<int>{4,2,3,4,1}));
assert((func0({4,5,6}) == std::vector<int>{6,5,4}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov %rdi,%rax
mov 0x8(%rsi),%rdi
mov (%rsi),%rcx
mov %rdi,%rdx
mov (%rcx),%r8d
sub %rcx,%rdx
sar $0x2,%rdx
sub $0x1,%edx
movslq %edx,%rdx
lea (%rcx,%rdx,4),%rdx
mov (%rdx),%r9d
mov %r9d,(%rcx)
mov %r8d,(%rdx)
mov 0x10(%rsi),%r... | _Z5func0St6vectorIiSaIiEE:
endbr64
movdqu xmm0, xmmword ptr [rsi]
mov rax, rdi
movhlps xmm1, xmm0
movq rcx, xmm0
movq rdx, xmm1
mov edi, [rcx]
sub rdx, rcx
sar rdx, 2
sub edx, 1
movsxd rdx, edx
lea rdx, [rcx+rdx*4]
mov r8d, [rdx]
mov [rcx], r8d
mov [rdx], edi
mov rdx, [rs... | __m128 * func0(__m128 *a1, const __m128i *a2, double a3, __m128 a4)
{
__m128 v4; // xmm0
__m128 *result; // rax
int v6; // edi
_DWORD *v7; // rdx
long long v8; // rdx
v4 = (__m128)_mm_loadu_si128(a2);
result = a1;
v6 = *(_DWORD *)v4.m128_u64[0];
v7 = (_DWORD *)(v4.m128_u64[0] + 4LL * (int)(((long lon... | func0:
ENDBR64
MOVDQU XMM0,xmmword ptr [RSI]
MOV RAX,RDI
MOVHLPS XMM1,XMM0
MOVQ RCX,XMM0
MOVQ RDX,XMM1
MOV EDI,dword ptr [RCX]
SUB RDX,RCX
SAR RDX,0x2
SUB EDX,0x1
MOVSXD RDX,EDX
LEA RDX,[RCX + RDX*0x4]
MOV R8D,dword ptr [RDX]
MOV dword ptr [RCX],R8D
MOV dword ptr [RDX],EDI
MOV RDX,qword ptr [RSI + 0x10]
MOVUPS xmmword ... | /* func0(std::vector<int, std::allocator<int> >) */
void func0(int8 *param_1,int (*param_2) [16])
{
int4 uVar1;
int8 uVar2;
int4 *puVar3;
long lVar4;
puVar3 = *(int4 **)*param_2;
lVar4 = *(long *)(*param_2 + 8);
uVar1 = *puVar3;
*puVar3 = puVar3[(int)(lVar4 - (long)puVar3 >> 2) + -1];
puVar3[(int... |
2,499 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> newList) {
int size = newList.size();
int temp = newList[0];
newList[0] = newList[size - 1];
newList[size - 1] = temp;
return newList;
}
| int main() {
assert((func0({1,2,3}) == std::vector<int>{3,2,1}));
assert((func0({1,2,3,4,4}) == std::vector<int>{4,2,3,4,1}));
assert((func0({4,5,6}) == std::vector<int>{6,5,4}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rsi),%rcx
mov 0x8(%rsi),%rdx
mov %rdi,%rax
pxor %xmm0,%xmm0
movdqu (%rsi),%xmm1
sub %rcx,%rdx
mov (%rcx),%edi
sar $0x2,%rdx
sub $0x1,%edx
movslq %edx,%rdx
lea (%rcx,%rdx,4),%rdx
mov (%rdx),%r8d
mov %r8d,(%rcx)
mov %edi,(%rdx... | _Z5func0St6vectorIiSaIiEE:
endbr64
movdqu xmm0, xmmword ptr [rsi]
mov rax, rdi
movhlps xmm1, xmm0
movq rcx, xmm0
movq rdx, xmm1
mov edi, [rcx]
sub rdx, rcx
sar rdx, 2
sub edx, 1
movsxd rdx, edx
lea rdx, [rcx+rdx*4]
mov r8d, [rdx]
mov [rcx], r8d
mov [rdx], edi
mov rdx, [rs... | __m128 * func0(__m128 *a1, const __m128i *a2, double a3, __m128 a4)
{
__m128 v4; // xmm0
__m128 *result; // rax
int v6; // edi
_DWORD *v7; // rdx
long long v8; // rdx
v4 = (__m128)_mm_loadu_si128(a2);
result = a1;
v6 = *(_DWORD *)v4.m128_u64[0];
v7 = (_DWORD *)(v4.m128_u64[0] + 4LL * (int)(((long lon... | func0:
ENDBR64
MOVDQU XMM0,xmmword ptr [RSI]
MOV RAX,RDI
MOVHLPS XMM1,XMM0
MOVQ RCX,XMM0
MOVQ RDX,XMM1
MOV EDI,dword ptr [RCX]
SUB RDX,RCX
SAR RDX,0x2
SUB EDX,0x1
MOVSXD RDX,EDX
LEA RDX,[RCX + RDX*0x4]
MOV R8D,dword ptr [RDX]
MOV dword ptr [RCX],R8D
MOV dword ptr [RDX],EDI
MOV RDX,qword ptr [RSI + 0x10]
MOVUPS xmmword ... | /* func0(std::vector<int, std::allocator<int> >) */
void func0(int8 *param_1,int (*param_2) [16])
{
int4 uVar1;
int8 uVar2;
int4 *puVar3;
long lVar4;
puVar3 = *(int4 **)*param_2;
lVar4 = *(long *)(*param_2 + 8);
uVar1 = *puVar3;
*puVar3 = puVar3[(int)(lVar4 - (long)puVar3 >> 2) + -1];
puVar3[(int... |
2,500 | func0 |
#include <assert.h>
| int func0(int r) {
if (r < 0) {
return -1;
}
return r * r;
}
| int main() {
assert(func0(0) == 0);
assert(func0(-1) == -1);
assert(func0(2) == 4);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jns 1161 <_Z5func0i+0x18>
mov $0xffffffff,%eax
jmp 1167 <_Z5func0i+0x1e>
mov -0x4(%rbp),%eax
imul %eax,%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
cmp [rbp+var_4], 0
jns short loc_1161
mov eax, 0FFFFFFFFh
jmp short loc_1167
loc_1161:
mov eax, [rbp+var_4]
imul eax, eax
loc_1167:
pop rbp
retn | long long func0(int a1)
{
if ( a1 >= 0 )
return (unsigned int)(a1 * a1);
else
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x0
JNS 0x00101161
MOV EAX,0xffffffff
JMP 0x00101167
LAB_00101161:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
LAB_00101167:
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
if (param_1 < 0) {
iVar1 = -1;
}
else {
iVar1 = param_1 * param_1;
}
return iVar1;
} |
2,501 | func0 |
#include <assert.h>
| int func0(int r) {
if (r < 0) {
return -1;
}
return r * r;
}
| int main() {
assert(func0(0) == 0);
assert(func0(-1) == -1);
assert(func0(2) == 4);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov %edi,%eax
test %edi,%edi
js 1137 <_Z5func0i+0xe>
imul %edi,%eax
retq
mov $0xffffffff,%eax
retq
| _Z5func0i:
endbr64
mov eax, edi
test edi, edi
js short loc_1137
imul eax, edi
retn
loc_1137:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1)
{
if ( a1 < 0 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
TEST EDI,EDI
JS 0x00101137
IMUL EAX,EDI
RET
LAB_00101137:
MOV EAX,0xffffffff
RET | /* func0(int) */
int func0(int param_1)
{
if (-1 < param_1) {
return param_1 * param_1;
}
return -1;
} |
2,502 | func0 |
#include <assert.h>
| int func0(int r) {
if (r < 0) {
return -1;
}
return r * r;
}
| int main() {
assert(func0(0) == 0);
assert(func0(-1) == -1);
assert(func0(2) == 4);
return 0;
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%eax
test %edi,%edi
js 114e <_Z5func0i+0xe>
imul %edi,%eax
retq
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0i:
endbr64
mov eax, edi
test edi, edi
js short loc_114E
imul eax, edi
retn
loc_114E:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1)
{
if ( a1 < 0 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
TEST EDI,EDI
JS 0x0010114e
IMUL EAX,EDI
RET
LAB_0010114e:
MOV EAX,0xffffffff
RET | /* func0(int) */
int func0(int param_1)
{
if (-1 < param_1) {
return param_1 * param_1;
}
return -1;
} |
2,503 | func0 |
#include <assert.h>
| int func0(int r) {
if (r < 0) {
return -1;
}
return r * r;
}
| int main() {
assert(func0(0) == 0);
assert(func0(-1) == -1);
assert(func0(2) == 4);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%eax
test %edi,%edi
js 114e <_Z5func0i+0xe>
imul %edi,%eax
retq
mov $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0i:
endbr64
mov eax, edi
test edi, edi
js short loc_114E
imul eax, edi
retn
loc_114E:
mov eax, 0FFFFFFFFh
retn | long long func0(int a1)
{
if ( a1 < 0 )
return 0xFFFFFFFFLL;
else
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
TEST EDI,EDI
JS 0x0010114e
IMUL EAX,EDI
RET
LAB_0010114e:
MOV EAX,0xffffffff
RET | /* func0(int) */
int func0(int param_1)
{
if (-1 < param_1) {
return param_1 * param_1;
}
return -1;
} |
2,504 | func0 |
#include <iostream>
#include <cassert>
| int func0(int array[], int start, int end) {
if (start > end) {
return end + 1;
}
if (start != array[start]) {
return start;
}
int mid = (start + end) / 2;
if (array[mid] == mid) {
return func0(array, mid + 1, end);
}
return func0(array, start, mid);
}... | int main() {
int arr1[] = {0, 1, 2, 3};
int arr2[] = {0, 1, 2, 6, 9};
int arr3[] = {2, 3, 5, 8, 9};
assert(func0(arr1, 0, 3) == 4);
assert(func0(arr2, 0, 4) == 3);
assert(func0(arr3, 0, 4) == 0);
return 0;
}
| O0 | cpp | func0(int*, int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x20(%rbp),%eax
jle 11cf <_Z5func0Piii+0x26>
mov -0x20(%rbp),%eax
add $0x1,%eax
jmp 124c <_Z5func0Piii+0xa3>
mov -0x1c(%rbp... | _Z5func0Piii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_20]
jle short loc_118F
mov eax, [rbp+var_20]
add eax, 1
jmp short locret_120C
loc_118F:
mov eax, [rbp+var_... | long long func0(int *a1, int a2, int a3)
{
int v4; // [rsp+1Ch] [rbp-4h]
if ( a2 > a3 )
return (unsigned int)(a3 + 1);
if ( a2 != a1[a2] )
return (unsigned int)a2;
v4 = (a2 + a3) / 2;
if ( v4 == a1[v4] )
return func0(a1, v4 + 1, a3);
else
return func0(a1, a2, v4);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x20]
JLE 0x0010118f
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
JMP 0x0010120c
LAB_0010118f:
MOV EAX,dword ptr [RBP ... | /* func0(int*, int, int) */
ulong func0(int *param_1,int param_2,int param_3)
{
int iVar1;
ulong uVar2;
if (param_3 < param_2) {
uVar2 = (ulong)(param_3 + 1);
}
else if (param_2 == param_1[param_2]) {
iVar1 = (param_3 + param_2) / 2;
if (iVar1 == param_1[iVar1]) {
uVar2 = func0(param_1,... |
2,505 | func0 |
#include <iostream>
#include <cassert>
| int func0(int array[], int start, int end) {
if (start > end) {
return end + 1;
}
if (start != array[start]) {
return start;
}
int mid = (start + end) / 2;
if (array[mid] == mid) {
return func0(array, mid + 1, end);
}
return func0(array, start, mid);
}... | int main() {
int arr1[] = {0, 1, 2, 3};
int arr2[] = {0, 1, 2, 6, 9};
int arr3[] = {2, 3, 5, 8, 9};
assert(func0(arr1, 0, 3) == 4);
assert(func0(arr2, 0, 4) == 3);
assert(func0(arr3, 0, 4) == 0);
return 0;
}
| O1 | cpp | func0(int*, int, int):
endbr64
cmp %edx,%esi
jg 11df <_Z5func0Piii+0x36>
movslq %esi,%rcx
mov %esi,%eax
cmp %esi,(%rdi,%rcx,4)
jne 11ed <_Z5func0Piii+0x44>
sub $0x8,%rsp
lea (%rsi,%rdx,1),%ecx
mov %ecx,%eax
shr $0x1f,%eax
add %ecx,%eax
sar %eax
movslq %eax,%rcx
cmp %eax,(%rdi,%rcx,4... | _Z5func0Piii:
endbr64
cmp esi, edx
jg short loc_119F
movsxd rcx, esi
mov eax, esi
cmp [rdi+rcx*4], esi
jnz short locret_11AD
sub rsp, 8
lea ecx, [rsi+rdx]
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
movsxd rcx, eax
cmp [rdi+rcx*4], eax
jz short loc_11A3
mov ... | long long func0(int *a1, int a2, int a3)
{
long long result; // rax
int v4; // eax
if ( a2 > a3 )
return (unsigned int)(a3 + 1);
result = (unsigned int)a2;
if ( a1[a2] == a2 )
{
v4 = (a2 + a3) / 2;
if ( a1[v4] == v4 )
return func0(a1, v4 + 1, a3);
else
return func0(a1, a2, v4);... | func0:
ENDBR64
CMP ESI,EDX
JG 0x0010119f
MOVSXD RCX,ESI
MOV EAX,ESI
CMP dword ptr [RDI + RCX*0x4],ESI
JNZ 0x001011ad
SUB RSP,0x8
LEA ECX,[RSI + RDX*0x1]
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOVSXD RCX,EAX
CMP dword ptr [RDI + RCX*0x4],EAX
JZ 0x001011a3
MOV EDX,EAX
CALL 0x00101169
LAB_0010119a:
ADD RSP,0x8
R... | /* func0(int*, int, int) */
ulong func0(int *param_1,int param_2,int param_3)
{
int iVar1;
ulong uVar2;
if (param_3 < param_2) {
return (ulong)(param_3 + 1);
}
if (param_1[param_2] == param_2) {
iVar1 = (param_2 + param_3) / 2;
if (param_1[iVar1] == iVar1) {
uVar2 = func0(param_1,iVar1 ... |
2,506 | func0 |
#include <iostream>
#include <cassert>
| int func0(int array[], int start, int end) {
if (start > end) {
return end + 1;
}
if (start != array[start]) {
return start;
}
int mid = (start + end) / 2;
if (array[mid] == mid) {
return func0(array, mid + 1, end);
}
return func0(array, start, mid);
}... | int main() {
int arr1[] = {0, 1, 2, 3};
int arr2[] = {0, 1, 2, 6, 9};
int arr3[] = {2, 3, 5, 8, 9};
assert(func0(arr1, 0, 3) == 4);
assert(func0(arr2, 0, 4) == 3);
assert(func0(arr3, 0, 4) == 0);
return 0;
}
| O2 | cpp | func0(int*, int, int):
endbr64
movslq %esi,%rax
lea (%rdi,%rax,4),%r8
jmp 134b <_Z5func0Piii+0x2b>
nopl (%rax)
cmp %esi,(%r8)
jne 1358 <_Z5func0Piii+0x38>
lea (%rdx,%rsi,1),%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
movslq %ecx,%rax
cmp %ecx,(%rdi,%rax,4)
je 1360 <_Z5fu... | _Z5func0Piii:
endbr64
loc_1284:
movsxd rax, esi
lea r8, [rdi+rax*4]
jmp short loc_12AB
loc_1290:
cmp [r8], esi
jnz short loc_12B8
lea eax, [rdx+rsi]
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
movsxd rax, ecx
cmp [rdi+rax*4], ecx
jz short loc_12C0
mov edx, ecx
lo... | long long func0(int *a1, int a2, int a3)
{
int v3; // ecx
while ( 1 )
{
if ( a3 < a2 )
return (unsigned int)(a3 + 1);
if ( a1[a2] != a2 )
break;
v3 = (a3 + a2) / 2;
if ( a1[v3] == v3 )
a2 = v3 + 1;
else
a3 = (a3 + a2) / 2;
}
return (unsigned int)a2;
} | func0:
ENDBR64
LAB_00101284:
MOVSXD RAX,ESI
LEA R8,[RDI + RAX*0x4]
JMP 0x001012ab
LAB_00101290:
CMP dword ptr [R8],ESI
JNZ 0x001012b8
LEA EAX,[RDX + RSI*0x1]
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
MOVSXD RAX,ECX
CMP dword ptr [RDI + RAX*0x4],ECX
JZ 0x001012c0
MOV EDX,ECX
LAB_001012ab:
CMP EDX,ESI
JGE 0x001012... | /* func0(int*, int, int) */
int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
do {
iVar1 = param_3;
do {
param_3 = iVar1;
if (param_3 < param_2) {
return param_3 + 1;
}
if (param_1[param_2] != param_2) {
return param_2;
}
iVar1 = (param_3 +... |
2,507 | func0 |
#include <iostream>
#include <cassert>
| int func0(int array[], int start, int end) {
if (start > end) {
return end + 1;
}
if (start != array[start]) {
return start;
}
int mid = (start + end) / 2;
if (array[mid] == mid) {
return func0(array, mid + 1, end);
}
return func0(array, start, mid);
}... | int main() {
int arr1[] = {0, 1, 2, 3};
int arr2[] = {0, 1, 2, 6, 9};
int arr3[] = {2, 3, 5, 8, 9};
assert(func0(arr1, 0, 3) == 4);
assert(func0(arr2, 0, 4) == 3);
assert(func0(arr3, 0, 4) == 0);
return 0;
}
| O3 | cpp | func0(int*, int, int):
endbr64
movslq %esi,%rax
lea (%rdi,%rax,4),%r8
jmp 133b <_Z5func0Piii+0x2b>
nopl (%rax)
cmp %esi,(%r8)
jne 1348 <_Z5func0Piii+0x38>
lea (%rdx,%rsi,1),%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
movslq %ecx,%rax
cmp %ecx,(%rdi,%rax,4)
je 1350 <_Z5fu... | _Z5func0Piii:
endbr64
loc_1294:
movsxd rax, esi
lea r8, [rdi+rax*4]
jmp short loc_12BB
loc_12A0:
cmp [r8], esi
jnz short loc_12C8
lea eax, [rdx+rsi]
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
movsxd rax, ecx
cmp [rdi+rax*4], ecx
jz short loc_12D0
mov edx, ecx
lo... | long long func0(int *a1, int a2, int a3)
{
int v3; // ecx
while ( 1 )
{
if ( a3 < a2 )
return (unsigned int)(a3 + 1);
if ( a1[a2] != a2 )
break;
v3 = (a3 + a2) / 2;
if ( a1[v3] == v3 )
a2 = v3 + 1;
else
a3 = (a3 + a2) / 2;
}
return (unsigned int)a2;
} | func0:
ENDBR64
LAB_00101294:
MOVSXD RAX,ESI
LEA R8,[RDI + RAX*0x4]
JMP 0x001012bb
LAB_001012a0:
CMP dword ptr [R8],ESI
JNZ 0x001012c8
LEA EAX,[RDX + RSI*0x1]
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
MOVSXD RAX,ECX
CMP dword ptr [RDI + RAX*0x4],ECX
JZ 0x001012d0
MOV EDX,ECX
LAB_001012bb:
CMP EDX,ESI
JGE 0x001012... | /* func0(int*, int, int) */
int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
do {
iVar1 = param_3;
do {
param_3 = iVar1;
if (param_3 < param_2) {
return param_3 + 1;
}
if (param_1[param_2] != param_2) {
return param_2;
}
iVar1 = (param_3 +... |
2,508 | func0 |
#include <string>
#include <assert.h>
| std::string func0(std::string string) {
int i = string.length();
int space_count = 0;
int MAX = 1000;
for(char c : string) {
if(c == ' ') space_count++;
}
int new_length = i + space_count * 2;
if(new_length > MAX) {
return "-1";
}
string.erase(0, string.f... | int main() {
assert(func0("My Name is Dawood") == "My%20Name%20is%20Dawood");
assert(func0("I am a Programmer") == "I%20am%20a%20Programmer");
assert(func0("I love Coding") == "I%20love%20Coding");
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
mov -0x60(%rbp),%rax
mov %rax,%rdi
callq 2380 <_... | _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
mov rax, [rbp+var_70]
mov rdi, rax
call __ZNKSt7__cxx1112basic_str... | long long func0(long long a1, long long a2)
{
long long first_not_of; // rax
long long last_not_of; // rax
char v4; // bl
int v6; // [rsp+20h] [rbp-50h]
int v7; // [rsp+24h] [rbp-4Ch]
int i; // [rsp+28h] [rbp-48h]
int v9; // [rsp+2Ch] [rbp-44h]
int v10; // [rsp+34h] [rbp-3Ch]
long long v11; // [rsp+3... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x70]
MOV RDI,RAX
CALL 0x00102340
MOV dword ptr [RBP + -0x44],EAX
MOV dword ptr [RBP + -0x50],0x0
MO... | /* func0(std::string) */
string * func0(string *param_1,string *param_2)
{
int uVar1;
bool bVar2;
long lVar3;
char *pcVar4;
int *puVar5;
long in_FS_OFFSET;
int local_58;
int local_50;
int8 local_40;
int8 local_38;
string *local_30;
int8 *local_28;
long local_20;
local_20 = *(long *)(in_... |
2,509 | func0 |
#include <string>
#include <assert.h>
| std::string func0(std::string string) {
int i = string.length();
int space_count = 0;
int MAX = 1000;
for(char c : string) {
if(c == ' ') space_count++;
}
int new_length = i + space_count * 2;
if(new_length > MAX) {
return "-1";
}
string.erase(0, string.f... | int main() {
assert(func0("My Name is Dawood") == "My%20Name%20is%20Dawood");
assert(func0("I am a Programmer") == "I%20am%20a%20Programmer");
assert(func0("I love Coding") == "I%20love%20Coding");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %rsi,%rbx
mov 0x8(%rsi),%r12
mov (%rsi),%rax
lea (%rax,%r12,1),%rsi
cmp %rax,%rsi
je 1338 <_Z5func0NSt7__cxx1112basic_string... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbp, rdi
mov rbx, rsi
mov r12, [rsi+8]
mov rax, [rsi]
lea rsi, [rax+r12]
cmp rax, rsi
jz short loc_1358
mov edx, 0
loc_1310:
cmp byte ptr [rax], 20h ... | char ** func0(char **a1, char **a2)
{
char *v4; // r12
char *v5; // rax
char *v6; // rsi
int v7; // edx
int v8; // r14d
unsigned long long first_not_of; // rax
long long last_not_of; // rax
long long v12; // rdx
unsigned long long v13; // rcx
int v14; // r13d
long long v15; // rax
unsigned long ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV RBX,RSI
MOV R12,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RSI]
LEA RSI,[RAX + R12*0x1]
CMP RAX,RSI
JZ 0x00101358
MOV EDX,0x0
LAB_00101310:
CMP byte ptr [RAX],0x20
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101310
LAB_001013... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
int iVar1;
char *pcVar2;
long lVar3;
uint uVar4;
long *plVar5;
int iVar6;
uint uVar7;
long *plVar8;
ulong uVar9;
char *pcVar10;
int unaff_R13D;
int auVar11 [16];
pcVar2 = (char *)*param_2;
pcVar10 = pcVar2 + param_2[1]... |
2,510 | func0 |
#include <string>
#include <assert.h>
| std::string func0(std::string string) {
int i = string.length();
int space_count = 0;
int MAX = 1000;
for(char c : string) {
if(c == ' ') space_count++;
}
int new_length = i + space_count * 2;
if(new_length > MAX) {
return "-1";
}
string.erase(0, string.f... | int main() {
assert(func0("My Name is Dawood") == "My%20Name%20is%20Dawood");
assert(func0("I am a Programmer") == "I%20am%20a%20Programmer");
assert(func0("I love Coding") == "I%20love%20Coding");
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 0x8(%rsi),%r13
mov %rsi,%rbx
mov (%rsi),%rax
lea (%rax,%r13,1),%rsi
cmp %rax,%rsi
je 16b8 <_Z5func0NSt7__cxx1112basic_string... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
mov r13, [rsi+8]
mov rbx, rsi
mov rax, [rsi]
lea rsi, [rax+r13]
cmp rax, rsi
jz short loc_1540
xor edx, edx
nop dword ptr [rax+00h]
loc_14E8... | long long func0(long long a1, char **a2)
{
char *v3; // r13
char *v5; // rax
char *v6; // rsi
int v7; // edx
int v8; // ecx
int v9; // r14d
long long result; // rax
unsigned long long first_not_of; // rax
long long last_not_of; // rax
unsigned long long v13; // rcx
long long v14; // rdx
int v15... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV R13,qword ptr [RSI + 0x8]
MOV RBX,RSI
MOV RAX,qword ptr [RSI]
LEA RSI,[RAX + R13*0x1]
CMP RAX,RSI
JZ 0x00101540
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_001014e8:
XOR ECX,ECX
CMP byte ptr [RAX],0x20
SETZ CL
ADD RAX,0x1
ADD EDX,ECX
CMP RSI,RAX
JNZ 0x... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
char cVar1;
uint uVar2;
int iVar3;
char *pcVar4;
long lVar5;
char *pcVar6;
size_t sVar7;
ulong *__dest;
size_t sVar8;
long *plVar9;
int4 extraout_var;
uint uVar10;
long *plVar11;
int iVar12;
long lVar13;
ulong uVar14;... |
2,511 | func0 |
#include <string>
#include <assert.h>
| std::string func0(std::string string) {
int i = string.length();
int space_count = 0;
int MAX = 1000;
for(char c : string) {
if(c == ' ') space_count++;
}
int new_length = i + space_count * 2;
if(new_length > MAX) {
return "-1";
}
string.erase(0, string.f... | int main() {
assert(func0("My Name is Dawood") == "My%20Name%20is%20Dawood");
assert(func0("I am a Programmer") == "I%20am%20a%20Programmer");
assert(func0("I love Coding") == "I%20love%20Coding");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
mov 0x8(%rsi),%r12
mov %rsi,%rbx
mov (%rsi),%rdx
lea (%rdx,%r12,1),%rcx
cmp %rdx,%rcx
je 18c8 <_Z5func0NSt7__cxx1112basic_string... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
mov rbx, [rsi+8]
mov r8, [rsi]
lea rcx, [r8+rbx]
cmp r8, rcx
jz loc_1708
lea rax, [rbx-1]
cmp rax, 0Eh
mov rax, r8
jbe ... | long long func0(long long a1, char **a2, __m128i a3, __m128i a4, __m128i a5, __m128i a6, __m128i a7, __m128i a8)
{
char *v10; // rbx
const __m128i *v11; // r8
const __m128i *v12; // rcx
const __m128i *v13; // rax
__m128i v14; // xmm1
unsigned long long v15; // rdi
__m128i si128; // xmm6
__m128i v17; //... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,qword ptr [RSI + 0x8]
MOV R8,qword ptr [RSI]
LEA RCX,[R8 + RBX*0x1]
CMP R8,RCX
JZ 0x00101708
LEA RAX,[RBX + -0x1]
CMP RAX,0xe
MOV RAX,R8
JBE 0x00101920
PXOR XMM1,XMM1
PXOR XMM5,XMM5
PXOR XMM4,XMM4
MOV RDI,RBX
AND RDI,-0x10
MOVDQ... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
bool bVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
char *pcVar9;
char *pcVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
... |
2,512 | func0 | #include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& list) {
std::vector<int> ev_li;
for (int i : list) {
if (i % 2 == 0) {
ev_li.push_back(i);
}
}
return ev_li;
}
| int main() {
assert((func0({1,2,3,4,5}) == std::vector<int>{2,4}));
assert((func0({4,5,6,7,8,0,1}) == std::vector<int>{4,6,8,0}));
assert((func0({8,12,15,19}) == std::vector<int>{8,12}));
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 19c2 <_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 0x00101a46
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 = *(... |
2,513 | func0 | #include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& list) {
std::vector<int> ev_li;
for (int i : list) {
if (i % 2 == 0) {
ev_li.push_back(i);
}
}
return ev_li;
}
| int main() {
assert((func0({1,2,3,4,5}) == std::vector<int>{2,4}));
assert((func0({4,5,6,7,8,0,1}) == std::vector<int>{4,6,8,0}));
assert((func0({8,12,15,19}) == std::vector<int>{8,12}));
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;
*(... |
2,514 | func0 | #include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& list) {
std::vector<int> ev_li;
for (int i : list) {
if (i % 2 == 0) {
ev_li.push_back(i);
}
}
return ev_li;
}
| int main() {
assert((func0({1,2,3,4,5}) == std::vector<int>{2,4}));
assert((func0({4,5,6,7,8,0,1}) == std::vector<int>{4,6,8,0}));
assert((func0({8,12,15,19}) == std::vector<int>{8,12}));
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 0x00101639
JMP 0x00101660
LAB_0010163... | /* 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 ... |
2,515 | func0 | #include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& list) {
std::vector<int> ev_li;
for (int i : list) {
if (i % 2 == 0) {
ev_li.push_back(i);
}
}
return ev_li;
}
| int main() {
assert((func0({1,2,3,4,5}) == std::vector<int>{2,4}));
assert((func0({4,5,6,7,8,0,1}) == std::vector<int>{4,6,8,0}));
assert((func0({8,12,15,19}) == std::vector<int>{8,12}));
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 0x00101639
JMP 0x00101660
LAB_0010163... | /* 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 ... |
2,516 | func0 |
#include <vector>
#include <assert.h>
void adjac(const std::vector<int>& ele, std::vector<std::vector<int>>& res, std::vector<int> sub = {}) {
if (ele.empty()) {
res.push_back(sub);
} else {
for (int j = ele[0] - 1; j <= ele[0] + 1; ++j) {
std::vector<int> new_sub = sub;
... | std::vector<std::vector<int>> func0(const std::vector<int>& test_tup) {
std::vector<std::vector<int>> res;
adjac(test_tup, res);
return res;
}
| int main() {
std::vector<std::vector<int>> result;
result = func0({3, 4});
assert((result == std::vector<std::vector<int>>{{2, 3}, {2, 4}, {2, 5}, {3, 3}, {3, 4}, {3, 5}, {4, 3}, {4, 4}, {4, 5}}));
result = func0({4, 5});
assert((result == std::vector<std::vector<int>>{{3, 4}, {3, 5}, {... | O0 | cpp | func0(std::vector<int, std::allocator<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
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 2d54 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEC1Ev... | _Z5func0RKSt6vectorIiSaIiEE:
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 rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEC2Ev; std::vector<std::vecto... | long long func0(long long a1, long long a2)
{
__int128 v3; // [rsp+10h] [rbp-30h] BYREF
long long v4; // [rsp+20h] [rbp-20h]
unsigned long long v5; // [rsp+28h] [rbp-18h]
v5 = __readfsqword(0x28u);
std::vector<std::vector<int>>::vector(a1);
v3 = 0LL;
v4 = 0LL;
std::vector<int>::vector(&v3);
adjac(a2... | 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
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001029ae
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x30],XMM0
MOVQ qword pt... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
vector *in_RSI;
long in_FS_OFFSET;
vector<int,std::allocator<int>> local_38 [16];
int8 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::
vector<std::vector<int,std::allocator<int>>,s... |
2,517 | func0 |
#include <vector>
#include <assert.h>
void adjac(const std::vector<int>& ele, std::vector<std::vector<int>>& res, std::vector<int> sub = {}) {
if (ele.empty()) {
res.push_back(sub);
} else {
for (int j = ele[0] - 1; j <= ele[0] + 1; ++j) {
std::vector<int> new_sub = sub;
... | std::vector<std::vector<int>> func0(const std::vector<int>& test_tup) {
std::vector<std::vector<int>> res;
adjac(test_tup, res);
return res;
}
| int main() {
std::vector<std::vector<int>> result;
result = func0({3, 4});
assert((result == std::vector<std::vector<int>>{{2, 3}, {2, 4}, {2, 5}, {3, 3}, {3, 4}, {3, 5}, {4, 3}, {4, 4}, {4, 5}}));
result = func0({4, 5});
assert((result == std::vector<std::vector<int>>{{3, 4}, {3, 5}, {... | O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rbx
mov %rsi,%rdi
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rbx)
movq $0x0,0x8(%rbx)
movq $0x0,0x10(%rbx)
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
push rbx
sub rsp, 28h
mov rbx, rdi
mov rdi, rsi
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
mov qword ptr [rbx], 0
mov qword ptr [rbx+8], 0
mov qword ptr [rbx+10h], 0
mov [rsp+38h+var_38], 0
mov [rsp+38h+var_30], ... | _QWORD * func0(_QWORD *a1, long long a2)
{
_QWORD v3[7]; // [rsp+0h] [rbp-38h] BYREF
v3[3] = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
memset(v3, 0, 24);
((void ( *)(long long, _QWORD *, _QWORD *))adjac)(a2, a1, v3);
return a1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV RDI,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RBX],0x0
MOV qword ptr [RBX + 0x8],0x0
MOV qword ptr [RBX + 0x10],0x0
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV RDX,R... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
vector *in_RSI;
long in_FS_OFFSET;
int8 local_38;
int8 local_30;
int8 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(para... |
2,518 | func0 |
#include <vector>
#include <assert.h>
void adjac(const std::vector<int>& ele, std::vector<std::vector<int>>& res, std::vector<int> sub = {}) {
if (ele.empty()) {
res.push_back(sub);
} else {
for (int j = ele[0] - 1; j <= ele[0] + 1; ++j) {
std::vector<int> new_sub = sub;
... | std::vector<std::vector<int>> func0(const std::vector<int>& test_tup) {
std::vector<std::vector<int>> res;
adjac(test_tup, res);
return res;
}
| int main() {
std::vector<std::vector<int>> result;
result = func0({3, 4});
assert((result == std::vector<std::vector<int>>{{2, 3}, {2, 4}, {2, 5}, {3, 3}, {3, 4}, {3, 5}, {4, 3}, {4, 4}, {4, 5}}));
result = func0({4, 5});
assert((result == std::vector<std::vector<int>>{{3, 4}, {3, 5}, {... | O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r12
mov %rdi,%r12
mov %rsi,%rdi
push %rbp
mov %r12,%rsi
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%r12)
mov %rsp,%rdx
movq $0x0,0x8(%r12)
movq $0x0,0x10(%r12)
movq $0x0,(%rsp)
movq... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r12
pxor xmm0, xmm0
push rbp
push rbx
mov rbx, rdi
mov rdi, rsi
mov rsi, rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+8+var_s10], rax
xor eax, eax
mov qword ptr [rbx+10h], 0
mov rbp, rsp
movups xmmword ptr [rbx], xmm0
mov rdx, r... | func0:
ENDBR64
PUSH R12
PXOR XMM0,XMM0
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RDI,RSI
MOV RSI,RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x10],0x0
MOV RBP,RSP
MOVUPS xmmword ptr [RBX],XMM0
MOV RDX,RBP
MOV qword ptr [RSP + 0x10],0x0
MOVAPS xmmword ptr [RSP],XM... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
long lVar1;
long in_FS_OFFSET;
lVar1 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
/* try { // try from 00102557 to 0010255b has its... | |
2,519 | func0 |
#include <vector>
#include <assert.h>
void adjac(const std::vector<int>& ele, std::vector<std::vector<int>>& res, std::vector<int> sub = {}) {
if (ele.empty()) {
res.push_back(sub);
} else {
for (int j = ele[0] - 1; j <= ele[0] + 1; ++j) {
std::vector<int> new_sub = sub;
... | std::vector<std::vector<int>> func0(const std::vector<int>& test_tup) {
std::vector<std::vector<int>> res;
adjac(test_tup, res);
return res;
}
| int main() {
std::vector<std::vector<int>> result;
result = func0({3, 4});
assert((result == std::vector<std::vector<int>>{{2, 3}, {2, 4}, {2, 5}, {3, 3}, {3, 4}, {3, 5}, {4, 3}, {4, 4}, {4, 5}}));
result = func0({4, 5});
assert((result == std::vector<std::vector<int>>{{3, 4}, {3, 5}, {... | O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r12
mov %rdi,%r12
pxor %xmm0,%xmm0
mov %rsi,%rdi
push %rbp
mov %r12,%rsi
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %rsp,%rdx
movups %xmm0,(%r12)
movq $0x0,0x10(%r12)
movq $0x0,0x10(%rsp)
mo... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r12
pxor xmm0, xmm0
push rbp
push rbx
mov rbx, rdi
mov rdi, rsi
mov rsi, rbx
sub rsp, 20h
mov rax, fs:28h
mov [rsp+8+var_s10], rax
xor eax, eax
mov qword ptr [rbx+10h], 0
mov rbp, rsp
movups xmmword ptr [rbx], xmm0
mov rdx, r... | func0:
ENDBR64
PUSH R12
PXOR XMM0,XMM0
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RDI,RSI
MOV RSI,RBX
SUB RSP,0x20
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x10],0x0
MOV RBP,RSP
MOVUPS xmmword ptr [RBX],XMM0
MOV RDX,RBP
MOV qword ptr [RSP + 0x10],0x0
MOVAPS xmmword ptr [RSP],XM... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
long lVar1;
long in_FS_OFFSET;
lVar1 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
/* try { // try from 00102537 to 0010253b has its... | |
2,520 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string text) {
for (size_t pos = 0; (pos = text.find(" ", pos)) != std::string::npos; pos++) {
text.replace(pos, 1, "_");
}
return text;
}
| int main() {
assert(func0("Jumanji The Jungle") == "Jumanji_The_Jungle");
assert(func0("The Avengers") == "The_Avengers");
assert(func0("Fast and Furious") == "Fast_and_Furious");
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movq $0x0,-0x8(%rbp)
mov -0x8(%rbp),%rdx
mov -0x20(%rbp),%rax
lea 0xb74(%rip),%rsi
mov %rax,%rdi
callq 2370 <_ZNKS... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_8], 0
jmp short loc_240B
loc_23E7:
mov rsi, [rbp+var_8]
mov rax, [rbp+var_20]
lea rdx, unk_3008
mov rcx, rdx
mov ... | long long func0(long long a1, long long a2)
{
long long i; // rax
long long v4; // [rsp+18h] [rbp-8h]
for ( i = std::string::find(a2, &unk_300A, 0LL); ; i = std::string::find(a2, &unk_300A, v4 + 1) )
{
v4 = i;
if ( i == -1 )
break;
std::string::replace(a2, i, 1LL, &unk_3008);
}
std::stri... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0010240b
LAB_001023e7:
MOV RSI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x103008]
MOV RCX,RDX
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001021c0
ADD qword ptr... | /* func0(std::string) */
string * func0(string *param_1,string *param_2)
{
ulong uVar1;
while( true ) {
uVar1 = std::string::find((char *)param_2,0x10300a);
if (uVar1 == 0xffffffffffffffff) break;
std::string::replace((ulong)param_2,uVar1,(char *)0x1);
}
std::string::string(param_1,param_2);
... |
2,521 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string text) {
for (size_t pos = 0; (pos = text.find(" ", pos)) != std::string::npos; pos++) {
text.replace(pos, 1, "_");
}
return text;
}
| int main() {
assert(func0("Jumanji The Jungle") == "Jumanji_The_Jungle");
assert(func0("The Avengers") == "The_Avengers");
assert(func0("Fast and Furious") == "Fast_and_Furious");
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 $0x8,%rsp
mov %rdi,%r13
mov %rsi,%rbp
mov $0x0,%edx
lea 0xd1b(%rip),%r12
mov $0x1,%ecx
mov %r12,%rsi
mov %rbp,%rdi
callq 11b0 <_ZNKSt7__cxx1112basi... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov rbp, rsi
mov edx, 0
lea r12, asc_201C; " "
lea r13, asc_201A; "_"
loc_12CE:
mov ecx, 1
mov rsi, r12
mov rdi, rbp
call __ZNKSt7__cxx1112bas... | char ** func0(char **a1, char **a2)
{
unsigned long long i; // rdx
unsigned long long v4; // rax
unsigned long long v5; // rbx
unsigned long long v6; // rcx
_QWORD *v7; // rcx
char *v8; // rax
unsigned int v10; // edx
unsigned long long v11; // rdi
char *v12; // rcx
char *v13; // r9
unsigned int v... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV RBP,RSI
MOV EDX,0x0
LEA R12,[0x10201c]
LEA R13,[0x10201a]
LAB_001012ce:
MOV ECX,0x1
MOV RSI,R12
MOV RDI,RBP
CALL 0x00101190
MOV RBX,RAX
CMP RAX,-0x1
JZ 0x00101338
MOV RCX,qword ptr [RBP + 0x8]
MOV RDX,RCX
SUB RDX,RBX
CMP RDX,0x0
MOV EAX,0x1
CMO... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
long *plVar1;
uint uVar2;
long lVar3;
uint uVar4;
ulong uVar5;
char *pcVar6;
uVar5 = 0;
do {
uVar5 = std::string::find((char *)param_2,0x10201c,uVar5);
if (uVar5 == 0xffffffffffffffff) {
LAB_00101338:
*param_1 = (lon... |
2,522 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string text) {
for (size_t pos = 0; (pos = text.find(" ", pos)) != std::string::npos; pos++) {
text.replace(pos, 1, "_");
}
return text;
}
| int main() {
assert(func0("Jumanji The Jungle") == "Jumanji_The_Jungle");
assert(func0("The Avengers") == "The_Avengers");
assert(func0("Fast and Furious") == "Fast_and_Furious");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
xor %edx,%edx
mov %rdi,%r13
push %r12
push %rbp
lea 0xabf(%rip),%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
jmp 1589 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x59>
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
xor edx, edx
mov r14, rdi
push r13
lea r13, asc_201A; "_"
push r12
lea r12, asc_201C; " "
push rbp
mov rbp, rsi
push rbx
jmp short loc_14E0
loc_14A8:
mov rcx, [rbp+8]
mov eax, 1
mov rdx, rcx... | char ** func0(char **a1, char **a2)
{
unsigned long long i; // rdx
unsigned long long v5; // rcx
unsigned long long v6; // rbx
_QWORD *v7; // rsi
char *v8; // rax
char *v9; // rcx
char *v10; // rdx
char **result; // rax
unsigned int v12; // ecx
unsigned long long v13; // rdi
char *v14; // rsi
ch... | func0:
ENDBR64
PUSH R14
XOR EDX,EDX
MOV R14,RDI
PUSH R13
LEA R13,[0x10201a]
PUSH R12
LEA R12,[0x10201c]
PUSH RBP
MOV RBP,RSI
PUSH RBX
JMP 0x001014e0
LAB_001014a8:
MOV RCX,qword ptr [RBP + 0x8]
MOV EAX,0x1
MOV RDX,RCX
SUB RDX,RBX
CMP RDX,0x0
CMOVA RDX,RAX
CMP RCX,RBX
JC 0x001015d4
MOV R8D,0x1
MOV RCX,R13
MOV RSI,RBX
MOV... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
int iVar1;
size_t sVar2;
ulong *__dest;
size_t sVar3;
long *plVar4;
int4 extraout_var;
uint uVar5;
ulong uVar6;
uint uVar7;
char *pcVar8;
long lVar9;
char *pcVar10;
long in_FS_OFFSET;
size_t sStack_60;
long lStack_58;
... |
2,523 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string text) {
for (size_t pos = 0; (pos = text.find(" ", pos)) != std::string::npos; pos++) {
text.replace(pos, 1, "_");
}
return text;
}
| int main() {
assert(func0("Jumanji The Jungle") == "Jumanji_The_Jungle");
assert(func0("The Avengers") == "The_Avengers");
assert(func0("Fast and Furious") == "Fast_and_Furious");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
xor %edx,%edx
mov %rdi,%r13
push %r12
push %rbp
lea 0xabf(%rip),%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
jmp 1589 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x59>
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
xor edx, edx
mov r14, rdi
push r13
lea r13, asc_201A; "_"
push r12
lea r12, asc_201C; " "
push rbp
mov rbp, rsi
push rbx
jmp short loc_14E0
loc_14A8:
mov rcx, [rbp+8]
mov eax, 1
mov rdx, rcx... | char ** func0(char **a1, char **a2)
{
unsigned long long i; // rdx
unsigned long long v5; // rcx
unsigned long long v6; // rbx
_QWORD *v7; // rsi
char *v8; // rax
char *v9; // rcx
char *v10; // rdx
char **result; // rax
unsigned int v12; // ecx
unsigned long long v13; // rdi
char *v14; // rsi
ch... | func0:
ENDBR64
PUSH R14
XOR EDX,EDX
MOV R14,RDI
PUSH R13
LEA R13,[0x10201a]
PUSH R12
LEA R12,[0x10201c]
PUSH RBP
MOV RBP,RSI
PUSH RBX
JMP 0x001014e0
LAB_001014a8:
MOV RCX,qword ptr [RBP + 0x8]
MOV EAX,0x1
MOV RDX,RCX
SUB RDX,RBX
CMP RDX,0x0
CMOVA RDX,RAX
CMP RCX,RBX
JC 0x001015d4
MOV R8D,0x1
MOV RCX,R13
MOV RSI,RBX
MOV... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
int iVar1;
size_t sVar2;
ulong *__dest;
size_t sVar3;
long *plVar4;
int4 extraout_var;
uint uVar5;
ulong uVar6;
uint uVar7;
char *pcVar8;
long lVar9;
char *pcVar10;
long in_FS_OFFSET;
size_t sStack_60;
long lStack_58;
... |
2,524 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& num_list) {
std::vector<int> a(num_list.size(), 0);
a.clear();
for (int num : num_list) {
if (num == 0) {
a.push_back(0);
}
}
std::vector<int> x;
x.clear();
for (int num : num_list) {
if (num != 0... | int main() {
assert((func0({1,0,2,0,3,4}) == std::vector<int>{1,2,3,4,0,0}));
assert((func0({2,3,2,0,0,4,0,5,0}) == std::vector<int>{2,3,2,4,5,0,0,0,0}));
assert((func0({0,1,0,1,1}) == std::vector<int>{1,1,1,0,0}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x60,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 1c78 <_ZNSaIiEC1Ev>
movl $0... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 60h
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_58]
mov [rbp+var_38], rax
nop
nop
mov dword ptr [rbp+var_50], 0
mov ... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // r12
long long v4; // rbx
int v6; // [rsp+10h] [rbp-60h] BYREF
long long v8; // [rsp+18h] [rbp-58h] BYREF
long long v9; // [rsp+20h] [rbp-50h] BYREF
long long v10; // [rsp+28h] [rbp-48h]
long long v11; // [rsp+30h] [rbp-... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x60
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 + -0x58]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV dword ptr [RBP + -0x50],0x0
MOV RAX,qword ptr [RBP ... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
bool bVar1;
ulong uVar2;
int *piVar3;
int8 uVar4;
int8 uVar5;
vector<int,std::allocator<int>> *in_RSI;
long in_FS_OFFSET;
int local_68;
int local_64;
int8 local_60;
ulong local_58;
vector<int,std::allo... |
2,525 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& num_list) {
std::vector<int> a(num_list.size(), 0);
a.clear();
for (int num : num_list) {
if (num == 0) {
a.push_back(0);
}
}
std::vector<int> x;
x.clear();
for (int num : num_list) {
if (num != 0... | int main() {
assert((func0({1,0,2,0,3,4}) == std::vector<int>{1,2,3,4,0,0}));
assert((func0({2,3,2,0,0,4,0,5,0}) == std::vector<int>{2,3,2,4,5,0,0,0,0}));
assert((func0({0,1,0,1,1}) == std::vector<int>{1,1,1,0,0}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov 0x8(%rsi),%rbx
sub (%rsi),%rbx
mov %rbx,%rax
sar $0x2,%rax
test %rbx,%rbx
js 12ef <_Z5func0RKSt6v... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
mov rcx, [rsi+8]
sub rcx, [rsi]
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rcx
jb loc_131F
mov rbp, rdi
mov r12, rsi
mov rbx,... | _QWORD * func0(_QWORD *a1, int **a2)
{
unsigned long long v2; // rcx
long long v4; // rbx
char *v5; // rax
char *v6; // rdx
int *v7; // rbx
int *v8; // r13
int *v9; // rbx
int *i; // r12
void *v11; // rbx
char *v12; // rsi
int v13; // eax
_DWORD *v14; // rsi
int v16; // [rsp+Ch] [rbp-4Ch] BYRE... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RCX,qword ptr [RSI + 0x8]
SUB RCX,qword ptr [RSI]
MOV RAX,0x7ffffffffffffffc
CMP RAX,RCX
JC 0x0010131f
MOV RBP,RDI
MOV R12,RSI
MOV RBX,RCX
TEST RCX,RCX
JZ 0x0010142f
MOV RDI,RCX
LAB... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int *piVar1;
int *piVar2;
ulong uVar3;
int4 *puVar4;
int *piVar5;
long *in_RSI;
long in_FS_OFFSET;
int local_4c;
int4 *local_48;
int4 *local_40;
int4 *local_38;
long local_30;
local_30 = *(long *)... |
2,526 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& num_list) {
std::vector<int> a(num_list.size(), 0);
a.clear();
for (int num : num_list) {
if (num == 0) {
a.push_back(0);
}
}
std::vector<int> x;
x.clear();
for (int num : num_list) {
if (num != 0... | int main() {
assert((func0({1,0,2,0,3,4}) == std::vector<int>{1,2,3,4,0,0}));
assert((func0({2,3,2,0,0,4,0,5,0}) == std::vector<int>{2,3,2,4,5,0,0,0,0}));
assert((func0({0,1,0,1,1}) == std::vector<int>{1,1,1,0,0}));
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 $0x28,%rsp
mov 0x8(%rsi),%rbp
mov (%rsi),%rbx
mov %rbp,%r15
sub %rbx,%r15
mov %r15,%rax
sar $0x2,%rax
test %r15,%r15
js 19ae <_Z5func0RKSt6vectorIiSaIiEE+0... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r12, [rsi+8]
mov rbx, [rsi]
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov rax, 7FFFFFFFFFFFFFFCh
mov r14, r12
sub r14, rbx
cmp rax, r14
jb ... | long long func0(long long a1, char **a2)
{
char *v2; // r12
char *v3; // rbx
unsigned long long v4; // r14
char *v6; // rcx
char *v7; // rcx
char *v8; // rbx
char *v9; // r14
char *v10; // r13
int v11; // r12d
char *v12; // r12
signed long long v13; // rbx
_DWORD *v14; // rcx
unsigned long lo... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R12,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV RAX,0x7ffffffffffffffc
MOV R14,R12
SUB R14,RBX
CMP RAX,R14
JC 0x00101cdb
PXOR XMM0,XMM0
MOV RBP,RDI
MOV R13,R... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int iVar1;
size_t __n;
int *__dest;
int *piVar2;
ulong uVar3;
ulong uVar4;
int *piVar5;
vector *pvVar6;
int uVar7;
int extraout_DL;
ulong uVar8;
ulong uVar9;
int uVar10;
int8 *in_RSI;
int8 *puVar... |
2,527 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& num_list) {
std::vector<int> a(num_list.size(), 0);
a.clear();
for (int num : num_list) {
if (num == 0) {
a.push_back(0);
}
}
std::vector<int> x;
x.clear();
for (int num : num_list) {
if (num != 0... | int main() {
assert((func0({1,0,2,0,3,4}) == std::vector<int>{1,2,3,4,0,0}));
assert((func0({2,3,2,0,0,4,0,5,0}) == std::vector<int>{2,3,2,4,5,0,0,0,0}));
assert((func0({0,1,0,1,1}) == std::vector<int>{1,1,1,0,0}));
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 $0x28,%rsp
mov 0x8(%rsi),%rbp
mov (%rsi),%rbx
mov %rbp,%r15
sub %rbx,%r15
mov %r15,%rax
sar $0x2,%rax
test %r15,%r15
js 197e <_Z5func0RKSt6vectorIiSaIiEE+0... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r12, [rsi+8]
mov rbx, [rsi]
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov rax, 7FFFFFFFFFFFFFFCh
mov r14, r12
sub r14, rbx
cmp rax, r14
jb ... | long long func0(long long a1, char **a2)
{
char *v2; // r12
char *v3; // rbx
unsigned long long v4; // r14
char *v6; // rcx
char *v7; // rcx
char *v8; // rbx
char *v9; // r13
int v10; // r12d
char *v11; // r13
signed long long v12; // r12
_DWORD *v13; // rcx
unsigned long long v14; // rsi
uns... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R12,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV RAX,0x7ffffffffffffffc
MOV R14,R12
SUB R14,RBX
CMP RAX,R14
JC 0x00101cda
PXOR XMM0,XMM0
MOV RBP,RDI
MOV R13,R... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int iVar1;
int4 *__src;
int4 *__dest;
long lVar2;
vector *pvVar3;
int uVar4;
ulong uVar5;
int *__dest_00;
int extraout_DL;
int *piVar6;
int *piVar7;
int uVar8;
int8 *in_RSI;
int8 *puVar9;
char *p... |
2,528 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
| int func0(const vector<int>& arr, int n) {
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
ans += (arr[i] ^ arr[j]);
}
}
return ans;
}
| int main() {
assert(func0({5,9,7,6}, 4) == 47);
assert(func0({7,3,5}, 3) == 12);
assert(func0({7,3}, 2) == 4);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jge 12e3 <_Z5func0RKSt6vectorIiSaIiEEi+0x7a>
mo... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
jmp short loc_12BB
loc_126D:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_12AF
l... | long long func0(long long a1, int a2)
{
int v2; // ebx
unsigned int v4; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
v2 = *(_DWORD *)std::vector<int>::operator[](a1, i);
v4 += ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001012bb
LAB_0010126d:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001012af
LAB_00101278:
... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
uint uVar1;
uint *puVar2;
int4 local_24;
int4 local_20;
int4 local_1c;
local_24 = 0;
for (local_20 = 0; local_1c = local_20, local_20 < param_2; local_20 = local_20 + 1) {
while (local_1c = lo... |
2,529 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
| int func0(const vector<int>& arr, int n) {
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
ans += (arr[i] ^ arr[j]);
}
}
return ans;
}
| int main() {
assert(func0({5,9,7,6}, 4) == 47);
assert(func0({7,3,5}, 3) == 12);
assert(func0({7,3}, 2) == 4);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
test %esi,%esi
jle 128b <_Z5func0RKSt6vectorIiSaIiEEi+0x42>
lea -0x1(%rsi),%r11d
add $0x1,%r11
mov $0x1,%r10d
mov $0x0,%edx
cmp %r11,%r10
je 1290 <_Z5func0RKSt6vectorIiSaIiEEi+0x47>
mov (%rdi),%r8
mov -0x4(%r8,%r10,4),%r9d
... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
test esi, esi
jle short loc_1260
push rbp
push rbx
mov ebx, esi
movsxd rbp, esi
mov r11d, 0
mov r10d, 1
mov edx, 0
jmp short loc_122E
loc_122B:
mov r10, rax
loc_122E:
cmp r10, rbx
jz short loc_125B
mov r8, [rdi]
mov r9d, [r8+r1... | long long func0(_QWORD *a1, int a2)
{
long long v2; // r11
long long v3; // r10
unsigned int v4; // edx
long long v5; // rax
if ( a2 <= 0 )
return 0LL;
v2 = 0LL;
v3 = 1LL;
v4 = 0;
while ( v3 != a2 )
{
v5 = v3;
do
v4 += *(_DWORD *)(*a1 + 4 * v5++) ^ *(_DWORD *)(*a1 + v2);
whil... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101260
PUSH RBP
PUSH RBX
MOV EBX,ESI
MOVSXD RBP,ESI
MOV R11D,0x0
MOV R10D,0x1
MOV EDX,0x0
JMP 0x0010122e
LAB_0010122b:
MOV R10,RAX
LAB_0010122e:
CMP R10,RBX
JZ 0x0010125b
MOV R8,qword ptr [RDI]
MOV R9D,dword ptr [R8 + R11*0x1]
MOV RAX,R10
LAB_0010123d:
MOV ECX,R9D
XOR ECX,dword ptr [... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
long lVar4;
bool bVar5;
if (param_2 < 1) {
return 0;
}
lVar4 = 0;
iVar2 = 0;
uVar3 = 1;
do {
if (uVar3 == (uint)param_2) {
return iVar2;
... |
2,530 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
| int func0(const vector<int>& arr, int n) {
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
ans += (arr[i] ^ arr[j]);
}
}
return ans;
}
| int main() {
assert(func0({5,9,7,6}, 4) == 47);
assert(func0({7,3,5}, 3) == 12);
assert(func0({7,3}, 2) == 4);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
test %esi,%esi
jle 14ce <_Z5func0RKSt6vectorIiSaIiEEi+0x4e>
lea -0x1(%rsi),%r11d
mov $0x1,%r10d
xor %r8d,%r8d
add $0x1,%r11
cmp %r11,%r10
je 14ca <_Z5func0RKSt6vectorIiSaIiEEi+0x4a>
xchg %ax,%ax
mov (%rdi),%rcx
mov %r10,%... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
test esi, esi
jle short loc_13D0
cmp esi, 1
jz short loc_13D0
mov rdi, [rdi]
mov r11d, esi
mov r9d, 1
xor r10d, r10d
xor edx, edx
xchg ax, ax
loc_13A0:
mov r8d, [rdi+r10]
mov rax, r9
nop word ptr [rax+rax+00000000h]
loc_13B0:
mov ... | long long func0(long long *a1, int a2)
{
long long v2; // rdi
long long v3; // r9
long long v4; // r10
unsigned int v5; // edx
long long v6; // rax
int v7; // ecx
if ( a2 < 2 )
return 0LL;
v2 = *a1;
v3 = 1LL;
v4 = 0LL;
v5 = 0;
do
{
v6 = v3;
do
{
v7 = *(_DWORD *)(v2 + 4 ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013d0
CMP ESI,0x1
JZ 0x001013d0
MOV RDI,qword ptr [RDI]
MOV R11D,ESI
MOV R9D,0x1
XOR R10D,R10D
XOR EDX,EDX
NOP
LAB_001013a0:
MOV R8D,dword ptr [RDI + R10*0x1]
MOV RAX,R9
NOP word ptr [RAX + RAX*0x1]
LAB_001013b0:
MOV ECX,dword ptr [RDI + RAX*0x4]
ADD RAX,0x1
XOR ECX,R8D
ADD EDX,ECX
... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
long lVar1;
ulong uVar2;
int iVar3;
ulong uVar4;
long lVar5;
if ((0 < param_2) && (param_2 != 1)) {
uVar4 = 1;
lVar5 = 0;
iVar3 = 0;
do {
uVar2 = uVar4;
do {
lVar... |
2,531 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
| int func0(const vector<int>& arr, int n) {
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
ans += (arr[i] ^ arr[j]);
}
}
return ans;
}
| int main() {
assert(func0({5,9,7,6}, 4) == 47);
assert(func0({7,3,5}, 3) == 12);
assert(func0({7,3}, 2) == 4);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
test %esi,%esi
jle 157e <_Z5func0RKSt6vectorIiSaIiEEi+0x10e>
cmp $0x1,%esi
je 157e <_Z5func0RKSt6vectorIiSaIiEEi+0x10e>
push %r14
xor %eax,%eax
xor %r8d,%r8d
mov $0x1,%ecx
push %rbp
mov $0x1,%r11d
push %rbx
mov (%rdi),%r... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
test esi, esi
jle loc_14B1
mov r8d, esi
cmp esi, 1
jz loc_14B1
push r14
xor r9d, r9d
mov esi, 1
push rbp
lea ebp, [r8-1]
push rbx
mov ebx, 1
mov r11, [rdi]
xor edi, edi
nop word ptr [rax+rax+00h]
loc_13D8:
mov ecx, r8d
mo... | long long func0(long long *a1, int a2)
{
long long v3; // r9
int v4; // esi
long long v5; // r11
unsigned int v6; // edi
unsigned int v7; // r10d
unsigned int v8; // ecx
__m128i v9; // xmm1
const __m128i *v10; // rax
__m128i v11; // xmm2
__m128i v12; // xmm0
__m128i v13; // xmm1
int v14; // ecx... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001014b1
MOV R8D,ESI
CMP ESI,0x1
JZ 0x001014b1
PUSH R14
XOR R9D,R9D
MOV ESI,0x1
PUSH RBP
LEA EBP,[R8 + -0x1]
PUSH RBX
MOV EBX,0x1
MOV R11,qword ptr [RDI]
XOR EDI,EDI
NOP word ptr [RAX + RAX*0x1]
LAB_001013d8:
MOV ECX,R8D
MOV EAX,EBP
MOV R10D,dword ptr [R11 + R9*0x1]
SUB ECX,ESI
CMP R8D... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
long lVar1;
uint uVar2;
long lVar3;
uint uVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
uint uVar9;
uint *puVar10;
int iVar11;
int iVar12;
long lVar13;
int iVar14;
int... |
2,532 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
int j = 2 * i;
sum += j * j * j * j;
}
return sum;
}
| int main() {
assert(func0(2) == 272);
assert(func0(3) == 1568);
assert(func0(4) == 5664);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jg 11c9 <_Z5func0i+0x40>
mov -0x8(%rbp),%eax
add %eax,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
mov [rbp+var_8], 1
jmp short loc_1181
loc_1164:
mov eax, [rbp+var_8]
add eax, eax
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+var_4]
imul eax, [rbp+var_4]
add ... | long long func0(int a1)
{
unsigned int v2; // [rsp+8h] [rbp-Ch]
int i; // [rsp+Ch] [rbp-8h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += 2 * i * 2 * i * 2 * i * 2 * i;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x1
JMP 0x00101181
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EAX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0x4]
IMUL EAX,dw... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int4 local_14;
int4 local_10;
local_14 = 0;
for (local_10 = 1; local_10 <= param_1; local_10 = local_10 + 1) {
iVar1 = local_10 * 2;
local_14 = local_14 + iVar1 * iVar1 * iVar1 * iVar1;
}
return local_14;
} |
2,533 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
int j = 2 * i;
sum += j * j * j * j;
}
return sum;
}
| int main() {
assert(func0(2) == 272);
assert(func0(3) == 1568);
assert(func0(4) == 5664);
return 0;
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11b3 <_Z5func0i+0x2a>
lea 0x2(%rdi,%rdi,1),%esi
mov $0x2,%eax
mov $0x0,%ecx
mov %eax,%edx
imul %eax,%edx
imul %edx,%edx
add %edx,%ecx
add $0x2,%eax
cmp %esi,%eax
jne 119f <_Z5func0i+0x16>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 11b0 <_Z5func0... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1173
lea esi, [rdi+rdi+2]
mov eax, 2
mov ecx, 0
loc_115F:
mov edx, eax
imul edx, eax
imul edx, edx
add ecx, edx
add eax, 2
cmp eax, esi
jnz short loc_115F
loc_1170:
mov eax, ecx
retn
loc_1173:
mov ecx, 0
jmp short lo... | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = 2;
v2 = 0;
do
{
v2 += v1 * v1 * v1 * v1;
v1 += 2;
}
while ( v1 != 2 * a1 + 2 );
}
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101173
LEA ESI,[RDI + RDI*0x1 + 0x2]
MOV EAX,0x2
MOV ECX,0x0
LAB_0010115f:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EDX
ADD ECX,EDX
ADD EAX,0x2
CMP EAX,ESI
JNZ 0x0010115f
LAB_00101170:
MOV EAX,ECX
RET
LAB_00101173:
MOV ECX,0x0
JMP 0x00101170 | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 2;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1 * iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 2;
} while (iVar1 != param_1 * 2 + 2);
}
return iVar2;
} |
2,534 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
int j = 2 * i;
sum += j * j * j * j;
}
return sum;
}
| int main() {
assert(func0(2) == 272);
assert(func0(3) == 1568);
assert(func0(4) == 5664);
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11f0 <_Z5func0i+0x30>
lea 0x2(%rdi,%rdi,1),%ecx
mov $0x2,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
mov %eax,%edx
imul %eax,%edx
add $0x2,%eax
imul %edx,%edx
add %edx,%r8d
cmp %ecx,%eax
jne 11d8 <_Z5func0i+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor ... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1170
lea esi, [rdi+rdi+2]
mov eax, 2
xor ecx, ecx
nop dword ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
add eax, 2
imul edx, edx
add ecx, edx
cmp eax, esi
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ... | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // ecx
int v3; // edx
if ( a1 <= 0 )
return 0LL;
v1 = 2;
v2 = 0;
do
{
v3 = v1 * v1;
v1 += 2;
v2 += v3 * v3;
}
while ( v1 != 2 * a1 + 2 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
LEA ESI,[RDI + RDI*0x1 + 0x2]
MOV EAX,0x2
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
ADD EAX,0x2
IMUL EDX,EDX
ADD ECX,EDX
CMP EAX,ESI
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 2;
iVar2 = 0;
do {
iVar3 = iVar1 * iVar1;
iVar1 = iVar1 + 2;
iVar2 = iVar2 + iVar3 * iVar3;
} while (iVar1 != param_1 * 2 + 2);
return iVar2;
}
return 0;
} |
2,535 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
int j = 2 * i;
sum += j * j * j * j;
}
return sum;
}
| int main() {
assert(func0(2) == 272);
assert(func0(3) == 1568);
assert(func0(4) == 5664);
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11f0 <_Z5func0i+0x30>
lea 0x2(%rdi,%rdi,1),%ecx
mov $0x2,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
mov %eax,%edx
imul %eax,%edx
add $0x2,%eax
imul %edx,%edx
add %edx,%r8d
cmp %eax,%ecx
jne 11d8 <_Z5func0i+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor ... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1170
lea esi, [rdi+rdi+2]
mov eax, 2
xor ecx, ecx
nop dword ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
add eax, 2
imul edx, edx
add ecx, edx
cmp esi, eax
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ... | long long func0(int a1)
{
int v1; // eax
unsigned int v2; // ecx
int v3; // edx
if ( a1 <= 0 )
return 0LL;
v1 = 2;
v2 = 0;
do
{
v3 = v1 * v1;
v1 += 2;
v2 += v3 * v3;
}
while ( 2 * a1 + 2 != v1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
LEA ESI,[RDI + RDI*0x1 + 0x2]
MOV EAX,0x2
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
ADD EAX,0x2
IMUL EDX,EDX
ADD ECX,EDX
CMP ESI,EAX
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 2;
iVar2 = 0;
do {
iVar3 = iVar1 * iVar1;
iVar1 = iVar1 + 2;
iVar2 = iVar2 + iVar3 * iVar3;
} while (param_1 * 2 + 2 != iVar1);
return iVar2;
}
return 0;
} |
2,536 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| vector<int> func0(const vector<int>& iterable) {
priority_queue<int, vector<int>, greater<int>> min_heap;
for(auto value : iterable){
min_heap.push(value);
}
vector<int> sorted;
while(!min_heap.empty()){
sorted.push_back(min_heap.top());
min_heap.pop();
}
re... | int main(){
assert(func0({1, 3, 5, 7, 9, 2, 4, 6, 8, 0}) == vector<int>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}));
assert(func0({25, 35, 22, 85, 14, 65, 75, 25, 58}) == vector<int>({14, 22, 25, 25, 35, 58, 65, 75, 85}));
assert(func0({7, 1, 9, 5}) == vector<int>({1, 5, 7, 9}));
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 1c30 <_ZNSt14priority_queueIiSt6vectorIiS... | _Z5func0RKSt6vectorIiSaIiEE:
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 rdi, rax
call _ZNSt14priority_queueIiSt6vectorIiSaIiEESt7greaterIiEEC2IS2... | long long func0(long long a1, long long a2)
{
long long v2; // rax
int v4; // [rsp+14h] [rbp-5Ch] BYREF
long long v5; // [rsp+18h] [rbp-58h] BYREF
_QWORD v6[2]; // [rsp+20h] [rbp-50h] BYREF
_BYTE v7[40]; // [rsp+30h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+58h] [rbp-18h]
v8 = __readfsqword(0x28u)... | 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 RDI,RAX
CALL 0x00101c0e
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qwor... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
bool bVar1;
char cVar2;
int *piVar3;
vector<int,std::allocator<int>> *in_RSI;
long in_FS_OFFSET;
int local_64;
int8 local_60;
int8 local_58;
vector<int,std::allocator<int>> *local_50;
priority_queue<int,st... |
2,537 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| vector<int> func0(const vector<int>& iterable) {
priority_queue<int, vector<int>, greater<int>> min_heap;
for(auto value : iterable){
min_heap.push(value);
}
vector<int> sorted;
while(!min_heap.empty()){
sorted.push_back(min_heap.top());
min_heap.pop();
}
re... | int main(){
assert(func0({1, 3, 5, 7, 9, 2, 4, 6, 8, 0}) == vector<int>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}));
assert(func0({25, 35, 22, 85, 14, 65, 75, 25, 58}) == vector<int>({14, 22, 25, 25, 35, 58, 65, 75, 85}));
assert(func0({7, 1, 9, 5}) == vector<int>({1, 5, 7, 9}));
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
mov (%rsi),%rbp
mov 0x8(%rsi),%r12
cmp ... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
mov [rsp+68h+var_58], 0
mov [rsp+68h+var_50], 0
mov [rsp+68h+var_48], 0
mov rbx, [rsi]
mov r12, [rsi+8]
cmp r1... | _QWORD * func0(_QWORD *a1, int **a2)
{
int *v3; // rbx
int *v4; // r12
int v5; // eax
char *v6; // rsi
char *v7; // r12
char *v8; // rbx
long long i; // rdx
long long v10; // rsi
_DWORD *v11; // rsi
unsigned int v12; // r9d
long long v13; // rdi
char v15; // [rsp+Bh] [rbp-5Dh] BYREF
int v16; /... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV RBX,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
CMP R12,RBX
JZ 0x001012f4
... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int iVar1;
int *piVar2;
long lVar3;
int *piVar4;
long lVar5;
long lVar6;
int *piVar7;
int8 *in_RSI;
ulong uVar8;
long in_FS_OFFSET;
_Iter_comp_val local_5d;
int local_5c;
int *local_58;
int *local_... |
2,538 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| vector<int> func0(const vector<int>& iterable) {
priority_queue<int, vector<int>, greater<int>> min_heap;
for(auto value : iterable){
min_heap.push(value);
}
vector<int> sorted;
while(!min_heap.empty()){
sorted.push_back(min_heap.top());
min_heap.pop();
}
re... | int main(){
assert(func0({1, 3, 5, 7, 9, 2, 4, 6, 8, 0}) == vector<int>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}));
assert(func0({25, 35, 22, 85, 14, 65, 75, 25, 58}) == vector<int>({14, 22, 25, 25, 35, 58, 65, 75, 85}));
assert(func0({7, 1, 9, 5}) == vector<int>({1, 5, 7, 9}));
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x48,%rsp
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
cmp ... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 48h
mov r12, [rsi]
mov r14, [rsi+8]
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
movaps xmmword ptr [rsp+78h+var_68], xmm0
mov ... | long long func0(long long a1, int **a2)
{
int *v3; // r12
int *v4; // r14
char *v5; // rbp
char *v6; // rbx
long long v7; // rax
long long v8; // rcx
long long v9; // rdx
char *v10; // rsi
int v11; // edi
long long v12; // rax
long long v13; // rsi
long long v14; // rsi
char *v15; // rax
in... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R12,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
CMP R14,R12
JZ 0x0... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int iVar1;
int iVar2;
int8 uVar3;
long lVar4;
int *piVar5;
long lVar6;
int iVar7;
int *piVar8;
long lVar9;
int *piVar10;
int *piVar11;
int8 *in_RSI;
ulong uVar12;
long in_FS_OFFSET;
bool bVar13;
... |
2,539 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
| vector<int> func0(const vector<int>& iterable) {
priority_queue<int, vector<int>, greater<int>> min_heap;
for(auto value : iterable){
min_heap.push(value);
}
vector<int> sorted;
while(!min_heap.empty()){
sorted.push_back(min_heap.top());
min_heap.pop();
}
re... | int main(){
assert(func0({1, 3, 5, 7, 9, 2, 4, 6, 8, 0}) == vector<int>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}));
assert(func0({25, 35, 22, 85, 14, 65, 75, 25, 58}) == vector<int>({14, 22, 25, 25, 35, 58, 65, 75, 85}));
assert(func0({7, 1, 9, 5}) == vector<int>({1, 5, 7, 9}));
}
| 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 $0x48,%rsp
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movaps %xmm0,0x10(%rsp)
movq $0x0,0x20(%rsp)
cmp ... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 48h
mov r12, [rsi]
mov r14, [rsi+8]
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
movaps [rsp+78h+var_68], xmm0
mov [rsp+78h+var... | long long func0(long long a1, int **a2)
{
int *v3; // r12
int *v4; // r14
char *v5; // rbp
long long v6; // rax
long long v7; // rcx
long long v8; // rdx
char *v9; // rsi
int v10; // edi
char *v11; // rbx
long long v12; // rax
long long v13; // rsi
long long v14; // rsi
char *v15; // rax
in... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R12,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
CMP R14,R12
JZ 0x0... | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int iVar1;
int iVar2;
int8 uVar3;
long lVar4;
int *piVar5;
long lVar6;
int iVar7;
int *piVar8;
long lVar9;
int *piVar10;
int *piVar11;
int8 *in_RSI;
ulong uVar12;
long in_FS_OFFSET;
bool bVar13;
... |
2,540 | func0 |
#include <string>
#include <assert.h>
| std::string func0(int a, int b, int c) {
if (a == c)
return "Yes";
else
return "No";
}
| int main() {
assert(func0(2, 0, 2) == "Yes");
assert(func0(2, -5, 2) == "Yes");
assert(func0(1, 2, 3) == "No");
return 0;
}
| O0 | cpp | func0[abi:cxx11](int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %ecx,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x2c(%rbp),%eax
cmp -0x34(%rbp),%eax
jne 142b <_... | _Z5func0B5cxx11iii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov [rbp+var_44], ecx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_44]
jnz short l... | long long func0[abi:cxx11](long long a1, int a2, long long a3, int a4)
{
char v5; // [rsp+27h] [rbp-29h] BYREF
char *v6; // [rsp+28h] [rbp-28h]
char *v7; // [rsp+30h] [rbp-20h]
unsigned long long v8; // [rsp+38h] [rbp-18h]
v8 = __readfsqword(0x28u);
if ( a2 == a4 )
{
v6 = &v5;
std::string::basic... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
MOV dword ptr [RBP + -0x44],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [... | /* func0[abi:cxx11](int, int, int) */
string * func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
int in_ECX;
int4 in_register_0000003c;
string *this;
long in_FS_OFFSET;
allocator local_31;
allocator *local_30;
allocator *local_28;
long local_20;
this = (string *)CONCAT44(in_register_0000003... |
2,541 | func0 |
#include <string>
#include <assert.h>
| std::string func0(int a, int b, int c) {
if (a == c)
return "Yes";
else
return "No";
}
| int main() {
assert(func0(2, 0, 2) == "Yes");
assert(func0(2, -5, 2) == "Yes");
assert(func0(1, 2, 3) == "No");
return 0;
}
| O1 | cpp | func0[abi:cxx11](int, int, int):
endbr64
push %rbx
mov %rdi,%rbx
cmp %ecx,%esi
je 1231 <_Z5func0B5cxx11iii+0x28>
lea 0x10(%rdi),%rax
mov %rax,(%rdi)
lea 0xe15(%rip),%rdx
lea -0x2(%rdx),%rsi
callq 13a8 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_it... | _Z5func0B5cxx11iii:
endbr64
push rbx
mov rbx, rdi
cmp esi, ecx
jz short loc_1231
lea rax, [rdi+10h]
mov [rdi], rax
lea rdx, unk_200A
lea rsi, [rdx-2]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct... | _QWORD * func0[abi:cxx11](_QWORD *a1, int a2, long long a3, int a4)
{
*a1 = a1 + 2;
if ( a2 == a4 )
std::string::_M_construct<char const*>(a1, (char *)&unk_2007 - 3);
else
std::string::_M_construct<char const*>(a1, (char *)&unk_200A - 2);
return a1;
} | func0[abi:cxx11]:
ENDBR64
PUSH RBX
MOV RBX,RDI
CMP ESI,ECX
JZ 0x00101231
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
LEA RDX,[0x10200a]
LEA RSI,[RDX + -0x2]
CALL 0x001013d0
LAB_0010122c:
MOV RAX,RBX
POP RBX
RET
LAB_00101231:
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
LEA RDX,[0x102007]
LEA RSI,[RDX + -0x3]
CALL 0x00... | /* func0[abi:cxx11](int, int, int) */
int8 func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
int in_ECX;
int4 in_register_0000003c;
if (param_2 == in_ECX) {
*(long *)CONCAT44(in_register_0000003c,param_1) = CONCAT44(in_register_0000003c,param_1) + 0x10;
std::string::_M_construct<char_const*>
... |
2,542 | func0 |
#include <string>
#include <assert.h>
| std::string func0(int a, int b, int c) {
if (a == c)
return "Yes";
else
return "No";
}
| int main() {
assert(func0(2, 0, 2) == "Yes");
assert(func0(2, -5, 2) == "Yes");
assert(func0(1, 2, 3) == "No");
return 0;
}
| O2 | cpp | func0[abi:cxx11](int, int, int):
endbr64
lea 0x10(%rdi),%rdx
mov %rdi,%rax
mov %rdx,(%rdi)
cmp %ecx,%esi
je 13b0 <_Z5func0B5cxx11iii+0x30>
mov $0x6f4e,%edx
movq $0x2,0x8(%rdi)
mov %dx,0x10(%rdi)
movb $0x0,0x12(%rdi)
retq
nopl 0x0(%rax,%rax,1)
mov $0x6559,%ecx
mov %cx,0x10(%rdi)
movb ... | _Z5func0B5cxx11iii:
endbr64
lea rax, [rdi+10h]
push rbx
mov rbx, rdi
mov [rdi], rax
cmp esi, ecx
jz short loc_1440
lea rdx, unk_200A
lea rsi, [rdx-2]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag_isra_0; std::string::_M_co... | _QWORD * func0[abi:cxx11](_QWORD *a1, int a2, long long a3, int a4)
{
*a1 = a1 + 2;
if ( a2 == a4 )
std::string::_M_construct<char const*>(a1, (char *)&unk_2007 - 3);
else
std::string::_M_construct<char const*>(a1, (char *)&unk_200A - 2);
return a1;
} | func0[abi:cxx11]:
ENDBR64
LEA RAX,[RDI + 0x10]
PUSH RBX
MOV RBX,RDI
MOV qword ptr [RDI],RAX
CMP ESI,ECX
JZ 0x00101440
LEA RDX,[0x10200a]
LEA RSI,[RDX + -0x2]
CALL 0x00101360
MOV RAX,RBX
POP RBX
RET
LAB_00101440:
LEA RDX,[0x102007]
LEA RSI,[RDX + -0x3]
CALL 0x00101360
MOV RAX,RBX
POP RBX
RET | /* func0[abi:cxx11](int, int, int) */
int8 func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
int in_ECX;
int4 in_register_0000003c;
*(long *)CONCAT44(in_register_0000003c,param_1) = CONCAT44(in_register_0000003c,param_1) + 0x10;
if (param_2 != in_ECX) {
std::string::_M_construct<char_const*>
... |
2,543 | func0 |
#include <string>
#include <assert.h>
| std::string func0(int a, int b, int c) {
if (a == c)
return "Yes";
else
return "No";
}
| int main() {
assert(func0(2, 0, 2) == "Yes");
assert(func0(2, -5, 2) == "Yes");
assert(func0(1, 2, 3) == "No");
return 0;
}
| O3 | cpp | func0[abi:cxx11](int, int, int):
endbr64
lea 0x10(%rdi),%rdx
mov %rdi,%rax
mov %rdx,(%rdi)
cmp %ecx,%esi
je 1340 <_Z5func0B5cxx11iii+0x30>
mov $0x6f4e,%edx
movq $0x2,0x8(%rdi)
mov %dx,0x10(%rdi)
movb $0x0,0x12(%rdi)
retq
nopl 0x0(%rax,%rax,1)
mov $0x6559,%ecx
mov %cx,0x10(%rdi)
movb ... | _Z5func0B5cxx11iii:
endbr64
lea rdx, [rdi+10h]
mov rax, rdi
mov [rdi], rdx
cmp esi, ecx
jz short loc_1350
mov edx, 6F4Eh
mov qword ptr [rdi+8], 2
mov [rdi+10h], dx
mov byte ptr [rdi+12h], 0
retn
loc_1350:
mov ecx, 6559h
mov byte ptr [rdi+12h], 73h ; 's'
mov [rdi+10h], cx... | long long func0[abi:cxx11](long long a1, int a2, long long a3, int a4)
{
long long result; // rax
result = a1;
*(_QWORD *)a1 = a1 + 16;
if ( a2 == a4 )
{
*(_BYTE *)(a1 + 18) = 115;
*(_WORD *)(a1 + 16) = 25945;
*(_QWORD *)(a1 + 8) = 3LL;
*(_BYTE *)(a1 + 19) = 0;
}
else
{
*(_QWORD *)... | func0[abi:cxx11]:
ENDBR64
LEA RDX,[RDI + 0x10]
MOV RAX,RDI
MOV qword ptr [RDI],RDX
CMP ESI,ECX
JZ 0x00101350
MOV EDX,0x6f4e
MOV qword ptr [RDI + 0x8],0x2
MOV word ptr [RDI + 0x10],DX
MOV byte ptr [RDI + 0x12],0x0
RET
LAB_00101350:
MOV ECX,0x6559
MOV byte ptr [RDI + 0x12],0x73
MOV word ptr [RDI + 0x10],CX
MOV qword ptr ... | /* func0[abi:cxx11](int, int, int) */
int8 func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
int in_ECX;
int4 in_register_0000003c;
*(long *)CONCAT44(in_register_0000003c,param_1) = CONCAT44(in_register_0000003c,param_1) + 0x10;
if (param_2 != in_ECX) {
*(int8 *)(CONCAT44(in_register_0000003c,par... |
2,544 | func0 |
#include <assert.h>
| bool func0(int actual_cost, int sale_amount) {
if (sale_amount == actual_cost) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1500, 1200) == false);
assert(func0(100, 100) == true);
assert(func0(2000, 5000) == false);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jne 1166 <_Z5func0ii+0x1d>
mov $0x1,%eax
jmp 116b <_Z5func0ii+0x22>
mov $0x0,%eax
pop %rbp
retq
| _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jnz short loc_1166
mov eax, 1
jmp short loc_116B
loc_1166:
mov eax, 0
loc_116B:
pop rbp
retn | _BOOL8 func0(int a1, int a2)
{
return a2 == a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JNZ 0x00101166
MOV EAX,0x1
JMP 0x0010116b
LAB_00101166:
MOV EAX,0x0
LAB_0010116b:
POP RBP
RET | /* func0(int, int) */
bool func0(int param_1,int param_2)
{
return param_2 == param_1;
} |
2,545 | func0 |
#include <assert.h>
| bool func0(int actual_cost, int sale_amount) {
if (sale_amount == actual_cost) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1500, 1200) == false);
assert(func0(100, 100) == true);
assert(func0(2000, 5000) == false);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
cmp %edi,%esi
sete %al
retq
| _Z5func0ii:
endbr64
cmp esi, edi
setz al
retn | bool func0(int a1, int a2)
{
return a2 == a1;
} | func0:
ENDBR64
CMP ESI,EDI
SETZ AL
RET | /* func0(int, int) */
bool func0(int param_1,int param_2)
{
return param_2 == param_1;
} |
2,546 | func0 |
#include <assert.h>
| bool func0(int actual_cost, int sale_amount) {
if (sale_amount == actual_cost) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1500, 1200) == false);
assert(func0(100, 100) == true);
assert(func0(2000, 5000) == false);
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
cmp %edi,%esi
sete %al
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
cmp esi, edi
setz al
retn | bool func0(int a1, int a2)
{
return a2 == a1;
} | func0:
ENDBR64
CMP ESI,EDI
SETZ AL
RET | /* func0(int, int) */
bool func0(int param_1,int param_2)
{
return param_2 == param_1;
} |
2,547 | func0 |
#include <assert.h>
| bool func0(int actual_cost, int sale_amount) {
if (sale_amount == actual_cost) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1500, 1200) == false);
assert(func0(100, 100) == true);
assert(func0(2000, 5000) == false);
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
cmp %edi,%esi
sete %al
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
cmp esi, edi
setz al
retn | bool func0(int a1, int a2)
{
return a2 == a1;
} | func0:
ENDBR64
CMP ESI,EDI
SETZ AL
RET | /* func0(int, int) */
bool func0(int param_1,int param_2)
{
return param_2 == param_1;
} |
2,548 | func0 |
#include <cmath>
#include <cassert>
| int func0(int v, int t) {
double windchill = 13.12 + 0.6215 * t - 11.37 * std::pow(v, 0.16) + 0.3965 * t * std::pow(v, 0.16);
return static_cast<int>(std::round(windchill));
}
| int main() {
assert(func0(120, 35) == 40);
assert(func0(40, 70) == 86);
assert(func0(10, 100) == 116);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm1
movsd 0xef8(%rip),%xmm0
mulsd %xmm0,%xmm1
movsd 0xef4(%rip),%xmm0
addsd %xmm0,%xmm1
movsd %xmm1,-0x20(%rbp)
mov 0xeec(%rip),%rdx
mov -0x14(%rbp),%eax
movq %rdx... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_2078
mulsd xmm1, xmm0
movsd xmm0, cs:qword_2080
addsd xmm1, xmm0
movsd [rbp+var_20], xmm1
mov rdx, cs:qword_2088
mov ... | long long func0(unsigned int a1, int a2)
{
double v3; // [rsp+10h] [rbp-20h]
double x; // [rsp+28h] [rbp-8h]
v3 = (double)a2 * 0.6215000000000001 + 13.12 - std::pow<int,double>(a1, 0.16) * 11.37;
x = std::pow<int,double>(a1, 0.16) * ((double)a2 * 0.3965) + v3;
return (unsigned int)(int)round(x);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102078]
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102080]
ADDSD XMM1,XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOV RDX,qword ptr [... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
double extraout_XMM0_Qa;
double dVar1;
double extraout_XMM0_Qa_00;
double dVar2;
double dVar3;
dVar2 = (double)param_2 * DAT_00102078 + DAT_00102080;
std::pow<int,double>(param_1,DAT_00102088);
dVar1 = extraout_XMM0_Qa * DAT_00102090;
dVa... |
2,549 | func0 |
#include <cmath>
#include <cassert>
| int func0(int v, int t) {
double windchill = 13.12 + 0.6215 * t - 11.37 * std::pow(v, 0.16) + 0.3965 * t * std::pow(v, 0.16);
return static_cast<int>(std::round(windchill));
}
| int main() {
assert(func0(120, 35) == 40);
assert(func0(40, 70) == 86);
assert(func0(10, 100) == 116);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
sub $0x28,%rsp
pxor %xmm4,%xmm4
cvtsi2sd %esi,%xmm4
movsd %xmm4,0x8(%rsp)
pxor %xmm6,%xmm6
cvtsi2sd %edi,%xmm6
mov 0xeea(%rip),%rax
movq %rax,%xmm1
movsd %xmm6,0x10(%rsp)
movapd %xmm6,%xmm0
callq 1080 <pow@plt>
movsd %xmm0,0x18(%rsp)
mov 0xec9(%rip),%rax
movq %rax,%xmm1
mov... | _Z5func0ii:
endbr64
push rbx
sub rsp, 10h
pxor xmm3, xmm3
cvtsi2sd xmm3, esi
movsd [rsp+18h+var_18], xmm3
pxor xmm5, xmm5
cvtsi2sd xmm5, edi
movq rbx, xmm5
movsd xmm1, cs:y; y
movapd xmm0, xmm5; x
call _pow
movsd [rsp+18h+var_10], xmm0
movsd xmm1, cs:y; y
movq xmm0, rbx; x
call _pow
mo... | long long func0(int a1, int a2)
{
double v2; // xmm0_8
double v4; // [rsp+8h] [rbp-10h]
v4 = pow((double)a1, 0.16);
v2 = pow((double)a1, 0.16);
return (unsigned int)(int)round((double)a2 * 0.6215000000000001 + 13.12 - v4 * 11.37 + (double)a2 * 0.3965 * v2);
} | func0:
ENDBR64
PUSH RBX
SUB RSP,0x10
PXOR XMM3,XMM3
CVTSI2SD XMM3,ESI
MOVSD qword ptr [RSP],XMM3
PXOR XMM5,XMM5
CVTSI2SD XMM5,EDI
MOVQ RBX,XMM5
MOVSD XMM1,qword ptr [0x00102070]
MOVAPD XMM0,XMM5
CALL 0x00101080
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD XMM1,qword ptr [0x00102070]
MOVQ XMM0,RBX
CALL 0x00101080
MOVAPD XMM2,... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int) */
int func0(int param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow((double)param_1,DAT_00102070);
dVar2 = pow((double)param_1,DAT_00102070);
dVar1 = round((((double)param_2 * _DAT_00102078... |
2,550 | func0 |
#include <cmath>
#include <cassert>
| int func0(int v, int t) {
double windchill = 13.12 + 0.6215 * t - 11.37 * std::pow(v, 0.16) + 0.3965 * t * std::pow(v, 0.16);
return static_cast<int>(std::round(windchill));
}
| int main() {
assert(func0(120, 35) == 40);
assert(func0(40, 70) == 86);
assert(func0(10, 100) == 116);
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
pxor %xmm4,%xmm4
pxor %xmm2,%xmm2
sub $0x28,%rsp
movsd 0xe40(%rip),%xmm1
cvtsi2sd %edi,%xmm4
cvtsi2sd %esi,%xmm2
movapd %xmm4,%xmm0
movsd %xmm4,0x10(%rsp)
movsd %xmm2,0x18(%rsp)
callq 1080 <pow@plt>
mov 0xe1c(%rip),%rax
movsd 0x10(%rsp),%xmm4
movsd %xmm0,0x8(%rsp)
movq %rax,%x... | _Z5func0ii:
endbr64
pxor xmm4, xmm4
pxor xmm2, xmm2
sub rsp, 28h
movsd xmm1, cs:y; y
cvtsi2sd xmm4, edi
cvtsi2sd xmm2, esi
movapd xmm0, xmm4; x
movsd [rsp+28h+x], xmm4
movsd [rsp+28h+var_10], xmm2
call _pow
movsd xmm4, [rsp+28h+x]
movsd xmm1, cs:y; y
movsd [rsp+28h+var_20], xmm0
movapd xmm0, ... | long long func0(int a1, int a2)
{
double v2; // xmm4_8
double v4; // [rsp+8h] [rbp-20h]
v4 = pow((double)a1, 0.16);
v2 = pow((double)a1, 0.16);
return (unsigned int)(int)round(0.6215000000000001 * (double)a2 + 13.12 - 11.37 * v4 + (double)a2 * 0.3965 * v2);
} | func0:
ENDBR64
PXOR XMM4,XMM4
PXOR XMM2,XMM2
SUB RSP,0x28
MOVSD XMM1,qword ptr [0x00102070]
CVTSI2SD XMM4,EDI
CVTSI2SD XMM2,ESI
MOVAPD XMM0,XMM4
MOVSD qword ptr [RSP + 0x10],XMM4
MOVSD qword ptr [RSP + 0x18],XMM2
CALL 0x00101080
MOVSD XMM4,qword ptr [RSP + 0x10]
MOVSD XMM1,qword ptr [0x00102070]
MOVSD qword ptr [RSP + ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int) */
int func0(int param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow((double)param_1,DAT_00102070);
dVar2 = pow((double)param_1,DAT_00102070);
dVar1 = round(((DAT_00102078 * (double)param_2 ... |
2,551 | func0 |
#include <cmath>
#include <cassert>
| int func0(int v, int t) {
double windchill = 13.12 + 0.6215 * t - 11.37 * std::pow(v, 0.16) + 0.3965 * t * std::pow(v, 0.16);
return static_cast<int>(std::round(windchill));
}
| int main() {
assert(func0(120, 35) == 40);
assert(func0(40, 70) == 86);
assert(func0(10, 100) == 116);
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
pxor %xmm4,%xmm4
pxor %xmm2,%xmm2
sub $0x28,%rsp
movsd 0xe40(%rip),%xmm1
cvtsi2sd %edi,%xmm4
cvtsi2sd %esi,%xmm2
movapd %xmm4,%xmm0
movsd %xmm4,0x10(%rsp)
movsd %xmm2,0x18(%rsp)
callq 1080 <pow@plt>
mov 0xe1c(%rip),%rax
movsd 0x10(%rsp),%xmm4
movsd %xmm0,0x8(%rsp)
movq %rax,%x... | _Z5func0ii:
endbr64
pxor xmm4, xmm4
pxor xmm2, xmm2
sub rsp, 28h
movsd xmm1, cs:y; y
cvtsi2sd xmm4, edi
cvtsi2sd xmm2, esi
movapd xmm0, xmm4; x
movsd [rsp+28h+x], xmm4
movsd [rsp+28h+var_10], xmm2
call _pow
movsd xmm4, [rsp+28h+x]
movsd xmm1, cs:y; y
movsd [rsp+28h+var_20], xmm0
movapd xmm0, ... | long long func0(int a1, int a2)
{
double v2; // xmm4_8
double v4; // [rsp+8h] [rbp-20h]
v4 = pow((double)a1, 0.16);
v2 = pow((double)a1, 0.16);
return (unsigned int)(int)round(0.6215000000000001 * (double)a2 + 13.12 - 11.37 * v4 + (double)a2 * 0.3965 * v2);
} | func0:
ENDBR64
PXOR XMM4,XMM4
PXOR XMM2,XMM2
SUB RSP,0x28
MOVSD XMM1,qword ptr [0x00102078]
CVTSI2SD XMM4,EDI
CVTSI2SD XMM2,ESI
MOVAPD XMM0,XMM4
MOVSD qword ptr [RSP + 0x10],XMM4
MOVSD qword ptr [RSP + 0x18],XMM2
CALL 0x00101080
MOVSD XMM4,qword ptr [RSP + 0x10]
MOVSD XMM1,qword ptr [0x00102078]
MOVSD qword ptr [RSP + ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int) */
int func0(int param_1,int param_2)
{
double dVar1;
double dVar2;
dVar1 = pow((double)param_1,DAT_00102078);
dVar2 = pow((double)param_1,DAT_00102078);
dVar1 = round(((DAT_00102080 * (double)param_2 ... |
2,552 | func0 |
#include <vector>
#include <string>
#include <cctype>
#include <numeric>
#include <cassert>
#include <algorithm>
| int func0(std::vector<std::string> sample_names) {
std::vector<std::string> filtered_names;
for (auto& name : sample_names) {
if (std::isupper(name[0]) && std::all_of(name.begin() + 1, name.end(), ::islower)) {
filtered_names.push_back(name);
}
}
std::string concatenat... | int main() {
assert(func0({"sally", "Dylan", "rebecca", "Diana", "Joanne", "keith"}) == 16);
assert(func0({"php", "res", "Python", "abcd", "Java", "aaa"}) == 10);
assert(func0({"abcd", "Python", "abba", "aba"}) == 6);
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> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xb8,%rsp
mov %rdi,-0xb8(%rbp)
mov %fs:0x28,%rax
mov %... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0B8h
mov [rbp+var_B8], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_80]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_s... | long long func0(long long a1)
{
char *v1; // rax
long long v2; // rbx
long long v3; // rax
long long v5; // rbx
long long v6; // rax
long long v8; // [rsp+10h] [rbp-B0h] BYREF
long long v9; // [rsp+18h] [rbp-A8h] BYREF
_QWORD v10[2]; // [rsp+20h] [rbp-A0h] BYREF
long long v11; // [rsp+30h] [rbp-90h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RBP + -0xb8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x80]
MOV RDI,RAX
CALL 0x00102c5c
MOV RAX,qword ptr [RBP + -0xb8]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x98]
MOV RDI,RAX
... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
int4 func0(vector param_1)
{
char cVar1;
bool bVar2;
int iVar3;
int4 uVar4;
char *pcVar5;
int8 uVar6;
int8 uVar7;
int4 in_register_0000003c;
long in_FS_OFFSET;
int8 local_b8;
int8 local_b0;
int8 local_a8;
vector<std::string... |
2,553 | func0 |
#include <vector>
#include <string>
#include <cctype>
#include <numeric>
#include <cassert>
#include <algorithm>
| int func0(std::vector<std::string> sample_names) {
std::vector<std::string> filtered_names;
for (auto& name : sample_names) {
if (std::isupper(name[0]) && std::all_of(name.begin() + 1, name.end(), ::islower)) {
filtered_names.push_back(name);
}
}
std::string concatenat... | int main() {
assert(func0({"sally", "Dylan", "rebecca", "Diana", "Joanne", "keith"}) == 16);
assert(func0({"php", "res", "Python", "abcd", "Java", "aaa"}) == 10);
assert(func0({"abcd", "Python", "abba", "aba"}) == 6);
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> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
m... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
mov [rsp+0B8h+var_A8], 0
mov [rsp+0B8h+var_A0], 0
mov [rsp+0B8h... | long long func0(char ***a1)
{
char **v1; // rbx
char **v2; // r12
char *v3; // rbp
char *v4; // r14
char *v5; // rbp
void **v6; // r13
void **v7; // rbx
char *v8; // rax
long long v9; // rcx
unsigned long long v10; // r12
unsigned long long v11; // rbp
void *v12; // r15
unsigned long long v13... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV RBX,qword ptr [RDI]
MOV R12,qword ptr [RDI + 0x8]
CMP RBX,R12
JNZ 0x00... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
ulong func0(vector param_1)
{
string *psVar1;
char *pcVar2;
ulong *puVar3;
ulong uVar4;
int iVar5;
__normal_iterator _Var6;
uint uVar7;
uint uVar8;
int4 extraout_var;
int8 uVar9;
ulong *puVar10;
ulong *puVar11;
int8 in_RCX;... |
2,554 | func0 |
#include <vector>
#include <string>
#include <cctype>
#include <numeric>
#include <cassert>
#include <algorithm>
| int func0(std::vector<std::string> sample_names) {
std::vector<std::string> filtered_names;
for (auto& name : sample_names) {
if (std::isupper(name[0]) && std::all_of(name.begin() + 1, name.end(), ::islower)) {
filtered_names.push_back(name);
}
}
std::string concatenat... | int main() {
assert(func0({"sally", "Dylan", "rebecca", "Diana", "Joanne", "keith"}) == 16);
assert(func0({"php", "res", "Python", "abcd", "Java", "aaa"}) == 10);
assert(func0({"abcd", "Python", "abba", "aba"}) == 6);
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> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov (%rdi),%rbp
mov... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r13, [rdi+8]
mov rbp, [rdi]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
movaps xmmword ... | long long func0(char ***a1)
{
char **v1; // r13
char **v2; // rbp
char *v3; // r12
char *v4; // r14
char *v5; // rbx
char *v6; // rdx
char *v7; // r15
long long v8; // rax
long long v9; // r12
char *v10; // rbx
void *v11; // rdi
void **v12; // rbp
void **v13; // r12
unsigned int v14; // r13... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R13,qword ptr [RDI + 0x8]
MOV RBP,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
CMP RBP,R13
JNZ 0x001017f5
JMP 0x0010... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::vector<std::string, std::allocator<std::string > >) */
int4 func0(vector param_1)
{
char *pcVar1;
string *psVar2;
char *pcVar3;
long lVar4;
long *plVar5;
long *plVar6;
long *plVar7;
int iVar8;
long lVar9;
char *pcVar10;
string ... |
2,555 | func0 |
#include <vector>
#include <string>
#include <cctype>
#include <numeric>
#include <cassert>
#include <algorithm>
| int func0(std::vector<std::string> sample_names) {
std::vector<std::string> filtered_names;
for (auto& name : sample_names) {
if (std::isupper(name[0]) && std::all_of(name.begin() + 1, name.end(), ::islower)) {
filtered_names.push_back(name);
}
}
std::string concatenat... | int main() {
assert(func0({"sally", "Dylan", "rebecca", "Diana", "Joanne", "keith"}) == 16);
assert(func0({"php", "res", "Python", "abcd", "Java", "aaa"}) == 10);
assert(func0({"abcd", "Python", "abba", "aba"}) == 6);
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> > > >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov rbp, [rdi]
mov r13, [rdi+8]
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
xor eax, eax
movaps [rsp+0E... | long long func0(char ***a1)
{
char **v1; // rbp
char **v2; // r13
long long *v3; // r14
char *v4; // r12
size_t v5; // r15
char *v6; // rbx
size_t v7; // rdx
long long v8; // rax
long long v9; // r12
void *v10; // rdi
char *v11; // rbx
__int8 *v12; // r15
long long *v13; // rbx
unsigned lon... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV RBP,qword ptr [RDI]
MOV R13,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV qword ptr [RSP + 0x50],0x0
CMP RBP,R13
JZ 0x00101b81
XOR ... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::vector<std::string, std::allocator<std::string > >) */
ulong func0(vector param_1)
{
ulong *puVar1;
char *pcVar2;
string *psVar3;
char *pcVar4;
int *__src;
ulong uVar5;
ulong uVar6;
int iVar7;
ulong *puVar8;
ulong uVar9;
long l... |
2,556 | func0 |
#include <regex>
#include <string>
#include <vector>
#include <cassert>
| std::string func0(const std::vector<std::string>& items) {
std::regex pattern(R"( ?\([^)]+\))");
for (const auto& item : items) {
return std::regex_replace(item, pattern, "");
}
return "";
}
| int main() {
assert(func0(std::vector<std::string>{"python (chrome)"}) == "python");
assert(func0(std::vector<std::string>{"string(.abc)"}) == "string");
assert(func0(std::vector<std::string>{"alpha(num)"}) == "alpha");
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 $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, a... | long long func0(long long a1, long long a2)
{
long long v3; // [rsp+18h] [rbp-68h] BYREF
_QWORD v4[2]; // [rsp+20h] [rbp-60h] BYREF
long long v5; // [rsp+30h] [rbp-50h]
_QWORD *v6; // [rsp+38h] [rbp-48h]
_BYTE v7[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+68h] [rbp-18h]
v8 = __read... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV EDX,0x10
LEA RCX,[0x134051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b63:
CALL 0x00106548
MOV RAX,qword ptr ... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
bool bVar1;
vector<std::string,std::allocator<std::string>> *in_RSI;
long in_FS_OFFSET;
int8 local_70;
int8 local_68;
vector<std::string,std::allocator<std::string>> *local_60;
int8 local_58;
... |
2,557 | func0 |
#include <regex>
#include <string>
#include <vector>
#include <cassert>
| std::string func0(const std::vector<std::string>& items) {
std::regex pattern(R"( ?\([^)]+\))");
for (const auto& item : items) {
return std::regex_replace(item, pattern, "");
}
return "";
}
| int main() {
assert(func0(std::vector<std::string>{"python (chrome)"}) == "python");
assert(func0(std::vector<std::string>{"string(.abc)"}) == "string");
assert(func0(std::vector<std::string>{"alpha(num)"}) == "alpha");
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 %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov ... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
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]... | long long func0(long long a1, long long *a2)
{
long long v3; // rax
char *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] [r... | 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::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 *puVar2;
_Sp_counted_base<(_Lock_policy)2> *p_Var3;
int iVar4;
long *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int8 loc... |
2,558 | func0 |
#include <regex>
#include <string>
#include <vector>
#include <cassert>
| std::string func0(const std::vector<std::string>& items) {
std::regex pattern(R"( ?\([^)]+\))");
for (const auto& item : items) {
return std::regex_replace(item, pattern, "");
}
return "";
}
| int main() {
assert(func0(std::vector<std::string>{"python (chrome)"}) == "python");
assert(func0(std::vector<std::string>{"string(.abc)"}) == "string");
assert(func0(std::vector<std::string>{"alpha(num)"}) == "alpha");
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 %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x4... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
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 ... | long long func0(long long a1, char ***a2)
{
char *v4; // rsi
char **v5; // rax
long long v6; // rdi
long long v7; // rdx
volatile signed __int32 *v8; // rcx
signed __int32 v9; // eax
long long v11; // rax
_BYTE v12[8]; // [rsp+0h] [rbp-50h] BYREF
_BYTE v13[8]; // [rsp+8h] [rbp-48h] BYREF
__int128 v... | 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 0x001036f0
LEA RDX,[0x11969e]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 *puVar2;
int8 uVar3;
int iVar4;
long *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int local_48 [24];
long local_30;
... |
2,559 | func0 |
#include <regex>
#include <string>
#include <vector>
#include <cassert>
| std::string func0(const std::vector<std::string>& items) {
std::regex pattern(R"( ?\([^)]+\))");
for (const auto& item : items) {
return std::regex_replace(item, pattern, "");
}
return "";
}
| int main() {
assert(func0(std::vector<std::string>{"python (chrome)"}) == "python");
assert(func0(std::vector<std::string>{"string(.abc)"}) == "string");
assert(func0(std::vector<std::string>{"alpha(num)"}) == "alpha");
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 %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x4... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
push r15
mov r15, rsi
push r14
lea r14, [rbp+var_E0]
push r13
push r12
push rbx
mov rbx, rdi
sub rsp, 108h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
... | _QWORD * func0(_QWORD *a1, long long a2)
{
unsigned long long v4; // rsi
char **v5; // rax
char *v6; // rdi
long long v7; // r13
char *v8; // r15
char v9; // al
long long v10; // rdx
long long v11; // rcx
long long v12; // r8
long long v13; // r9
long long v14; // rax
char *v15; // r15
char *v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
MOV R15,RSI
PUSH R14
LEA R14,[RBP + -0xe0]
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
SUB RSP,0x108
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xd8]
MOV qword ptr [RBP + -0x130],R14
MOV RDI,RAX
MOV qword ptr [RBP + -0x128],RAX
CALL 0x... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
vector vVar2;
vector *pvVar3;
long lVar4;
int8 uVar5;
bool bVar6;
char cVar7;
int iVar8;
int8 *puVar9;
vector *pvVar10;
long lVar11;
long *pl... |
2,560 | func0 |
#include <cassert>
| int func0(int n) {
return static_cast<int>(n * (7 * n - 5) / 2);
}
| int main() {
assert(func0(10) == 325);
assert(func0(15) == 750);
assert(func0(18) == 1089);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%edx
mov %edx,%eax
shl $0x3,%eax
sub %edx,%eax
sub $0x5,%eax
imul -0x4(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov edx, [rbp+var_4]
mov eax, edx
shl eax, 3
sub eax, edx
sub eax, 5
imul eax, [rbp+var_4]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (7 * a1 - 5) / 2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,EDX
SHL EAX,0x3
SUB EAX,EDX
SUB EAX,0x5
IMUL EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 * 7 + -5) * param_1) / 2;
} |
2,561 | func0 |
#include <cassert>
| int func0(int n) {
return static_cast<int>(n * (7 * n - 5) / 2);
}
| int main() {
assert(func0(10) == 325);
assert(func0(15) == 750);
assert(func0(18) == 1089);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov %edi,%eax
lea 0x0(,%rdi,8),%edi
mov %edi,%edx
sub %eax,%edx
lea -0x5(%rdx),%edi
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
| _Z5func0i:
endbr64
mov eax, edi
lea edi, ds:0[rdi*8]
sub edi, eax
sub edi, 5
imul edi, eax
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (7 * a1 - 5) / 2);
} | func0:
ENDBR64
MOV EAX,EDI
LEA EDI,[RDI*0x8]
SUB EDI,EAX
SUB EDI,0x5
IMUL EDI,EAX
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 * 7 + -5) * param_1) / 2;
} |
2,562 | func0 |
#include <cassert>
| int func0(int n) {
return static_cast<int>(n * (7 * n - 5) / 2);
}
| int main() {
assert(func0(10) == 325);
assert(func0(15) == 750);
assert(func0(18) == 1089);
return 0;
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%eax
lea 0x0(,%rdi,8),%edi
mov %edi,%edx
sub %eax,%edx
lea -0x5(%rdx),%edi
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
mov eax, edi
lea edi, ds:0[rdi*8]
sub edi, eax
sub edi, 5
imul edi, eax
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (7 * a1 - 5) / 2);
} | func0:
ENDBR64
MOV EAX,EDI
LEA EDI,[RDI*0x8]
SUB EDI,EAX
SUB EDI,0x5
IMUL EDI,EAX
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 * 7 + -5) * param_1) / 2;
} |
2,563 | func0 |
#include <cassert>
| int func0(int n) {
return static_cast<int>(n * (7 * n - 5) / 2);
}
| int main() {
assert(func0(10) == 325);
assert(func0(15) == 750);
assert(func0(18) == 1089);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%eax
lea 0x0(,%rdi,8),%edi
mov %edi,%edx
sub %eax,%edx
lea -0x5(%rdx),%edi
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
mov eax, edi
lea edi, ds:0[rdi*8]
sub edi, eax
sub edi, 5
imul edi, eax
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (7 * a1 - 5) / 2);
} | func0:
ENDBR64
MOV EAX,EDI
LEA EDI,[RDI*0x8]
SUB EDI,EAX
SUB EDI,0x5
IMUL EDI,EAX
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 * 7 + -5) * param_1) / 2;
} |
2,564 | func0 |
#include <cassert>
#include <vector>
#include <set>
#include <algorithm>
| std::set<std::vector<std::pair<int, int>>> func0(const std::vector<std::vector<std::pair<int, int>>> &test_list) {
std::set<std::vector<std::pair<int, int>>> res;
for(auto sub : test_list){
std::set<std::pair<int,int>> sub_set(sub.begin(), sub.end());
std::vector<std::pair<int,int>> sorted_s... | int main(){
std::set<std::vector<std::pair<int,int>>> expected1 = { { {2,2}, {4,6} }, { {3,2}, {4,5} } };
assert(func0({ { {4,5}, {3,2} }, { {2,2}, {4,6} }, { {3,2}, {4,5} } }) == expected1);
std::set<std::vector<std::pair<int,int>>> expected2 = { { {4,3}, {5,6} }, { {3,3}, {5,7} } };
assert(func0... | O0 | cpp | func0(std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >, std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xb8,%rsp
mov %rdi,-0xb8(%rbp)
mov %rsi,-0xc0(%rbp)
mov %fs:0x2... | _Z5func0RKSt6vectorIS_ISt4pairIiiESaIS1_EESaIS3_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0C8h
mov [rbp+var_C8], rdi
mov [rbp+var_D0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_C8]
mov rdi, rax
call _ZNSt3setISt6vectorISt4pairIiiESaIS... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rbx
long long v4; // rax
long long v5; // rbx
long long v6; // rax
char v8; // [rsp+1Fh] [rbp-B1h] BYREF
long long v9; // [rsp+20h] [rbp-B0h] BYREF
_QWORD v10[3]; // [rsp+28h] [rbp-A8h] BYREF
_BYTE v11[32]; // [rsp+40... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RBP + -0xc8],RDI
MOV qword ptr [RBP + -0xd0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0xc8]
MOV RDI,RAX
CALL 0x00102906
MOV RAX,qword ptr [RBP + -0xd0]
MOV qword ptr [RBP + -0xa0],RAX
MO... | /* func0(std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >,
std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > > >
const&) */
vector * func0(vector *param_1)
{
bool bVar1;
_Rb_tree_const_iterator _Var2;
_Rb_tree_const_iterator _Var3;
... |
2,565 | func0 |
#include <cassert>
#include <vector>
#include <set>
#include <algorithm>
| std::set<std::vector<std::pair<int, int>>> func0(const std::vector<std::vector<std::pair<int, int>>> &test_list) {
std::set<std::vector<std::pair<int, int>>> res;
for(auto sub : test_list){
std::set<std::pair<int,int>> sub_set(sub.begin(), sub.end());
std::vector<std::pair<int,int>> sorted_s... | int main(){
std::set<std::vector<std::pair<int,int>>> expected1 = { { {2,2}, {4,6} }, { {3,2}, {4,5} } };
assert(func0({ { {4,5}, {3,2} }, { {2,2}, {4,6} }, { {3,2}, {4,5} } }) == expected1);
std::set<std::vector<std::pair<int,int>>> expected2 = { { {4,3}, {5,6} }, { {3,3}, {5,7} } };
assert(func0... | O1 | cpp | func0(std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >, std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %rdi,0x10(%rsp)
mov %... | _Z5func0RKSt6vectorIS_ISt4pairIiiESaIS1_EESaIS3_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0C8h
mov [rsp+0F8h+var_D8], rdi
mov rax, fs:28h
mov [rsp+0F8h+var_40], rax
xor eax, eax
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
lea rax... | long long func0(long long a1, long long **a2)
{
struct _Unwind_Exception *v2; // rbx
long long v3; // r13
long long v4; // rcx
long long v5; // r13
unsigned long long v6; // rax
char *v7; // r13
char *v8; // rbp
char *v9; // r14
int v10; // eax
long long insert_hint_unique_pos; // rax
int *v12; /... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RDI + 0x8]
MOV qword ptr [RDI + 0x18],RAX
MOV qword ptr [RDI + 0x2... | /* func0(std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >,
std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > > >
const&) */
vector * func0(vector *param_1)
{
_Rb_tree_node_base *p_Var1;
long *plVar2;
long lVar3;
long lVar4;
_Rb_tr... |
2,566 | func0 |
#include <cassert>
#include <vector>
#include <set>
#include <algorithm>
| std::set<std::vector<std::pair<int, int>>> func0(const std::vector<std::vector<std::pair<int, int>>> &test_list) {
std::set<std::vector<std::pair<int, int>>> res;
for(auto sub : test_list){
std::set<std::pair<int,int>> sub_set(sub.begin(), sub.end());
std::vector<std::pair<int,int>> sorted_s... | int main(){
std::set<std::vector<std::pair<int,int>>> expected1 = { { {2,2}, {4,6} }, { {3,2}, {4,5} } };
assert(func0({ { {4,5}, {3,2} }, { {2,2}, {4,6} }, { {3,2}, {4,5} } }) == expected1);
std::set<std::vector<std::pair<int,int>>> expected2 = { { {4,3}, {5,6} }, { {3,3}, {5,7} } };
assert(func0... | O2 | cpp | func0(std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >, std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov (%rsi),%r14
mov %rdi,... | _Z5func0RKSt6vectorIS_ISt4pairIiiESaIS1_EESaIS3_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov r15, [rsi]
mov [rsp+0E8h+var_C8], rdi
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
xor eax, eax
lea rax, [rdi+8]
mov dword ptr [rdi+8], 0
mo... | long long func0(long long a1, long long **a2)
{
long long *v2; // r15
long long *v3; // rax
long long v4; // rdx
long long v5; // rcx
signed long long v6; // rax
_DWORD *v7; // rax
_DWORD *v8; // r14
long long v9; // rdx
unsigned long long v10; // rbx
_DWORD *v11; // rbx
_DWORD *v12; // r12
lon... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV R15,qword ptr [RSI]
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x8]
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x18],RAX
MOV qword ptr [RDI + 0x20],RAX
... | /* WARNING: Removing unreachable block (ram,0x00102263) */
/* WARNING: Removing unreachable block (ram,0x00102270) */
/* WARNING: Removing unreachable block (ram,0x00102281) */
/* WARNING: Removing unreachable block (ram,0x00102459) */
/* WARNING: Removing unreachable block (ram,0x0010246c) */
/* WARNING: Removing unre... |
2,567 | func0 |
#include <cassert>
#include <vector>
#include <set>
#include <algorithm>
| std::set<std::vector<std::pair<int, int>>> func0(const std::vector<std::vector<std::pair<int, int>>> &test_list) {
std::set<std::vector<std::pair<int, int>>> res;
for(auto sub : test_list){
std::set<std::pair<int,int>> sub_set(sub.begin(), sub.end());
std::vector<std::pair<int,int>> sorted_s... | int main(){
std::set<std::vector<std::pair<int,int>>> expected1 = { { {2,2}, {4,6} }, { {3,2}, {4,5} } };
assert(func0({ { {4,5}, {3,2} }, { {2,2}, {4,6} }, { {3,2}, {4,5} } }) == expected1);
std::set<std::vector<std::pair<int,int>>> expected2 = { { {4,3}, {5,6} }, { {3,3}, {5,7} } };
assert(func0... | O3 | cpp | func0(std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >, std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > > > const&):
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov (%rsi),... | _Z5func0RKSt6vectorIS_ISt4pairIiiESaIS1_EESaIS3_EE:
endbr64
push r15
lea rcx, [rdi+8]
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0C8h
mov [rsp+0F8h+var_D8], rdi
mov rax, fs:28h
mov [rsp+0F8h+var_40], rax
xor eax, eax
mov [rsp+0F8h+var_D0], rcx
mov rax, [rsi+8... | long long func0(long long a1, long long **a2)
{
size_t v2; // rbp
size_t v3; // r12
long long v4; // r14
signed int *v5; // r15
long long *v6; // rax
long long *v7; // rcx
long long v8; // rcx
long long v9; // rsi
signed long long v10; // rax
long long v11; // rcx
unsigned long long v12; // rax
... | func0:
ENDBR64
PUSH R15
LEA RCX,[RDI + 0x8]
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x28],RCX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x2... | /* func0(std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >,
std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > > >
const&) */
vector * func0(vector *param_1)
{
_Rb_tree_node_base *p_Var1;
long *plVar2;
long *plVar3;
void *pvVar4;
in... |
2,568 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& text) {
std::regex patterns("\\Bz\\B");
if(std::regex_search(text, patterns))
return "Found a match!";
else
return "Not matched!";
}
| int main() {
assert(func0("pythonzabc.") == "Found a match!");
assert(func0("xyzabc.") == "Found a match!");
assert(func0(" lang .") == "Not matched!");
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov $0x10,%edx
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, aBzB; "\\Bz\\B"
mov... | long long func0(long long a1, long long a2)
{
char v3; // [rsp+1Fh] [rbp-51h] BYREF
char *v4; // [rsp+20h] [rbp-50h]
char *v5; // [rsp+28h] [rbp-48h]
_BYTE v6[40]; // [rsp+30h] [rbp-40h] BYREF
unsigned long long v7; // [rsp+58h] [rbp-18h]
v7 = __readfsqword(0x28u);
std::basic_regex<char,std::regex_trait... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV EDX,0x10
LEA RCX,[0x132051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b43:
CALL 0x001061ba
LEA RCX,[RBP + -0x... | /* func0(std::string const&) */
string * func0(string *param_1)
{
bool bVar1;
string *in_RSI;
long in_FS_OFFSET;
allocator local_59;
allocator *local_58;
allocator *local_50;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_48,"\\Bz\\B... |
2,569 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& text) {
std::regex patterns("\\Bz\\B");
if(std::regex_search(text, patterns))
return "Found a match!";
else
return "Not matched!";
}
| int main() {
assert(func0("pythonzabc.") == "Found a match!");
assert(func0("xyzabc.") == "Found a match!");
assert(func0(" lang .") == "Not matched!");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
mov %r13,%rdi
callq 4730 <_ZN... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea r12, [rbp+var_70]
lea rdi, [rbp+var_68]; this
call __Z... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x70]
LEA RDI,[RBP + -0x68]
CALL 0x001046f0
MOV qword ptr [RBP + -0x60],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV ECX,0x10
LEA RDX,[0x... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
bool bVar3;
int iVar4;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_78 [8];
int local_70 [8];
int8 local_68;
_Sp_counted_base<(_Lock_policy)2> *lo... | |
2,570 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& text) {
std::regex patterns("\\Bz\\B");
if(std::regex_search(text, patterns))
return "Found a match!";
else
return "Not matched!";
}
| int main() {
assert(func0("pythonzabc.") == "Found a match!");
assert(func0("xyzabc.") == "Found a match!");
assert(func0(" lang .") == "Not matched!");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
lea 0x8(%rsp),%rbp... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
mov r14, rsi
push r13
lea r13, [rbp+var_70]
push r12
lea r12, [rbp+var_68]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_28], rax... | long long func0(long long a1, long long *a2)
{
long long v3; // rdi
long long v4; // rsi
long long v5; // rsi
char v6; // r13
long long v7; // rdi
long long v8; // rdx
volatile signed __int32 *v9; // rcx
signed __int32 v10; // eax
long long v12; // rax
_BYTE v13[8]; // [rsp+0h] [rbp-70h] BYREF
_B... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
MOV R14,RSI
PUSH R13
LEA R13,[RBP + -0x70]
PUSH R12
LEA R12,[RBP + -0x68]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001036d0
LEA RDX,[0x11865c]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
bool bVar3;
int iVar4;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_78 [8];
int local_70 [8];
int local_68 [16];
int local_58 [16];
int local_48 [16];
long local_30;
lo... |
2,571 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& text) {
std::regex patterns("\\Bz\\B");
if(std::regex_search(text, patterns))
return "Found a match!";
else
return "Not matched!";
}
| int main() {
assert(func0("pythonzabc.") == "Found a match!");
assert(func0("xyzabc.") == "Found a match!");
assert(func0(" lang .") == "Not matched!");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
lea 0x8(%rsp),%rbp... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
mov r15, rsi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 2B8h
mov rax, fs:28h
mov [rsp+2E8h+var_40], rax
xor eax, eax
lea r14, [rsp+2E8h+var_2A0]
mov rdi, r14; this
c... | long long func0(long long a1, unsigned long long *a2)
{
__m128i v3; // xmm0
long long v4; // rdi
void *v5; // rdi
void **v6; // rbp
unsigned long long v7; // r12
void *v8; // rdi
unsigned long long v9; // r13
unsigned long long v10; // rbp
long long v11; // rax
long long v12; // rcx
unsigned long... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x2b8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x2a8],RAX
XOR EAX,EAX
LEA R14,[RSP + 0x48]
MOV RDI,R14
CALL 0x00104730
LEA RDX,[0x11a6a1]
PXOR XMM0,XMM0
LEA RDI,[RSP + 0x110]
MOV R8D,0x10
MOV RCX,R14
LEA RSI,[RD... | /* func0(std::string const&) */
string * func0(string *param_1)
{
ulong uVar1;
int8 uVar2;
ulong uVar3;
int auVar4 [16];
bool bVar5;
char cVar6;
long lVar7;
int8 *puVar8;
int8 *puVar9;
ulong uVar10;
ulong *puVar11;
long lVar12;
ulong uVar13;
ulong *in_RSI;
uint *puVar14;
_Match_mode _V... |
2,572 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<int> func0(std::vector<int> input, int k) {
std::reverse(input.begin(), input.begin() + k);
return input;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6}, 4) == std::vector<int>{4, 3, 2, 1, 5, 6}));
assert((func0({4, 5, 6, 7}, 2) == std::vector<int>{5, 4, 6, 7}));
assert((func0({9, 8, 7, 6, 5}, 3) == std::vector<int>{7, 8, 9, 6, 5}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %edx,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x34(%rbp),%eax
movslq %eax,%rbx
mov -0x30(%rbp),%rax
mo... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_34], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_34]
movsxd rbx, eax
mov rax, [rbp+var_30]
mov rdi, rax... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rbx
long long v4; // rbx
long long v5; // rax
_QWORD v7[3]; // [rsp+20h] [rbp-20h] BYREF
v7[1] = __readfsqword(0x28u);
v3 = a3;
v7[0] = std::vector<int>::begin(a2);
v4 = __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operato... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x34],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CAL... | /* func0(std::vector<int, std::allocator<int> >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
int in_EDX;
int4 in_register_00000034;
vector<int,std::allocator<int>> *this;
int4 in_register_0000003c;
long in_FS_OFFSET;
i... |
2,573 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<int> func0(std::vector<int> input, int k) {
std::reverse(input.begin(), input.begin() + k);
return input;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6}, 4) == std::vector<int>{4, 3, 2, 1, 5, 6}));
assert((func0({4, 5, 6, 7}, 2) == std::vector<int>{5, 4, 6, 7}));
assert((func0({9, 8, 7, 6, 5}, 3) == std::vector<int>{7, 8, 9, 6, 5}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov %rdi,%rax
mov (%rsi),%rcx
movslq %edx,%rdx
lea (%rcx,%rdx,4),%rdx
cmp %rcx,%rdx
je 125f <_Z5func0St6vectorIiSaIiEEi+0x36>
sub $0x4,%rdx
cmp %rdx,%rcx
jae 125f <_Z5func0St6vectorIiSaIiEEi+0x36>
mov (%rcx),%edi
mov (%rdx),%r8d
... | _Z5func0St6vectorIiSaIiEEi:
endbr64
mov eax, edx
mov rdx, [rsi]
cdqe
lea rax, [rdx+rax*4]
cmp rax, rdx
jz short loc_125D
sub rax, 4
cmp rdx, rax
jnb short loc_125D
loc_1246:
mov ecx, [rdx]
mov r8d, [rax]
mov [rdx], r8d
mov [rax], ecx
sub rax, 4
add rdx, 4
cmp ... | int ** func0(int **a1, int **a2, int a3)
{
int *v4; // rdx
long long v5; // rax
int *i; // rax
int v7; // ecx
v4 = *a2;
v5 = (long long)&(*a2)[a3];
if ( (int *)v5 != *a2 )
{
for ( i = (int *)(v5 - 4); v4 < i; ++v4 )
{
v7 = *v4;
*v4 = *i;
*i-- = v7;
}
}
*a1 = *a2;
a1[... | func0:
ENDBR64
MOV EAX,EDX
MOV RDX,qword ptr [RSI]
CDQE
LEA RAX,[RDX + RAX*0x4]
CMP RAX,RDX
JZ 0x0010125d
SUB RAX,0x4
CMP RDX,RAX
JNC 0x0010125d
LAB_00101246:
MOV ECX,dword ptr [RDX]
MOV R8D,dword ptr [RAX]
MOV dword ptr [RDX],R8D
MOV dword ptr [RAX],ECX
SUB RAX,0x4
ADD RDX,0x4
CMP RDX,RAX
JC 0x00101246
LAB_0010125d:
M... | /* func0(std::vector<int, std::allocator<int> >, int) */
int8 func0(vector param_1,int param_2)
{
int4 uVar1;
int4 *puVar2;
int in_EDX;
int4 *puVar3;
int4 in_register_00000034;
int4 in_register_0000003c;
puVar3 = *(int4 **)CONCAT44(in_register_00000034,param_2);
if ((puVar3 + in_EDX != puVar3) && (... |
2,574 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<int> func0(std::vector<int> input, int k) {
std::reverse(input.begin(), input.begin() + k);
return input;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6}, 4) == std::vector<int>{4, 3, 2, 1, 5, 6}));
assert((func0({4, 5, 6, 7}, 2) == std::vector<int>{5, 4, 6, 7}));
assert((func0({9, 8, 7, 6, 5}, 3) == std::vector<int>{7, 8, 9, 6, 5}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov %rdi,%rax
mov (%rsi),%rdi
movslq %edx,%rdx
lea (%rdi,%rdx,4),%rdx
cmp %rdi,%rdx
je 16c3 <_Z5func0St6vectorIiSaIiEEi+0x43>
sub $0x4,%rdx
cmp %rdi,%rdx
jbe 16c3 <_Z5func0St6vectorIiSaIiEEi+0x43>
mov %rdi,%rcx
nopw 0x0(%rax,%rax,... | _Z5func0St6vectorIiSaIiEEi:
endbr64
mov r10, [rsi]
movsxd rdx, edx
mov rax, rdi
lea rdx, [r10+rdx*4]
cmp rdx, r10
jz short loc_15C3
sub rdx, 4
cmp r10, rdx
jnb short loc_15C3
mov rcx, r10
nop word ptr [rax+rax+00h]
loc_15A8:
mov r8d, [rcx]
mov r9d, [rdx]
add rcx, 4
... | __m128 * func0(__m128 *a1, long long a2, int a3)
{
__m128 *result; // rax
long long v4; // rdx
int *v5; // rdx
int *v6; // rcx
int v7; // r8d
int v8; // r9d
unsigned long long v9; // rdx
result = a1;
v4 = *(_QWORD *)a2 + 4LL * a3;
if ( v4 != *(_QWORD *)a2 )
{
v5 = (int *)(v4 - 4);
if ( *(... | func0:
ENDBR64
MOV R10,qword ptr [RSI]
MOVSXD RDX,EDX
MOV RAX,RDI
LEA RDX,[R10 + RDX*0x4]
CMP RDX,R10
JZ 0x001015c3
SUB RDX,0x4
CMP R10,RDX
JNC 0x001015c3
MOV RCX,R10
NOP word ptr [RAX + RAX*0x1]
LAB_001015a8:
MOV R8D,dword ptr [RCX]
MOV R9D,dword ptr [RDX]
ADD RCX,0x4
SUB RDX,0x4
MOV dword ptr [RCX + -0x4],R9D
MOV dwo... | /* func0(std::vector<int, std::allocator<int> >, int) */
void func0(int8 *param_1,int (*param_2) [16],int param_3)
{
int8 uVar1;
int4 uVar2;
int4 *puVar3;
int8 uVar4;
int4 *puVar5;
int4 *puVar6;
int4 *puVar7;
int4 *puVar8;
puVar3 = *(int4 **)*param_2;
if ((puVar3 + param_3 != puVar3) &&
(p... |
2,575 | func0 |
#include <vector>
#include <algorithm>
#include <assert.h>
| std::vector<int> func0(std::vector<int> input, int k) {
std::reverse(input.begin(), input.begin() + k);
return input;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6}, 4) == std::vector<int>{4, 3, 2, 1, 5, 6}));
assert((func0({4, 5, 6, 7}, 2) == std::vector<int>{5, 4, 6, 7}));
assert((func0({9, 8, 7, 6, 5}, 3) == std::vector<int>{7, 8, 9, 6, 5}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov %rdi,%rax
movslq %edx,%rcx
mov (%rsi),%rdi
push %rbx
shl $0x2,%rcx
lea (%rdi,%rcx,1),%r8
cmp %rdi,%r8
je 16ec <_Z5func0St6vectorIiSaIiEEi+0x11c>
lea -0x4(%r8),%r9
cmp %rdi,%r9
jbe 16ec <_Z5func0St6vectorIiSaIiEEi+0x11c>
sub ... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbx
mov r9, rdi
movsxd rdx, edx
mov rdi, rsi
mov rsi, [rsi]
shl rdx, 2
lea rax, [rsi+rdx]
cmp rax, rsi
jz short loc_1669
sub rax, 4
cmp rsi, rax
jnb short loc_1669
lea rcx, [rdx-5]
cmp rcx, 7
jbe short loc_1649
mov rbx... | __m128 * func0(__m128 *a1, long long a2, int a3)
{
__m128i *v5; // rsi
long long v6; // rdx
__m128i *v7; // rax
unsigned long long v8; // rcx
unsigned long long v9; // rbx
unsigned long long v10; // r10
__m128i *v11; // rdx
__int32 v12; // ecx
__int32 v13; // r8d
unsigned long long v14; // rax
__m... | func0:
ENDBR64
PUSH RBX
MOV R9,RDI
MOVSXD RDX,EDX
MOV RDI,RSI
MOV RSI,qword ptr [RSI]
SHL RDX,0x2
LEA RAX,[RSI + RDX*0x1]
CMP RAX,RSI
JZ 0x00101669
SUB RAX,0x4
CMP RSI,RAX
JNC 0x00101669
LEA RCX,[RDX + -0x5]
CMP RCX,0x7
JBE 0x00101649
MOV RBX,RCX
SHR RBX,0x3
MOV R8,RBX
LEA R10,[RBX + 0x1]
NEG R8
LEA R11,[R10*0x4]
LEA R... | /* func0(std::vector<int, std::allocator<int> >, int) */
int8 * func0(int8 *param_1,int (*param_2) [16],int param_3)
{
long lVar1;
int8 uVar2;
int4 uVar3;
int4 *puVar4;
int8 uVar5;
int4 uVar6;
int4 uVar7;
int4 uVar8;
int4 uVar9;
int4 uVar10;
int4 uVar11;
int4 *puVar12;
int4 *puVar13;
long ... |
2,576 | func0 | #include <vector>
#include <assert.h>
int get_product(const std::vector<int>& val) {
int res = 1;
for (int ele : val) {
res *= ele;
}
return res;
}
| int func0(const std::vector<std::vector<int>>& test_list, int K) {
std::vector<int> extract;
for (const auto& sub : test_list) {
extract.push_back(sub[K]);
}
int res = get_product(extract);
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 665);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 280);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 0) == 210);
return 0;
}
| O0 | cpp | func0(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 %rbx
sub $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %esi,-0x6c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x30(... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov [rbp+var_6C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vec... | long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int product; // ebx
long long v5; // [rsp+20h] [rbp-50h] BYREF
_QWORD v6[2]; // [rsp+28h] [rbp-48h] BYREF
long long v7; // [rsp+38h] [rbp-38h]
_BYTE v8[24]; // [rsp+40h] [rbp-30h] BYREF
unsigned long long v9; // [rsp+58h] [rbp-18h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV dword ptr [RBP + -0x6c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00101e5c
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qwor... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int) */
int4 func0(vector *param_1,int param_2)
{
bool bVar1;
int4 uVar2;
int *piVar3;
long in_FS_OFFSET;
int8 local_58;
int8 local_50;
vector<std::vector<int,std::allocator<... |
2,577 | func0 | #include <vector>
#include <assert.h>
int get_product(const std::vector<int>& val) {
int res = 1;
for (int ele : val) {
res *= ele;
}
return res;
}
| int func0(const std::vector<std::vector<int>>& test_list, int K) {
std::vector<int> extract;
for (const auto& sub : test_list) {
extract.push_back(sub[K]);
}
int res = get_product(extract);
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 665);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 280);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 0) == 210);
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov [rsp+48h+var_48], 0
mov [rsp+48h+var_40], 0
mov [rsp+48h+var_38], 0
mov rbx, [rdi]
mov r12, [rdi+8]
cmp rbx, r1... | long long func0(long long a1, int a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r12
long long v4; // rbp
_DWORD *v5; // rdx
char *v6; // rsi
unsigned int product; // ebx
void *v9; // [rsp+0h] [rbp-48h] BYREF
char *v10; // [rsp+8h] [rbp-40h]
char *v11; // [rsp+10h] [rbp-38h]
unsigned long long v12; // [rs... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV RBX,qword ptr [RDI]
MOV R12,qword ptr [RDI + 0x8]
CMP RBX,R12
JZ 0x001013c7
MOVSXD RSI,ESI
LEA R... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int) */
int4 func0(vector *param_1,int param_2)
{
long *plVar1;
int4 uVar2;
int *piVar3;
long *plVar4;
long in_FS_OFFSET;
void *local_48;
int *local_40;
int *local_38;
lo... |
2,578 | func0 | #include <vector>
#include <assert.h>
int get_product(const std::vector<int>& val) {
int res = 1;
for (int ele : val) {
res *= ele;
}
return res;
}
| int func0(const std::vector<std::vector<int>>& test_list, int K) {
std::vector<int> extract;
for (const auto& sub : test_list) {
extract.push_back(sub[K]);
}
int res = get_product(extract);
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 665);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 280);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 0) == 210);
return 0;
}
| O2 | cpp | func0(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 $0x28,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%r13
cmp %r13,%rbx
je 1950 <_Z5func0RKSt6vectorIS... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
push rbx
sub rsp, 28h
mov rbx, [rdi]
mov r12, [rdi+8]
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
movaps xmmword ptr [rsp+48h+var_48], xmm0
mov [rsp+48h+var_38], 0
cmp r... | long long func0(long long a1, int a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r12
char *v4; // rdi
long long v5; // rbp
char *v6; // rsi
_DWORD *v7; // rdx
char *v8; // rax
unsigned int v9; // ebx
int v10; // ebx
void *v12[2]; // [rsp+0h] [rbp-48h] BYREF
char *v13; // [rsp+10h] [rbp-38h]
unsigned l... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBX,qword ptr [RDI]
MOV R12,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
CMP RBX,R12
JZ 0x001019c0
MOVSXD RSI,ESI
XOR EDI,EDI
MO... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int) */
int func0(vector *param_1,int param_2)
{
long *plVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int iVar5;
long *plVar6;
int *piVar7;
long in_FS_OFFSET;
int *local_... |
2,579 | func0 | #include <vector>
#include <assert.h>
int get_product(const std::vector<int>& val) {
int res = 1;
for (int ele : val) {
res *= ele;
}
return res;
}
| int func0(const std::vector<std::vector<int>>& test_list, int K) {
std::vector<int> extract;
for (const auto& sub : test_list) {
extract.push_back(sub[K]);
}
int res = get_product(extract);
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 665);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 280);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 0) == 210);
return 0;
}
| O3 | cpp | func0(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 $0x28,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%r14
cmp %r14,%rbx
je 1b50 <_Z5func0RKSt6vectorIS... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rbx, [rdi]
mov r15, [rdi+8]
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
movaps [rsp+78h+var_58], xmm0
mov [rsp+78h+var_48],... | long long func0(long long a1, int a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r15
__m128i *v4; // r14
__m128i *v5; // rbp
long long v6; // rcx
_DWORD *v7; // r12
unsigned long long v8; // rax
unsigned long long v9; // rdx
char *v10; // r9
__m128i *v11; // r8
const __m128i *v12; // rax
unsigned long... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RBX,qword ptr [RDI]
MOV R15,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x30],0x0
CMP RBX,R15
JZ 0x00101c88
MOVS... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int) */
ulong func0(vector *param_1,int param_2)
{
long *plVar1;
long lVar2;
size_t __n;
ulong ... |
2,580 | func0 |
#include <cmath>
#include <cassert>
| int func0(int N, int K) {
int No = 0;
No = (N - K + 1);
No = pow(No, 3);
return No;
}
| int main() {
assert(func0(2, 1) == 8);
assert(func0(5, 2) == 64);
assert(func0(1, 1) == 1);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x14(%rbp),%eax
sub -0x18(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm0
movsd 0xef5(%rip),%xmm1
callq 1060 <pow@plt>
cvttsd2si %xmm0... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_4], 0
mov eax, [rbp+var_14]
sub eax, [rbp+var_18]
add eax, 1
mov [rbp+var_4], eax
pxor xmm2, xmm2
cvtsi2sd xmm2, [rbp+var_4]
movq rax, xmm2
movsd xmm0, cs:y
mova... | long long func0(int a1, int a2)
{
return (unsigned int)(int)pow((double)(a1 - a2 + 1), 3.0);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x4],0x0
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
PXOR XMM2,XMM2
CVTSI2SD XMM2,dword ptr [RBP + -0x4]
MOVQ RAX,XMM2
MOV... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
double dVar1;
dVar1 = pow((double)((param_1 - param_2) + 1),DAT_00102070);
return (int)dVar1;
} |
2,581 | func0 |
#include <cmath>
#include <cassert>
| int func0(int N, int K) {
int No = 0;
No = (N - K + 1);
No = pow(No, 3);
return No;
}
| int main() {
assert(func0(2, 1) == 8);
assert(func0(5, 2) == 64);
assert(func0(1, 1) == 1);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
sub $0x8,%rsp
sub %esi,%edi
add $0x1,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movsd 0xf0a(%rip),%xmm1
callq 1060 <pow@plt>
cvttsd2si %xmm0,%eax
add $0x8,%rsp
retq
| _Z5func0ii:
endbr64
sub rsp, 8
sub edi, esi
add edi, 1
pxor xmm0, xmm0
cvtsi2sd xmm0, edi; x
movsd xmm1, cs:y; y
call _pow
cvttsd2si eax, xmm0
add rsp, 8
retn | long long func0(int a1, int a2)
{
return (unsigned int)(int)pow((double)(a1 - a2 + 1), 3.0);
} | func0:
ENDBR64
SUB RSP,0x8
SUB EDI,ESI
ADD EDI,0x1
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MOVSD XMM1,qword ptr [0x00102068]
CALL 0x00101060
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
double dVar1;
dVar1 = pow((double)((param_1 - param_2) + 1),DAT_00102068);
return (int)dVar1;
} |
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.