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,382 | func0 |
#include <tuple>
#include <cassert>
template <typename T>
| size_t func0(const T& t) {
return sizeof(t);
}
| int main() {
assert(func0(std::make_tuple("A", 1, "B", 2, "C", 3)) == sizeof(std::make_tuple("A", 1, "B", 2, "C", 3)));
assert(func0(std::make_tuple(1, "Raju", 2, "Nikhil", 3, "Deepanshu")) == sizeof(std::make_tuple(1, "Raju", 2, "Nikhil", 3, "Deepanshu")));
assert(func0(std::make_tuple(std::make_tuple(1... | O2 | cpp | |||||
2,383 | func0 |
#include <tuple>
#include <cassert>
template <typename T>
| size_t func0(const T& t) {
return sizeof(t);
}
| int main() {
assert(func0(std::make_tuple("A", 1, "B", 2, "C", 3)) == sizeof(std::make_tuple("A", 1, "B", 2, "C", 3)));
assert(func0(std::make_tuple(1, "Raju", 2, "Nikhil", 3, "Deepanshu")) == sizeof(std::make_tuple(1, "Raju", 2, "Nikhil", 3, "Deepanshu")));
assert(func0(std::make_tuple(std::make_tuple(1... | O3 | cpp | |||||
2,384 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(std::vector<int>& arr1, std::vector<int>& arr2, int m, int n, int k) {
std::vector<int> sorted1(m + n);
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
... | int main() {
std::vector<int> arr1 = {2, 3, 6, 7, 9};
std::vector<int> arr2 = {1, 4, 8, 10};
assert(func0(arr1, arr2, 5, 4, 5) == 6);
arr1 = {100, 112, 256, 349, 770};
arr2 = {72, 86, 113, 119, 265, 445, 892};
assert(func0(arr1, arr2, 5, 7, 7) == 256);
arr1 = {3, 4, 7, 8, 10};
... | O0 | cpp | func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %edx,-0x54(%rbp)
mov %ecx,-0x58(%rbp)
mov %r8d,-0x5c(%rbp)
mov %fs:0x28,%rax
mov %... | _Z5func0RSt6vectorIiSaIiEES2_iii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_64], edx
mov [rbp+var_68], ecx
mov [rbp+var_6C], r8d
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_45]
m... | long long func0(long long a1, long long a2, int a3, int a4, int a5)
{
int v5; // ebx
int v6; // ebx
int v7; // ebx
int v8; // ebx
int v9; // ebx
unsigned int v10; // ebx
char v15; // [rsp+2Bh] [rbp-45h] BYREF
int v16; // [rsp+2Ch] [rbp-44h]
int v17; // [rsp+30h] [rbp-40h]
int v18; // [rsp+34h] [rbp... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV dword ptr [RBP + -0x64],EDX
MOV dword ptr [RBP + -0x68],ECX
MOV dword ptr [RBP + -0x6c],R8D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x45]
MOV qwor... | /* func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int,
int) */
int4 func0(vector *param_1,vector *param_2,int param_3,int param_4,int param_5)
{
int iVar1;
int4 uVar2;
int *piVar3;
int4 *puVar4;
long in_FS_OFFSET;
allocator local_4d;
int local_4c;
int l... |
2,385 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(std::vector<int>& arr1, std::vector<int>& arr2, int m, int n, int k) {
std::vector<int> sorted1(m + n);
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
... | int main() {
std::vector<int> arr1 = {2, 3, 6, 7, 9};
std::vector<int> arr2 = {1, 4, 8, 10};
assert(func0(arr1, arr2, 5, 4, 5) == 6);
arr1 = {100, 112, 256, 349, 770};
arr2 = {72, 86, 113, 119, 265, 445, 892};
assert(func0(arr1, arr2, 5, 7, 7) == 256);
arr1 = {3, 4, 7, 8, 10};
... | O1 | cpp | func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
lea (%rdx,%rcx,1),%r15d
movslq %r15d,%r15
movabs $0x1fffffffffffffff,%rax
cmp %rax,%r15
ja 130f <_Z5func0RSt6... | _Z5func0RSt6vectorIiSaIiEES2_iii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_3C], r8d
lea r12d, [rdx+rcx]
movsxd r12, r12d
mov rax, r12
shr rax, 3Dh
jnz short loc_12BC
mov r14, rdi
mov r13, rsi
mov ebp, edx
mov e... | long long func0(long long *a1, long long *a2, int a3, int a4, int a5)
{
unsigned long long v5; // r12
unsigned long long v10; // r15
_DWORD *v11; // rax
_DWORD *v12; // rdi
_DWORD *v13; // rdx
_DWORD *i; // rax
long long v15; // r10
long long v16; // r9
long long v17; // rcx
int v18; // esi
int v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],R8D
LEA R12D,[RDX + RCX*0x1]
MOVSXD R12,R12D
MOV RAX,R12
SHR RAX,0x3d
JNZ 0x001012bc
MOV R14,RDI
MOV R13,RSI
MOV EBP,EDX
MOV EBX,ECX
TEST R12,R12
JZ 0x001012c8
LEA R15,[R12*0x4]
MOV RDI,R15
CALL 0x00101110
MOV RD... | /* func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int,
int) */
int4 func0(vector *param_1,vector *param_2,int param_3,int param_4,int param_5)
{
int4 uVar1;
long lVar2;
int4 *puVar3;
long lVar4;
int iVar5;
int4 *puVar6;
long lVar7;
int iVar8;
long lVa... |
2,386 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(std::vector<int>& arr1, std::vector<int>& arr2, int m, int n, int k) {
std::vector<int> sorted1(m + n);
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
... | int main() {
std::vector<int> arr1 = {2, 3, 6, 7, 9};
std::vector<int> arr2 = {1, 4, 8, 10};
assert(func0(arr1, arr2, 5, 4, 5) == 6);
arr1 = {100, 112, 256, 349, 770};
arr2 = {72, 86, 113, 119, 265, 445, 892};
assert(func0(arr1, arr2, 5, 7, 7) == 256);
arr1 = {3, 4, 7, 8, 10};
... | O2 | cpp | func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int, int):
endbr64
push %r15
lea (%rdx,%rcx,1),%eax
push %r14
cltq
push %r13
push %r12
push %rbp
push %rbx
mov %edx,%ebx
movabs $0x1fffffffffffffff,%rdx
sub $0x8,%rsp
cmp %rdx,%rax
ja 1724 <_Z5func0R... | _Z5func0RSt6vectorIiSaIiEES2_iii:
endbr64
push r15
push r14
push r13
mov r13, rsi
lea esi, [rdx+rcx]
push r12
movsxd rsi, esi
push rbp
mov rax, rsi
push rbx
sub rsp, 18h
shr rax, 3Dh
jnz loc_16A4
mov r15, rdi
mov ebp, edx
mov ebx, ecx
mov r14d, r8d
xor r12d... | long long func0(long long *a1, long long *a2, int a3, int a4, int a5)
{
unsigned long long v6; // rsi
_DWORD *v11; // r12
_DWORD *v12; // rax
long long v13; // r10
long long v14; // r9
long long v15; // rax
int v16; // edx
int v17; // ecx
long long v18; // rdi
int v19; // r8d
int v20; // edi
in... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
LEA ESI,[RDX + RCX*0x1]
PUSH R12
MOVSXD RSI,ESI
PUSH RBP
MOV RAX,RSI
PUSH RBX
SUB RSP,0x18
SHR RAX,0x3d
JNZ 0x001016a4
MOV R15,RDI
MOV EBP,EDX
MOV EBX,ECX
MOV R14D,R8D
XOR R12D,R12D
TEST RSI,RSI
JZ 0x00101573
LEA RCX,[RSI*0x4]
MOV qword ptr [RSP],RSI
MOV RDI,RCX
MOV... | /* func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int,
int) */
int * func0(vector *param_1,vector *param_2,int param_3,int param_4,int param_5)
{
int *piVar1;
int iVar2;
uint uVar3;
long lVar4;
void *pvVar5;
long lVar6;
int4 *puVar7;
long lVar8;
long ... |
2,387 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(std::vector<int>& arr1, std::vector<int>& arr2, int m, int n, int k) {
std::vector<int> sorted1(m + n);
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
... | int main() {
std::vector<int> arr1 = {2, 3, 6, 7, 9};
std::vector<int> arr2 = {1, 4, 8, 10};
assert(func0(arr1, arr2, 5, 4, 5) == 6);
arr1 = {100, 112, 256, 349, 770};
arr2 = {72, 86, 113, 119, 265, 445, 892};
assert(func0(arr1, arr2, 5, 7, 7) == 256);
arr1 = {3, 4, 7, 8, 10};
... | O3 | cpp | func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %edx,%ebx
add %ecx,%edx
movslq %edx,%rdx
sub $0x8,%rsp
cmp %rax,%rdx
ja 1874 <_Z5fun... | _Z5func0RSt6vectorIiSaIiEES2_iii:
endbr64
push r15
push r14
push r13
lea r13d, [rdx+rcx]
push r12
movsxd r13, r13d
push rbp
mov rax, r13
push rbx
sub rsp, 18h
shr rax, 3Dh
mov [rsp+48h+var_48], rsi
mov [rsp+48h+var_3C], r8d
jnz loc_1963
mov r14, rdi
mov ebp, edx
mo... | long long func0(long long *a1, long long *a2, int a3, int a4, int a5)
{
unsigned long long v5; // r13
_DWORD *v9; // rbx
long long v10; // r15
_DWORD *v11; // rax
long long v12; // r11
int v13; // edx
int v14; // ecx
long long v15; // rsi
long long v16; // r9
long long v17; // r10
long long i; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
LEA R13D,[RDX + RCX*0x1]
PUSH R12
MOVSXD R13,R13D
PUSH RBP
MOV RAX,R13
PUSH RBX
SUB RSP,0x18
SHR RAX,0x3d
MOV qword ptr [RSP],RSI
MOV dword ptr [RSP + 0xc],R8D
JNZ 0x00101963
MOV R14,RDI
MOV EBP,EDX
MOV R12D,ECX
XOR EBX,EBX
TEST R13,R13
JZ 0x00101680
LEA R15,[R13*0x4]
MOV RDI,R... | /* func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int,
int) */
void * func0(vector *param_1,vector *param_2,int param_3,int param_4,int param_5)
{
int iVar1;
int8 *puVar2;
int8 *puVar3;
long lVar4;
void *pvVar5;
int8 uVar6;
int iVar7;
int4 *puVar8;
lo... |
2,388 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| bool func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while(temp > 0) {
times++;
temp /= 10;
}
temp = number;
while(temp > 0) {
int reminder = temp % 10;
sum += std::pow(reminder, times);
temp /= 10;
}
... | int main() {
assert(func0(153) == true);
assert(func0(259) == false);
assert(func0(4458) == false);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jle 11f6 <_Z5func0i+0x4d>
addl $0x1,-0xc(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
jmp short loc_11B0
loc_118E:
add [rbp+var_C], 1
mov eax, [rbp+var_8]
movsxd rdx, eax
imul rdx, 66666667h
shr rd... | _BOOL8 func0(int a1)
{
int v2; // [rsp+10h] [rbp-10h]
unsigned int v3; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int j; // [rsp+18h] [rbp-8h]
v2 = 0;
v3 = 0;
for ( i = a1; i > 0; i /= 10 )
++v3;
for ( j = a1; j > 0; j /= 10 )
v2 = (int)(std::pow<int,int>((unsigned int)(j % 10), v3) + ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011b0
LAB_0010118e:
ADD dword ptr [RBP + -0xc],0x1
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
IMUL RD... | /* func0(int) */
bool func0(int param_1)
{
int iVar1;
double extraout_XMM0_Qa;
int local_18;
int local_14;
int local_10;
local_18 = 0;
local_14 = 0;
for (local_10 = param_1; iVar1 = param_1, 0 < local_10; local_10 = local_10 / 10) {
local_14 = local_14 + 1;
}
while (local_10 = iVar1, 0 < lo... |
2,389 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| bool func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while(temp > 0) {
times++;
temp /= 10;
}
temp = number;
while(temp > 0) {
int reminder = temp % 10;
sum += std::pow(reminder, times);
temp /= 10;
}
... | int main() {
assert(func0(153) == true);
assert(func0(259) == false);
assert(func0(4458) == false);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,%ebp
test %edi,%edi
jle 1263 <_Z5func0i+0xba>
mov %edi,%eax
mov $0x0,%ecx
add $0x1,%ecx
mov %eax,%esi
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
sar $0x1f,%eax
sub %eax,%edx
mov ... | _Z5func0i:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r13d, edi
test edi, edi
jle loc_121C
mov edx, edi
mov ecx, 0
loc_1187:
add ecx, 1
mov esi, edx
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov edi, edx
sar edi, 1Fh
sub eax, edi
mov ... | bool func0(int a1)
{
int v1; // edx
int v2; // ecx
int v3; // esi
int v4; // ebp
int v5; // r12d
double v6; // r14
int v7; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 10;
}
while ( v3 > 9 );
v4 = a1;
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13D,EDI
TEST EDI,EDI
JLE 0x0010121c
MOV EDX,EDI
MOV ECX,0x0
LAB_00101187:
ADD ECX,0x1
MOV ESI,EDX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDI,EDX
SAR EDI,0x1f
SUB EAX,EDI
MOV EDX,EAX
CMP ESI,0x9
JG 0x00101187
MOV EBP,R13D
MOV R12D,0x0
PXOR... | /* func0(int) */
bool func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
int iVar4;
double dVar5;
if (param_1 < 1) {
iVar4 = 0;
}
else {
iVar2 = 0;
iVar4 = param_1;
do {
iVar2 = iVar2 + 1;
bVar1 = 9 < iVar4;
iVar4 = iVar4 / 10;
} while (bVar1);
iVar4 = ... |
2,390 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| bool func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while(temp > 0) {
times++;
temp /= 10;
}
temp = number;
while(temp > 0) {
int reminder = temp % 10;
sum += std::pow(reminder, times);
temp /= 10;
}
... | int main() {
assert(func0(153) == true);
assert(func0(259) == false);
assert(func0(4458) == false);
return 0;
}
| O2 | cpp | func0(int):
endbr64
push %r14
push %r13
push %r12
mov %edi,%r12d
push %rbp
push %rbx
sub $0x10,%rsp
test %edi,%edi
jle 1340 <_Z5func0i+0xb0>
mov %edi,%eax
xor %ecx,%ecx
mov $0xcccccccd,%esi
nopl 0x0(%rax)
mov %eax,%eax
add $0x1,%ecx
mov %rax,%rdx
imul %rsi,%rax
shr $0x23,%r... | _Z5func0i:
endbr64
push r14
push r13
push r12
push rbp
mov ebp, edi
push rbx
sub rsp, 10h
test edi, edi
jle loc_12D0
mov eax, edi
xor ecx, ecx
mov esi, 0CCCCCCCDh
nop dword ptr [rax+rax+00h]
loc_1238:
mov eax, eax
add ecx, 1
mov rdx, rax
imul rax, rsi
shr ... | bool func0(int a1)
{
unsigned int v1; // eax
int v2; // ecx
int v3; // edx
unsigned int v4; // r12d
int v5; // r14d
double v6; // xmm1_8
double v7; // xmm0_8
int v8; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 0xAu... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x10
TEST EDI,EDI
JLE 0x001012d0
MOV EAX,EDI
XOR ECX,ECX
MOV ESI,0xcccccccd
NOP dword ptr [RAX + RAX*0x1]
LAB_00101238:
MOV EAX,EAX
ADD ECX,0x1
MOV RDX,RAX
IMUL RAX,RSI
SHR RAX,0x23
CMP EDX,0x9
JG 0x00101238
PXOR XMM1,XMM1
MOV R12D,EBP
XOR ... | /* func0(int) */
bool func0(int param_1)
{
bool bVar1;
ulong uVar2;
int iVar3;
uint uVar4;
int iVar5;
double dVar6;
if (param_1 < 1) {
iVar5 = 0;
}
else {
iVar3 = 0;
uVar2 = (ulong)(uint)param_1;
do {
iVar3 = iVar3 + 1;
iVar5 = (int)uVar2;
uVar2 = uVar2 / 10;
... |
2,391 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| bool func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while(temp > 0) {
times++;
temp /= 10;
}
temp = number;
while(temp > 0) {
int reminder = temp % 10;
sum += std::pow(reminder, times);
temp /= 10;
}
... | int main() {
assert(func0(153) == true);
assert(func0(259) == false);
assert(func0(4458) == false);
return 0;
}
| O3 | cpp | func0(int):
endbr64
push %r14
push %r13
push %r12
mov %edi,%r12d
push %rbp
push %rbx
sub $0x10,%rsp
test %edi,%edi
jle 1340 <_Z5func0i+0xb0>
mov %edi,%eax
xor %ecx,%ecx
mov $0xcccccccd,%esi
nopl 0x0(%rax)
mov %eax,%eax
add $0x1,%ecx
mov %rax,%rdx
imul %rsi,%rax
shr $0x23,%r... | _Z5func0i:
endbr64
push r14
push r13
push r12
push rbp
mov ebp, edi
push rbx
sub rsp, 10h
test edi, edi
jle loc_12D0
mov eax, edi
xor ecx, ecx
mov esi, 0CCCCCCCDh
nop dword ptr [rax+rax+00h]
loc_1238:
mov eax, eax
add ecx, 1
mov rdx, rax
imul rax, rsi
shr ... | bool func0(int a1)
{
unsigned int v1; // eax
int v2; // ecx
int v3; // edx
unsigned int v4; // r12d
int v5; // r14d
double v6; // xmm1_8
double v7; // xmm0_8
int v8; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 0xAu... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x10
TEST EDI,EDI
JLE 0x001012d0
MOV EAX,EDI
XOR ECX,ECX
MOV ESI,0xcccccccd
NOP dword ptr [RAX + RAX*0x1]
LAB_00101238:
MOV EAX,EAX
ADD ECX,0x1
MOV RDX,RAX
IMUL RAX,RSI
SHR RAX,0x23
CMP EDX,0x9
JG 0x00101238
PXOR XMM1,XMM1
MOV R12D,EBP
XOR ... | /* func0(int) */
bool func0(int param_1)
{
bool bVar1;
ulong uVar2;
int iVar3;
uint uVar4;
int iVar5;
double dVar6;
if (param_1 < 1) {
iVar5 = 0;
}
else {
iVar3 = 0;
uVar2 = (ulong)(uint)param_1;
do {
iVar3 = iVar3 + 1;
iVar5 = (int)uVar2;
uVar2 = uVar2 / 10;
... |
2,392 | func0 |
#include <cassert>
#include <utility>
| std::pair<int, double> func0(int number) {
int total = 0;
for (int value = 1; value <= number; ++value) {
total += value;
}
double average = static_cast<double>(total) / number;
return {total, average};
}
| int main() {
assert(func0(10) == std::make_pair(55, 5.5));
assert(func0(15) == std::make_pair(120, 8.0));
assert(func0(20) == std::make_pair(210, 10.5));
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x40(%rbp)
movl $0x1,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cmp -0x44(%rbp),%eax
jg 11cf <_Z5func0i+0x46>
mov -0x40(%rbp),%edx
mov ... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_44], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_40], 0
mov [rbp+var_3C], 1
jmp short loc_11A7
loc_1198:
mov edx, [rbp+var_40]
mov eax, [rbp+var_3C]
add eax, edx
mov ... | double func0(int a1)
{
int v2; // [rsp+10h] [rbp-40h] BYREF
int i; // [rsp+14h] [rbp-3Ch]
double v4; // [rsp+18h] [rbp-38h] BYREF
_QWORD v5[5]; // [rsp+20h] [rbp-30h] BYREF
v5[3] = __readfsqword(0x28u);
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += i;
v4 = (double)v2 / (double)a1;
std::pair<int,doub... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x44],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x3c],0x1
JMP 0x001011a7
LAB_00101198:
MOV EDX,dword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x3c]
A... | /* func0(int) */
ulong func0(int param_1)
{
long in_FS_OFFSET;
int local_48;
int local_44;
double local_40;
ulong local_38;
int8 local_30;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = 0;
for (local_44 = 1; local_44 <= param_1; local_44 = local_44 + 1) {
local_48 = lo... |
2,393 | func0 |
#include <cassert>
#include <utility>
| std::pair<int, double> func0(int number) {
int total = 0;
for (int value = 1; value <= number; ++value) {
total += value;
}
double average = static_cast<double>(total) / number;
return {total, average};
}
| int main() {
assert(func0(10) == std::make_pair(55, 5.5));
assert(func0(15) == std::make_pair(120, 8.0));
assert(func0(20) == std::make_pair(210, 10.5));
return 0;
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
jle 117e <_Z5func0i+0x35>
lea 0x1(%rdi),%ecx
mov $0x0,%edx
mov $0x1,%eax
add %eax,%edx
add $0x1,%eax
cmp %eax,%ecx
jne 115e <_Z5func0i+0x15>
mov %edx,%eax
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
retq... | _Z5func0i:
endbr64
test edi, edi
jle short loc_117C
lea ecx, [rdi+1]
mov eax, 0
mov edx, 1
loc_115E:
add eax, edx
add edx, 1
cmp ecx, edx
jnz short loc_115E
loc_1167:
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
retn
loc_117C:
mov ... | double func0(int a1)
{
int v1; // eax
int v2; // edx
if ( a1 <= 0 )
{
v1 = 0;
}
else
{
v1 = 0;
v2 = 1;
do
v1 += v2++;
while ( a1 + 1 != v2 );
}
return (double)v1 / (double)a1;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x0010117c
LEA ECX,[RDI + 0x1]
MOV EAX,0x0
MOV EDX,0x1
LAB_0010115e:
ADD EAX,EDX
ADD EDX,0x1
CMP ECX,EDX
JNZ 0x0010115e
LAB_00101167:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
RET
LAB_0010117c:
MOV EAX,0x0
JMP 0x00101167 | /* func0(int) */
double func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar1 = 0;
}
else {
iVar1 = 0;
iVar2 = 1;
do {
iVar1 = iVar1 + iVar2;
iVar2 = iVar2 + 1;
} while (param_1 + 1 != iVar2);
}
return (double)iVar1 / (double)param_1;
} |
2,394 | func0 |
#include <cassert>
#include <utility>
| std::pair<int, double> func0(int number) {
int total = 0;
for (int value = 1; value <= number; ++value) {
total += value;
}
double average = static_cast<double>(total) / number;
return {total, average};
}
| int main() {
assert(func0(10) == std::make_pair(55, 5.5));
assert(func0(15) == std::make_pair(120, 8.0));
assert(func0(20) == std::make_pair(210, 10.5));
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
jle 1180 <_Z5func0i+0x40>
lea 0x1(%rdi),%ecx
xor %eax,%eax
mov $0x1,%edx
nopw 0x0(%rax,%rax,1)
add %edx,%eax
add $0x1,%edx
cmp %edx,%ecx
jne 1158 <_Z5func0i+0x18>
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm0
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xm... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1190
lea ecx, [rdi+1]
xor eax, eax
mov edx, 1
test dil, 1
jz short loc_1170
mov eax, 1
mov edx, 2
cmp ecx, 2
jz short loc_117B
nop word ptr [rax+rax+00000000h]
loc_1170:
lea eax, [rax+rdx*2+1]
add edx, 2
cmp ecx, ... | double func0(int a1)
{
int v1; // eax
int v2; // edx
if ( a1 <= 0 )
return 0.0 / (double)a1;
v1 = 0;
v2 = 1;
if ( (a1 & 1) == 0 || (v1 = 1, v2 = 2, a1 != 1) )
{
do
{
v1 += 2 * v2 + 1;
v2 += 2;
}
while ( a1 + 1 != v2 );
}
return (double)v1 / (double)a1;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101190
LEA ECX,[RDI + 0x1]
XOR EAX,EAX
MOV EDX,0x1
TEST DIL,0x1
JZ 0x00101170
MOV EAX,0x1
MOV EDX,0x2
CMP ECX,0x2
JZ 0x0010117b
NOP word ptr [RAX + RAX*0x1]
LAB_00101170:
LEA EAX,[RAX + RDX*0x2 + 0x1]
ADD EDX,0x2
CMP ECX,EDX
JNZ 0x00101170
LAB_0010117b:
PXOR XMM0,XMM0
PXOR XMM1,XMM1
... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
return 0;
}
iVar1 = 0;
iVar2 = 1;
if ((param_1 & 1U) != 0) {
iVar1 = 1;
iVar2 = 2;
if (param_1 + 1 == 2) {
return 1;
}
}
do {
iVar1 = iVar1 + 1 + iVar2 * 2;
iVar2 = iVar2 + 2;
} ... |
2,395 | func0 |
#include <cassert>
#include <utility>
| std::pair<int, double> func0(int number) {
int total = 0;
for (int value = 1; value <= number; ++value) {
total += value;
}
double average = static_cast<double>(total) / number;
return {total, average};
}
| int main() {
assert(func0(10) == std::make_pair(55, 5.5));
assert(func0(15) == std::make_pair(120, 8.0));
assert(func0(20) == std::make_pair(210, 10.5));
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11e0 <_Z5func0i+0xa0>
lea -0x1(%rdi),%eax
cmp $0x11,%eax
jbe 11f3 <_Z5func0i+0xb3>
mov %edi,%edx
movdqa 0xeae(%rip),%xmm1
xor %eax,%eax
pxor %xmm0,%xmm0
movdqa 0xeb0(%rip),%xmm3
shr $0x2,%edx
nopl 0x0(%rax,%rax,1)
movdqa %xmm1,%xmm2
add $0x1,%eax
padd... | _Z5func0i:
endbr64
mov edx, edi
test edi, edi
jle loc_1220
lea eax, [rdi-1]
cmp eax, 9
jbe loc_1233
mov ecx, edi
movdqa xmm1, cs:xmmword_2010
xor eax, eax
pxor xmm0, xmm0
movdqa xmm3, cs:xmmword_2020
shr ecx, 2
nop dword ptr [rax]
loc_1178:
movdqa xmm2, xmm1
add eax, 1
p... | double func0(int a1)
{
__m128i si128; // xmm1
int v2; // eax
__m128i v3; // xmm0
__m128i v4; // xmm3
__m128i v5; // xmm2
__m128i v6; // xmm0
unsigned int v7; // ecx
int v8; // eax
int v9; // ecx
if ( a1 > 0 )
{
if ( (unsigned int)(a1 - 1) <= 9 )
{
v8 = 0;
v7 = 1;
}
el... | func0:
ENDBR64
MOV EDX,EDI
TEST EDI,EDI
JLE 0x00101220
LEA EAX,[RDI + -0x1]
CMP EAX,0x9
JBE 0x00101233
MOV ECX,EDI
MOVDQA XMM1,xmmword ptr [0x00102010]
XOR EAX,EAX
PXOR XMM0,XMM0
MOVDQA XMM3,xmmword ptr [0x00102020]
SHR ECX,0x2
NOP dword ptr [RAX]
LAB_00101178:
MOVDQA XMM2,XMM1
ADD EAX,0x1
PADDD XMM1,XMM3
PADDD XMM0,XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
uint uVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
if (param_1 < 1) {
return 0;
}
if (param_1 - 1U < 10) {
... |
2,396 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
xor $0x1,%eax
mov %eax,%edx
mov -0x4(%rbp),%eax
add $0x1,%eax
cmp %eax,%edx
jne 11ad <_Z5func0i+0x24>
mov $0x1,%eax
jmp 11b2 <_Z5func0i+0x29>
mov $0x0,%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
xor eax, 1
mov edx, eax
mov eax, [rbp+var_4]
add eax, 1
cmp edx, eax
jnz short loc_116D
mov eax, 1
jmp short loc_1172
loc_116D:
mov eax, 0
loc_1172:
pop rbp
retn | _BOOL8 func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
XOR EAX,0x1
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
CMP EDX,EAX
JNZ 0x0010116d
MOV EAX,0x1
JMP 0x00101172
LAB_0010116d:
MOV EAX,0x0
LAB_00101172:
POP RBP
RET | /* func0(int) */
bool func0(int param_1)
{
return (param_1 ^ 1U) == param_1 + 1U;
} |
2,397 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov %edi,%eax
xor $0x1,%eax
add $0x1,%edi
cmp %edi,%eax
sete %al
retq
| _Z5func0i:
endbr64
mov eax, edi
xor eax, 1
add edi, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
XOR EAX,0x1
ADD EDI,0x1
CMP EAX,EDI
SETZ AL
RET | /* func0(int) */
bool func0(int param_1)
{
return (param_1 ^ 1U) == param_1 + 1U;
} |
2,398 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%eax
add $0x1,%edi
xor $0x1,%eax
cmp %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0i:
endbr64
mov eax, edi
add edi, 1
xor eax, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
ADD EDI,0x1
XOR EAX,0x1
CMP EAX,EDI
SETZ AL
RET | /* func0(int) */
bool func0(int param_1)
{
return (param_1 ^ 1U) == param_1 + 1U;
} |
2,399 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%eax
add $0x1,%edi
xor $0x1,%eax
cmp %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0i:
endbr64
mov eax, edi
add edi, 1
xor eax, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
ADD EDI,0x1
XOR EAX,0x1
CMP EAX,EDI
SETZ AL
RET | /* func0(int) */
bool func0(int param_1)
{
return (param_1 ^ 1U) == param_1 + 1U;
} |
2,400 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
class Pair {
public:
int a, b;
Pair(int a, int b) : a(a), b(b) {}
};
| int func0(std::vector<Pair> arr, int n) {
int max = 0;
std::vector<int> mcl(n, 1);
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0... | int main() {
assert(func0({Pair(5, 24), Pair(15, 25), Pair(27, 40), Pair(50, 60)}, 4) == 3);
assert(func0({Pair(1, 2), Pair(3, 4), Pair(5, 6), Pair(7, 8)}, 4) == 4);
assert(func0({Pair(19, 10), Pair(11, 12), Pair(13, 14), Pair(15, 16), Pair(31, 54)}, 5) == 5);
return 0;
}
| O0 | cpp | func0(std::vector<Pair, std::allocator<Pair> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x40(%rbp)
lea -0x45(%rbp),%rax
mov %rax,%rdi
callq 18d4 <_ZNSaIiEC1E... | _Z5func0St6vectorI4PairSaIS0_EEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_48], 0
lea rax, [rbp+var_4D]
mov [rbp+var_38], rax
nop
nop
mov [rbp+var_4C],... | long long func0(long long a1, int a2)
{
int v2; // ebx
int v3; // ebx
int v5; // ebx
_DWORD *v6; // rax
unsigned int v7; // ebx
char v9; // [rsp+13h] [rbp-4Dh] BYREF
int v10; // [rsp+14h] [rbp-4Ch] BYREF
int v11; // [rsp+18h] [rbp-48h]
int i; // [rsp+1Ch] [rbp-44h]
int j; // [rsp+20h] [rbp-40h]
i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x48],0x0
LEA RAX,[RBP + -0x4d]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV dword ptr [RBP + -0x4c],0x1
... | /* func0(std::vector<Pair, std::allocator<Pair> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
bool bVar2;
long lVar3;
int *piVar4;
int4 in_register_0000003c;
long in_FS_OFFSET;
allocator local_55;
int local_54;
int local_50;
int local_4c;
int local_48;
int local_44;
allocator... |
2,401 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
class Pair {
public:
int a, b;
Pair(int a, int b) : a(a), b(b) {}
};
| int func0(std::vector<Pair> arr, int n) {
int max = 0;
std::vector<int> mcl(n, 1);
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0... | int main() {
assert(func0({Pair(5, 24), Pair(15, 25), Pair(27, 40), Pair(50, 60)}, 4) == 3);
assert(func0({Pair(1, 2), Pair(3, 4), Pair(5, 6), Pair(7, 8)}, 4) == 4);
assert(func0({Pair(19, 10), Pair(11, 12), Pair(13, 14), Pair(15, 16), Pair(31, 54)}, 5) == 5);
return 0;
}
| O1 | cpp | func0(std::vector<Pair, std::allocator<Pair> >, int):
endbr64
push %r12
push %rbp
push %rbx
movslq %esi,%rax
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 1291 <_Z5func0St6vectorI4PairSaIS0_EEi+0x68>
mov %rdi,%rbp
mov %esi,%ebx
mov $0x0,%r12d
test %rax,%rax
je 1305 <_Z5func0St6vectorI4Pai... | _Z5func0St6vectorI4PairSaIS0_EEi:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
movsxd rbp, esi
mov rax, rbp
shr rax, 3Dh
jnz short loc_1244
mov rbx, rdi
mov r13d, esi
test rbp, rbp
jz short loc_128D
lea r12, ds:0[rbp*4]
mov rdi, r12; unsigned __int64
call ... | long long func0(long long *a1, int a2)
{
long long v2; // rbp
unsigned long long v5; // r12
unsigned int *v6; // rax
unsigned int *v7; // rdi
unsigned int *v8; // rdx
long long i; // rdx
long long v10; // rax
int v11; // ecx
long long v12; // rsi
_DWORD *v13; // r8
unsigned int v14; // ebx
unsi... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVSXD RBP,ESI
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x00101244
MOV RBX,RDI
MOV R13D,ESI
TEST RBP,RBP
JZ 0x0010128d
LEA R12,[RBP*0x4]
MOV RDI,R12
CALL 0x001010c0
MOV RDI,RAX
LEA RDX,[RAX + R12*0x1]
LAB_00101225:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x... | /* func0(std::vector<Pair, std::allocator<Pair> >, int) */
int func0(vector param_1,int param_2)
{
int auVar1 [16];
int auVar2 [16];
char *pcVar3;
ulong uVar4;
int *piVar5;
ulong uVar6;
int iVar7;
long *unaff_RBX;
long *plVar8;
ulong uVar9;
int4 in_register_00000034;
long lVar10;
int4 in_reg... |
2,402 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
class Pair {
public:
int a, b;
Pair(int a, int b) : a(a), b(b) {}
};
| int func0(std::vector<Pair> arr, int n) {
int max = 0;
std::vector<int> mcl(n, 1);
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0... | int main() {
assert(func0({Pair(5, 24), Pair(15, 25), Pair(27, 40), Pair(50, 60)}, 4) == 3);
assert(func0({Pair(1, 2), Pair(3, 4), Pair(5, 6), Pair(7, 8)}, 4) == 4);
assert(func0({Pair(19, 10), Pair(11, 12), Pair(13, 14), Pair(15, 16), Pair(31, 54)}, 5) == 5);
return 0;
}
| O2 | cpp | func0(std::vector<Pair, std::allocator<Pair> >, int):
endbr64
movabs $0x1fffffffffffffff,%rdx
movslq %esi,%rax
push %r12
push %rbp
push %rbx
cmp %rdx,%rax
ja 15b9 <_Z5func0St6vectorI4PairSaIS0_EEi+0xe9>
xor %r12d,%r12d
test %rax,%rax
je 15aa <_Z5func0St6vectorI4PairSaIS0_EEi+0xda>
lea 0x0(,%rax... | _Z5func0St6vectorI4PairSaIS0_EEi:
endbr64
push r13
push r12
movsxd r12, esi
push rbp
mov rax, r12
push rbx
sub rsp, 8
shr rax, 3Dh
jnz loc_151D
xor ebx, ebx
test r12, r12
jz loc_1510
mov rbp, r12
shl r12, 2
mov r13, rdi
mov rdi, r12; unsigned __int64
call __Zn... | long long func0(_QWORD *a1, int a2)
{
int v2; // ebx
unsigned long long v3; // r12
int *v5; // rax
int *v6; // rdi
int *v7; // r10
long long v8; // r9
long long v9; // rdx
_DWORD *v10; // r8
long long v11; // rax
int v12; // ecx
int *v13; // rax
if ( (unsigned long long)a2 >> 61 )
std::__t... | func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RAX,R12
PUSH RBX
SUB RSP,0x8
SHR RAX,0x3d
JNZ 0x0010151d
XOR EBX,EBX
TEST R12,R12
JZ 0x00101510
MOV RBP,R12
SHL R12,0x2
MOV R13,RDI
MOV RDI,R12
CALL 0x001010e0
MOV RDI,RAX
LEA R10,[RAX + R12*0x1]
TEST R12B,0x4
JZ 0x00101460
MOV dword ptr [RAX],0x1
LEA RAX,[RA... | /* func0(std::vector<Pair, std::allocator<Pair> >, int) */
void * func0(vector param_1,int param_2)
{
uint *puVar1;
void *pvVar2;
int *piVar3;
uint *puVar4;
ulong uVar5;
uint *puVar6;
void *__dest;
int8 uVar7;
long extraout_RDX;
uint uVar8;
int4 in_register_00000034;
void *pvVar9;
int4 in_re... |
2,403 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
class Pair {
public:
int a, b;
Pair(int a, int b) : a(a), b(b) {}
};
| int func0(std::vector<Pair> arr, int n) {
int max = 0;
std::vector<int> mcl(n, 1);
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0... | int main() {
assert(func0({Pair(5, 24), Pair(15, 25), Pair(27, 40), Pair(50, 60)}, 4) == 3);
assert(func0({Pair(1, 2), Pair(3, 4), Pair(5, 6), Pair(7, 8)}, 4) == 4);
assert(func0({Pair(19, 10), Pair(11, 12), Pair(13, 14), Pair(15, 16), Pair(31, 54)}, 5) == 5);
return 0;
}
| O3 | cpp | func0(std::vector<Pair, std::allocator<Pair> >, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r13
push %r12
push %rbp
movslq %esi,%rbp
push %rbx
sub $0x8,%rsp
cmp %rax,%rbp
ja 1665 <_Z5func0St6vectorI4PairSaIS0_EEi+0x205>
xor %r12d,%r12d
test %rbp,%rbp
je 163d <_Z5func0St6vectorI4PairSa... | _Z5func0St6vectorI4PairSaIS0_EEi:
endbr64
push r13
push r12
movsxd r12, esi
push rbp
mov rax, r12
push rbx
sub rsp, 8
shr rax, 3Dh
jnz loc_160E
xor ebx, ebx
test r12, r12
jz loc_15E9
mov rbp, r12
shl r12, 2
mov r13, rdi
mov rdi, r12; unsigned __int64
call __Zn... | long long func0(_QWORD *a1, int a2)
{
int v2; // ebx
unsigned long long v4; // r12
__m128i *v6; // rax
__m128i *v7; // rdi
char *v8; // r8
unsigned long long v9; // rdx
__m128i si128; // xmm0
long long v11; // rcx
__m128i *v12; // rsi
long long v13; // r8
long long v14; // rdx
_DWORD *v15; // r... | func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RAX,R12
PUSH RBX
SUB RSP,0x8
SHR RAX,0x3d
JNZ 0x0010160e
XOR EBX,EBX
TEST R12,R12
JZ 0x001015e9
MOV RBP,R12
SHL R12,0x2
MOV R13,RDI
MOV RDI,R12
CALL 0x001010e0
MOV RDI,RAX
LEA R8,[RAX + R12*0x1]
LEA RAX,[R12 + -0x4]
MOV RDX,RAX
SHR RDX,0x2
ADD RDX,0x1
CMP RAX... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<Pair, std::allocator<Pair> >, int) */
void * func0(vector param_1,int param_2)
{
void *pvVar1;
int *piVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
int8 uVar6;
ulong uVar7;
uint uVar8;
uint *p... |
2,404 | func0 |
#include <iostream>
#include <string>
#include <cassert>
| char func0(std::string str1) {
for (int index = 0; index < str1.length(); ++index) {
char c = str1[index];
int count = 0;
for (int j = 0; j <= index; ++j) {
if (str1[j] == c)
++count;
}
if (count > 1) {
return c;
}
... | int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == 'N');
assert(func0("123123") == '1');
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 $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 22c0 <_ZNKSt7__cxx1112basic_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_1C], 0
jmp short loc_13D0
loc_1363:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call ... | long long func0(long long a1)
{
unsigned __int8 v2; // [rsp+13h] [rbp-1Dh]
int i; // [rsp+14h] [rbp-1Ch]
int v4; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
for ( i = 0; i < (unsigned long long)std::string::length(a1); ++i )
{
v2 = *(_BYTE *)std::string::operator[](a1, i);
v4 = 0;
for... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001013d0
LAB_00101363:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101250
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x1d... | /* func0(std::string) */
char func0(ulong param_1)
{
char cVar1;
char *pcVar2;
ulong uVar3;
int local_24;
int local_20;
int local_1c;
local_24 = 0;
while( true ) {
uVar3 = std::string::length();
if (uVar3 <= (ulong)(long)local_24) {
return 'N';
}
pcVar2 = (char *)std::string::... |
2,405 | func0 |
#include <iostream>
#include <string>
#include <cassert>
| char func0(std::string str1) {
for (int index = 0; index < str1.length(); ++index) {
char c = str1[index];
int count = 0;
for (int j = 0; j <= index; ++j) {
if (str1[j] == c)
++count;
}
if (count > 1) {
return c;
}
... | int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == 'N');
assert(func0("123123") == '1');
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
test %rax,%rax
je 1289 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x60>
mov (%rdi),%r8
lea 0x1(%r8),%rsi
lea 0x1(%r8,%rax,1),%r10
mov $0x0,%r9d
movzbl -0x1(%rsi),%ed... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
test rax, rax
jz short loc_126B
mov r9, [rdi]
lea rsi, [r9+1]
lea r10, [rax+r9+1]
mov r8d, 0
jmp short loc_1237
loc_122A:
add r8d, 1
add rsi, 1
cmp rsi, r10
jz short loc_1264
loc_1237:... | long long func0(_QWORD *a1)
{
long long v1; // rax
_BYTE *v2; // r9
long long v3; // rsi
long long v4; // r10
int i; // r8d
unsigned int v6; // edi
_BYTE *v7; // rax
int v8; // edx
v1 = a1[1];
if ( v1 )
{
v2 = (_BYTE *)*a1;
v3 = *a1 + 1LL;
v4 = v1 + *a1 + 1;
for ( i = 0; ; ++i )
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x0010126b
MOV R9,qword ptr [RDI]
LEA RSI,[R9 + 0x1]
LEA R10,[RAX + R9*0x1 + 0x1]
MOV R8D,0x0
JMP 0x00101237
LAB_0010122a:
ADD R8D,0x1
ADD RSI,0x1
CMP RSI,R10
JZ 0x00101264
LAB_00101237:
MOVZX EDI,byte ptr [RSI + -0x1]
TEST R8D,R8D
JS 0x0010122a
MOV RAX,R9
MO... | /* func0(std::string) */
char func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
int iVar5;
if (param_1[1] != 0) {
pcVar1 = (char *)*param_1;
pcVar4 = pcVar1 + 1;
iVar5 = 0;
do {
if (-1 < iVar5) {
iVar3 = 0;
pcVar2 = pcVar1;
do {
... |
2,406 | func0 |
#include <iostream>
#include <string>
#include <cassert>
| char func0(std::string str1) {
for (int index = 0; index < str1.length(); ++index) {
char c = str1[index];
int count = 0;
for (int j = 0; j <= index; ++j) {
if (str1[j] == c)
++count;
}
if (count > 1) {
return c;
}
... | int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == 'N');
assert(func0("123123") == '1');
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
test %rax,%rax
je 14f1 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x51>
mov (%rdi),%rdi
lea 0x1(%rdi),%rsi
lea 0x1(%rax,%rdi,1),%r9
nopl 0x0(%rax)
movzbl -0x1(%rsi),%... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
test rax, rax
jz short loc_1381
mov r8, [rdi]
lea rsi, [r8+1]
lea r9, [rax+r8+1]
nop dword ptr [rax+00000000h]
loc_1350:
movzx edi, byte ptr [rsi-1]
mov rax, r8
xor edx, edx
nop dword ptr [ra... | long long func0(_QWORD *a1)
{
long long v1; // rax
_BYTE *v2; // r8
long long v3; // rsi
long long v4; // r9
unsigned int v5; // edi
_BYTE *v6; // rax
int v7; // edx
int v8; // ecx
v1 = a1[1];
if ( v1 )
{
v2 = (_BYTE *)*a1;
v3 = *a1 + 1LL;
v4 = v1 + *a1 + 1;
while ( 1 )
{
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x00101381
MOV R8,qword ptr [RDI]
LEA RSI,[R8 + 0x1]
LEA R9,[RAX + R8*0x1 + 0x1]
NOP dword ptr [RAX]
LAB_00101350:
MOVZX EDI,byte ptr [RSI + -0x1]
MOV RAX,R8
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_00101360:
XOR ECX,ECX
CMP DIL,byte ptr [RAX]
SETZ CL
ADD RAX,0x1
... | /* func0(std::string) */
char func0(int8 *param_1)
{
char cVar1;
char *pcVar2;
char *pcVar3;
int iVar4;
char *pcVar5;
if (param_1[1] != 0) {
pcVar2 = (char *)*param_1;
pcVar5 = pcVar2 + 1;
do {
iVar4 = 0;
pcVar3 = pcVar2;
do {
cVar1 = *pcVar3;
pcVar3 = pcVa... |
2,407 | func0 |
#include <iostream>
#include <string>
#include <cassert>
| char func0(std::string str1) {
for (int index = 0; index < str1.length(); ++index) {
char c = str1[index];
int count = 0;
for (int j = 0; j <= index; ++j) {
if (str1[j] == c)
++count;
}
if (count > 1) {
return c;
}
... | int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == 'N');
assert(func0("123123") == '1');
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%r10
test %r10,%r10
je 1ef6 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2c6>
mov (%rdi),%rcx
mov $0x1,%r9d
xor %esi,%esi
pxor %xmm4,%xmm4
movdqa 0x1488(%rip),%xmm5
pxor ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov r8, [rdi+8]
test r8, r8
jz loc_1D5F
push rbx
mov rdx, [rdi]
xor esi, esi
mov edi, 1
pxor xmm6, xmm6
pxor xmm5, xmm5
pxor xmm4, xmm4
mov r10d, edi
movzx ecx, byte ptr [rdx+rdi-1]
pxor xmm3, xmm3
cmp ... | long long func0(const __m128i **a1)
{
const __m128i *v1; // r8
const __m128i *v2; // rdx
int v3; // esi
long long v4; // rdi
unsigned int v5; // ecx
__m128i v6; // xmm8
__m128i v7; // xmm1
const __m128i *v8; // rax
__m128i v9; // xmm8
__m128i v10; // xmm8
__m128i v11; // xmm0
__m128i v12; // xm... | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
TEST R8,R8
JZ 0x00101d5f
PUSH RBX
MOV RDX,qword ptr [RDI]
XOR ESI,ESI
MOV EDI,0x1
PXOR XMM6,XMM6
PXOR XMM5,XMM5
PXOR XMM4,XMM4
MOV R10D,EDI
MOVZX ECX,byte ptr [RDX + RDI*0x1 + -0x1]
PXOR XMM3,XMM3
CMP ESI,0xe
JLE 0x00101d45
NOP dword ptr [RAX]
LAB_00101b10:
MOVD XMM8,ECX
MOV ... | /* func0(std::string) */
char func0(int8 *param_1)
{
uint uVar1;
char *pcVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
char *pcVar17;
c... |
2,408 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(int n) {
std::vector<int> ludics;
for (int i = 1; i <= n; i++) {
ludics.push_back(i);
}
int index = 1;
while (index != ludics.size()) {
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < ludic... | int main() {
std::vector<int> result;
result = func0(10);
assert((result == std::vector<int>{1, 2, 3, 5, 7}));
result = func0(25);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25}));
result = func0(45);
assert((result == std::vector<int>{1, 2, 3, 5, ... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 194e <_ZNSt6vectorIiSaIiEEC1Ev>
movl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov dword ptr [r... | long long func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-3Ch]
int j; // [rsp+18h] [rbp-38h]
int v5; // [rsp+1Ch] [rbp-34h]
long long v6; // [rsp+20h] [rbp-30h] BYREF
long long v7; // [rsp+28h] [rbp-28h] BYREF
_QWORD v8[3]; // [rsp+30h] [rbp-20h] BYREF
v8[1] = __readfsqword(0x28u);
std::vector<... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x0010191c
MOV dword ptr [RBP + -0x20],0x1
JMP 0x001012bd
LAB_001012a1:
LEA R... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int iVar1;
int *piVar2;
ulong uVar3;
long lVar4;
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_44;
int local_40;
int8 local_38;
int8 local_30;
int local_28;
... |
2,409 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(int n) {
std::vector<int> ludics;
for (int i = 1; i <= n; i++) {
ludics.push_back(i);
}
int index = 1;
while (index != ludics.size()) {
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < ludic... | int main() {
std::vector<int> result;
result = func0(10);
assert((result == std::vector<int>{1, 2, 3, 5, 7}));
result = func0(25);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25}));
result = func0(45);
assert((result == std::vector<int>{1, 2, 3, 5, ... | O1 | cpp | func0(int):
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)
movl $0x1,0x4(%rsp)
test %esi,%esi
jle 1308 <_Z5func0i+0x7f>
mov %esi,%ebx
mov $... | _Z5func0i:
endbr64
push r13
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 [rsp+38h+var_34], 1
test esi, esi
jle short loc_12... | long long * func0(long long *a1, int a2)
{
int i; // ebp
int *v5; // rsi
long long v6; // rdx
long long v7; // r13
char *v8; // rdx
long long v9; // rcx
unsigned long long v10; // rbp
_DWORD *v11; // rdi
_BYTE *v12; // rsi
signed long long v13; // rdx
int v14; // r12d
long long v15; // r12
int... | func0:
ENDBR64
PUSH R13
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 dword ptr [RSP + 0x4],0x1
TEST ESI,ESI
JLE 0x001012c6
MOV R12D,ESI
MOV EBP,0x1
LEA R1... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int4 *__src;
int4 *__dest;
int iVar1;
int *piVar2;
long lVar3;
int4 *puVar4;
size_t __n;
ulong uVar5;
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long lVar6;
long in_FS_OFFSET;
int loc... |
2,410 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(int n) {
std::vector<int> ludics;
for (int i = 1; i <= n; i++) {
ludics.push_back(i);
}
int index = 1;
while (index != ludics.size()) {
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < ludic... | int main() {
std::vector<int> result;
result = func0(10);
assert((result == std::vector<int>{1, 2, 3, 5, 7}));
result = func0(25);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25}));
result = func0(45);
assert((result == std::vector<int>{1, 2, 3, 5, ... | O2 | cpp | func0(int):
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)
movl $0x1,0x4(%rsp)
test %esi,%esi
jle 1806 <_Z5func0i+0x146>
mov %esi,%ebx
xor ... | _Z5func0i:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_34], 1
movups xmmword ptr [rdi], xmm0
test esi, esi
jle loc_1709
mov ... | long long * func0(long long *a1, int a2)
{
char *v3; // rax
int v5; // ebp
char *v6; // rsi
long long v7; // rdx
long long v8; // rbp
long long v9; // r13
unsigned long long v10; // rax
unsigned long long v11; // r12
long long v12; // r13
char *v13; // rdi
char *v14; // rax
int v16; // [rsp+0h] ... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x4],0x1
MOVUPS xmmword ptr [RDI],XMM0
TEST ESI,ESI
JLE 0x00101709
MOV R12D,ESI
MOV EBP,0x1
LEA R13,[RSP + ... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int4 *__dest;
int iVar1;
int *piVar2;
ulong uVar3;
size_t __n;
long lVar4;
ulong uVar5;
int in_ESI;
int *piVar6;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
ulong uVar7;
long in_FS_OFFSET;
int loc... |
2,411 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(int n) {
std::vector<int> ludics;
for (int i = 1; i <= n; i++) {
ludics.push_back(i);
}
int index = 1;
while (index != ludics.size()) {
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < ludic... | int main() {
std::vector<int> result;
result = func0(10);
assert((result == std::vector<int>{1, 2, 3, 5, 7}));
result = func0(25);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25}));
result = func0(45);
assert((result == std::vector<int>{1, 2, 3, 5, ... | O3 | cpp | func0(int):
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)
movl $0x1,0x4(%rsp)
movups %xmm0,(%rdi)
test %esi,%esi
jle 179d <_Z5func0i+0x17d>
mov %esi,%ebx
xor %e... | _Z5func0i:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_34], 1
movups xmmword ptr [rdi], xmm0
test esi, esi
jle loc_1709
mov ... | long long * func0(long long *a1, int a2)
{
char *v3; // rax
int v5; // ebp
char *v6; // rsi
long long v7; // rdx
long long v8; // rbp
long long v9; // r13
unsigned long long v10; // rax
unsigned long long v11; // r12
long long v12; // r13
char *v13; // rdi
char *v14; // rax
int v16; // [rsp+0h] ... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x4],0x1
MOVUPS xmmword ptr [RDI],XMM0
TEST ESI,ESI
JLE 0x00101709
MOV R12D,ESI
MOV EBP,0x1
LEA R13,[RSP + ... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int4 *__dest;
int iVar1;
int *piVar2;
ulong uVar3;
size_t __n;
long lVar4;
ulong uVar5;
int in_ESI;
int *piVar6;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
ulong uVar7;
long in_FS_OFFSET;
int loc... |
2,412 | func0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <cassert>
| std::string func0(const std::string& s) {
std::string temp = s;
std::reverse(temp.begin(), temp.end());
size_t start = 0;
size_t end = temp.find(" ");
while (end != std::string::npos) {
std::reverse(temp.begin() + start, temp.begin() + end);
start = end + 1;
end = tem... | int main() {
assert(func0("python program") == "program python");
assert(func0("java language") == "language java");
assert(func0("indian man") == "man indian");
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 %r12
push %rbx
sub $0x40,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x50(%rbp),%rdx
mov -0x48... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 40h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rdx, [rbp+var_50]
mov rax, [rbp+var_48]
mov rsi... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
long long v4; // rbx
long long v5; // r12
long long v6; // rbx
long long v7; // rax
long long v8; // r12
long long v9; // rbx
long long v10; // rax
long long v12; // [rsp+18h] [rbp-38h] BYREF
long long v13; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x40
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 RDX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
LAB_0010241d:
CALL 0x001021a0... | /* func0(std::string const&) */
string * func0(string *param_1)
{
long lVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
string *in_RSI;
long in_FS_OFFSET;
int8 local_40;
int8 local_38;
long local_30;
long local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::strin... |
2,413 | func0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <cassert>
| std::string func0(const std::string& s) {
std::string temp = s;
std::reverse(temp.begin(), temp.end());
size_t start = 0;
size_t end = temp.find(" ");
while (end != std::string::npos) {
std::reverse(temp.begin() + start, temp.begin() + end);
start = end + 1;
end = tem... | int main() {
assert(func0("python program") == "program python");
assert(func0("java language") == "language java");
assert(func0("indian man") == "man indian");
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 $0x18,%rsp
mov %rdi,%r12
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
mov %rax,(%rdi)
mov (%rsi),%rbp
mov 0x8(%r... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r12, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
lea rdi, [rdi+10h]
mov [r12], rdi
mov rbp, [rsi]
mov rbx, [rsi+8]
mov [rsp+38h+... | _QWORD * func0(_QWORD *a1, long long a2)
{
void *v3; // rdi
_BYTE *v4; // rbp
size_t v5; // rbx
long long v6; // rax
long long v7; // rbx
long long v8; // rbp
_QWORD v10[7]; // [rsp+0h] [rbp-38h] BYREF
v10[1] = __readfsqword(0x28u);
v3 = a1 + 2;
*a1 = v3;
v4 = *(_BYTE **)a2;
v5 = *(_QWORD *)(a2... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
LEA RDI,[RDI + 0x10]
MOV qword ptr [R12],RDI
MOV RBP,qword ptr [RSI]
MOV RBX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP],RBX
CMP RBX,0xf
JA 0x00101370
CMP RBX,0x1
JNZ 0x001013a... | /* func0(std::string const&) */
string * func0(string *param_1)
{
string *__src;
long lVar1;
string *__dest;
random_access_iterator_tag rVar2;
ulong uVar3;
int8 *in_RSI;
long in_FS_OFFSET;
int auVar4 [16];
ulong local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__dest = pa... |
2,414 | func0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <cassert>
| std::string func0(const std::string& s) {
std::string temp = s;
std::reverse(temp.begin(), temp.end());
size_t start = 0;
size_t end = temp.find(" ");
while (end != std::string::npos) {
std::reverse(temp.begin() + start, temp.begin() + end);
start = end + 1;
end = tem... | int main() {
assert(func0("python program") == "program python");
assert(func0("java language") == "language java");
assert(func0("indian man") == "man indian");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
mov %rdi,%r12
add $0x10,%rdi
push %rbp
push %rbx
sub $0x18,%rsp
mov 0x8(%rsi),%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov %rdi,(%r12)
mov (%rsi),%... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r12
push rbp
mov rbp, rdi
add rdi, 10h
push rbx
sub rsp, 10h
mov rbx, [rsi+8]
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
mov [rbp+0], rdi
mov r12, [rsi]
mov [rsp+28h+var_28], rbx
cmp... | long long * func0(long long *a1, long long a2)
{
void *v3; // rdi
size_t v4; // rbx
_BYTE *v5; // r12
char *v6; // rdx
long long v7; // rax
char *i; // rax
char v9; // cl
char v10; // si
long long v11; // r12
long long j; // rax
char *v13; // rcx
char *v14; // rdx
char *k; // rcx
char v16; /... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDI
ADD RDI,0x10
PUSH RBX
SUB RSP,0x10
MOV RBX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RBP],RDI
MOV R12,qword ptr [RSI]
MOV qword ptr [RSP],RBX
CMP RBX,0xf
JA 0x001015a0
CMP RBX,0x1
JNZ 0x00101595
MOVZX EAX,byte ... | /* func0(std::string const&) */
string * func0(string *param_1)
{
int uVar1;
string *__src;
int *puVar2;
long lVar3;
int *puVar4;
int *puVar5;
int *puVar6;
int8 *in_RSI;
string *__dest;
ulong uVar7;
long in_FS_OFFSET;
ulong local_28;
long local_20;
__dest = param_1 + 0x10;
uVar7 = in_... |
2,415 | func0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <cassert>
| std::string func0(const std::string& s) {
std::string temp = s;
std::reverse(temp.begin(), temp.end());
size_t start = 0;
size_t end = temp.find(" ");
while (end != std::string::npos) {
std::reverse(temp.begin() + start, temp.begin() + end);
start = end + 1;
end = tem... | int main() {
assert(func0("python program") == "program python");
assert(func0("java language") == "language java");
assert(func0("indian man") == "man indian");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
mov %rdi,%r12
add $0x10,%rdi
push %rbp
push %rbx
sub $0x18,%rsp
mov 0x8(%rsi),%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov %rdi,(%r12)
mov (%rsi),%... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r12
push rbp
mov rbp, rdi
add rdi, 10h
push rbx
sub rsp, 10h
mov rbx, [rsi+8]
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
mov [rbp+0], rdi
mov r12, [rsi]
mov [rsp+28h+var_28], rbx
cmp... | long long * func0(long long *a1, long long a2)
{
void *v3; // rdi
size_t v4; // rbx
_BYTE *v5; // r12
char *v6; // rdx
long long v7; // rax
char *i; // rax
char v9; // cl
char v10; // si
long long v11; // r12
long long j; // rax
char *v13; // rcx
char *v14; // rdx
char *k; // rcx
char v16; /... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDI
ADD RDI,0x10
PUSH RBX
SUB RSP,0x10
MOV RBX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RBP],RDI
MOV R12,qword ptr [RSI]
MOV qword ptr [RSP],RBX
CMP RBX,0xf
JA 0x001015a0
CMP RBX,0x1
JNZ 0x00101595
MOVZX EAX,byte ... | /* func0(std::string const&) */
string * func0(string *param_1)
{
int uVar1;
string *__src;
int *puVar2;
long lVar3;
int *puVar4;
int *puVar5;
int *puVar6;
int8 *in_RSI;
string *__dest;
ulong uVar7;
long in_FS_OFFSET;
ulong local_28;
long local_20;
__dest = param_1 + 0x10;
uVar7 = in_... |
2,416 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
} else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jle 11d3 <_Z5func0i+0x4a>
movl $0x2,-0x4(%rbp)
mov -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x4(%rbp)
jg 11cc <_Z5func0i+0x43>
mov -0x14(%rbp),%eax
cltd
id... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jle short loc_1193
mov [rbp+var_4], 2
jmp short loc_117B
loc_1163:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1177
mov eax, 0
jmp short loc_119... | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
if ( a1 <= 0 )
return 0LL;
for ( i = 2; i <= a1 / 2; ++i )
{
if ( !(a1 % i) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JLE 0x00101193
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0010117b
LAB_00101163:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101177
MOV EAX,0x0
JMP 0x00101198
LAB_00101177:
... | /* func0(int) */
int8 func0(int param_1)
{
int8 uVar1;
int local_c;
if (param_1 < 1) {
uVar1 = 0;
}
else {
for (local_c = 2; local_c <= param_1 / 2; local_c = local_c + 1) {
if (param_1 % local_c == 0) {
return 0;
}
}
uVar1 = 1;
}
return uVar1;
} |
2,417 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
} else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov $0x0,%eax
test %edi,%edi
jle 11c4 <_Z5func0i+0x3b>
mov %edi,%esi
shr $0x1f,%esi
add %edi,%esi
sar %esi
cmp $0x3,%edi
jle 11cb <_Z5func0i+0x42>
test $0x1,%dil
je 11d1 <_Z5func0i+0x48>
mov $0x2,%ecx
add $0x1,%ecx
cmp %esi,%ecx
jg 11c5 <_Z5func0i+0x3c>
m... | _Z5func0i:
endbr64
mov eax, 0
test edi, edi
jle short locret_1184
mov esi, edi
shr esi, 1Fh
add esi, edi
sar esi, 1
cmp edi, 3
jle short loc_118B
test dil, 1
jz short loc_1191
mov ecx, 2
loc_116F:
add ecx, 1
cmp ecx, esi
jg short loc_1185
mov eax, edi
cdq
... | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 <= 3 )
{
return 1LL;
}
else if ( (a1 & 1) != 0 )
{
v2 = 2;
while ( ++v2 <= a1 / 2 )
{
if ( !(a1 % v2) )
return 0LL;
}
return 1LL;
... | func0:
ENDBR64
MOV EAX,0x0
TEST EDI,EDI
JLE 0x00101184
MOV ESI,EDI
SHR ESI,0x1f
ADD ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x0010118b
TEST DIL,0x1
JZ 0x00101191
MOV ECX,0x2
LAB_0010116f:
ADD ECX,0x1
CMP ECX,ESI
JG 0x00101185
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010116f
MOV EAX,0x0
LAB_00101184:
RET
LAB_00101185:
M... | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
if (0 < param_1) {
if (param_1 < 4) {
return 1;
}
if ((param_1 & 1U) == 0) {
return 0;
}
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if (param_1 / 2 < iVar1) {
return 1;
}
} while (param_1 % iVar1 != ... |
2,418 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
} else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O2 | cpp | func0(int):
endbr64
xor %eax,%eax
test %edi,%edi
jle 1202 <_Z5func0i+0x42>
mov %edi,%esi
sar %esi
cmp $0x3,%edi
jle 11f8 <_Z5func0i+0x38>
test $0x1,%dil
je 1202 <_Z5func0i+0x42>
add $0x1,%esi
mov $0x2,%ecx
jmp 11f1 <_Z5func0i+0x31>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv ... | _Z5func0i:
endbr64
xor eax, eax
test edi, edi
jle short locret_1182
mov esi, edi
sar esi, 1
cmp edi, 3
jle short loc_1178
test dil, 1
jz short locret_1182
add esi, 1
mov ecx, 2
jmp short loc_1171
loc_1168:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc... | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 > 3 )
{
if ( (a1 & 1) == 0 )
return result;
v2 = 2;
while ( ++v2 != (a1 >> 1) + 1 )
{
if ( !(a1 % v2) )
return 0LL;
}
}
return 1LL;
... | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x00101182
MOV ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x00101178
TEST DIL,0x1
JZ 0x00101182
ADD ESI,0x1
MOV ECX,0x2
JMP 0x00101171
LAB_00101168:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101171:
ADD ECX,0x1
CMP ECX,ESI
JNZ 0x00101168
LAB_00101178:
MOV EAX,0x1
RET... | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
if (0 < param_1) {
if (param_1 < 4) {
return 1;
}
if ((param_1 & 1U) != 0) {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if (iVar1 == (param_1 >> 1) + 1) {
return 1;
}
} while (param_1 % iVar1 != ... |
2,419 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
} else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O3 | cpp | func0(int):
endbr64
xor %eax,%eax
test %edi,%edi
jle 1202 <_Z5func0i+0x42>
mov %edi,%esi
sar %esi
cmp $0x3,%edi
jle 11f8 <_Z5func0i+0x38>
test $0x1,%dil
je 1202 <_Z5func0i+0x42>
add $0x1,%esi
mov $0x2,%ecx
jmp 11f1 <_Z5func0i+0x31>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv ... | _Z5func0i:
endbr64
xor eax, eax
test edi, edi
jle short locret_1182
mov esi, edi
sar esi, 1
cmp edi, 3
jle short loc_1178
test dil, 1
jz short locret_1182
add esi, 1
mov ecx, 2
jmp short loc_1171
loc_1168:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc... | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 > 3 )
{
if ( (a1 & 1) == 0 )
return result;
v2 = 2;
while ( ++v2 != (a1 >> 1) + 1 )
{
if ( !(a1 % v2) )
return 0LL;
}
}
return 1LL;
... | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x00101182
MOV ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x00101178
TEST DIL,0x1
JZ 0x00101182
ADD ESI,0x1
MOV ECX,0x2
JMP 0x00101171
LAB_00101168:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101171:
ADD ECX,0x1
CMP ECX,ESI
JNZ 0x00101168
LAB_00101178:
MOV EAX,0x1
RET... | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
if (0 < param_1) {
if (param_1 < 4) {
return 1;
}
if ((param_1 & 1U) != 0) {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if (iVar1 == (param_1 >> 1) + 1) {
return 1;
}
} while (param_1 % iVar1 != ... |
2,420 | func0 |
#include <cmath>
#include <cassert>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O0 | cpp | func0(double):
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf65(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| _Z5func0d:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_20A8
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 0.0174532925199433 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x001020a8]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | /* func0(double) */
double func0(double param_1)
{
return DAT_001020a8 * param_1;
} |
2,421 | func0 |
#include <cmath>
#include <cassert>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O1 | cpp | func0(double):
endbr64
mulsd 0xed3(%rip),%xmm0
retq
| _Z5func0d:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 0.0174532925199433;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double) */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
2,422 | func0 |
#include <cmath>
#include <cassert>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O2 | cpp | func0(double):
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| _Z5func0d:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 0.0174532925199433;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double) */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
2,423 | func0 |
#include <cmath>
#include <cassert>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O3 | cpp | func0(double):
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| _Z5func0d:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 0.0174532925199433;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double) */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
2,424 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::tuple<std::string, int, int> func0(const std::string& text, const std::string& pattern) {
std::smatch match;
std::regex re(pattern);
if (std::regex_search(text, match, re)) {
return {match.str(), match.position(), match.position() + match.length()};
}
throw std::runtime_error("Pat... | int main() {
assert((func0("The quick brown fox jumps over the lazy dog.", "fox") == std::make_tuple("fox", 16, 19)));
assert((func0("Its been a very crazy procedure right", "crazy") == std::make_tuple("crazy", 16, 21)));
assert((func0("Hardest choices required strongest will", "will") == std::make_tuple... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0xa0,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %rd... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 0A0h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov [rbp+var_A8], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_80]
mov ... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rbx
std::runtime_error *exception; // rbx
long long v7; // [rsp+20h] [rbp-90h] BYREF
long long v8; // [rsp+28h] [rbp-88h] BYREF
_BYTE v9[32]; // [rsp+30h] [rbp-80h] BYREF
_BYTE v10[32]; // [rsp+50h] [rbp-60h] BYREF
_BYTE v11[40]... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV qword ptr [RBP + -0xa8],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x80]
MOV RDI,RAX
CALL 0x00106534
MOV RCX,qword ptr [RBP + -0xa8]
LEA... | /* func0(std::string const&, std::string const&) */
string * func0(string *param_1,string *param_2)
{
bool bVar1;
long lVar2;
runtime_error *this;
string *in_RDX;
long in_FS_OFFSET;
long local_98;
long local_90;
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__n... |
2,425 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::tuple<std::string, int, int> func0(const std::string& text, const std::string& pattern) {
std::smatch match;
std::regex re(pattern);
if (std::regex_search(text, match, re)) {
return {match.str(), match.position(), match.position() + match.length()};
}
throw std::runtime_error("Pat... | int main() {
assert((func0("The quick brown fox jumps over the lazy dog.", "fox") == std::make_tuple("fox", 16, 19)));
assert((func0("Its been a very crazy procedure right", "crazy") == std::make_tuple("crazy", 16, 21)));
assert((func0("Hardest choices required strongest will", "will") == std::make_tuple... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1f0,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
endbr64
push rbp
mov rbp, rsp
push r14
push r13
push r12
push rbx
sub rsp, 1F0h
mov rbx, rdi
mov r14, rsi
mov r12, rdx
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov [rbp+var_200], 0
mov [rb... | long long func0(long long a1, long long a2, _QWORD *a3)
{
long long v6; // rsi
long long v7; // rdx
long long v8; // rax
long long v9; // r12
volatile signed __int32 *v10; // rcx
long long v11; // rdx
signed __int32 v12; // eax
_DWORD *v13; // r12
volatile signed __int32 *v14; // rcx
long long v15;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1f0
MOV RBX,RDI
MOV R14,RSI
MOV R12,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV qword ptr [RBP + -0x200],0x0
MOV qword ptr [RBP + -0x1f8],0x0
MOV qword ptr [RBP + -0x1f0],0x0
MOV qword ptr [RBP + -0x1e8... | /* func0(std::string const&, std::string const&) */
string * func0(string *param_1,string *param_2)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int *__src;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
bool bVar3;
uint uVar4;
int8 *puVar5;
runtime_error *this;
ulong uVar6;
int iVar7;
uint uVar8;
i... |
2,426 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::tuple<std::string, int, int> func0(const std::string& text, const std::string& pattern) {
std::smatch match;
std::regex re(pattern);
if (std::regex_search(text, match, re)) {
return {match.str(), match.position(), match.position() + match.length()};
}
throw std::runtime_error("Pat... | int main() {
assert((func0("The quick brown fox jumps over the lazy dog.", "fox") == std::make_tuple("fox", 16, 19)));
assert((func0("Its been a very crazy procedure right", "crazy") == std::make_tuple("crazy", 16, 21)));
assert((func0("Hardest choices required strongest will", "will") == std::make_tuple... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x208,%rsp
mov ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
endbr64
push rbp
pxor xmm0, xmm0
mov rbp, rsp
push r15
mov r15, rsi
push r14
lea r14, [rbp+var_1D0]
push r13
mov r13, rdx
push r12
lea r12, [rbp+var_1E8]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub r... | long long func0(long long a1, _QWORD *a2, long long *a3)
{
long long v6; // rsi
long long v7; // rdx
__m128i v8; // xmm0
volatile signed __int32 *v9; // r13
long long v10; // rdx
volatile signed __int32 *v11; // rcx
signed __int32 v12; // eax
long long v13; // r13
long long v14; // rdx
volatile sig... | func0:
ENDBR64
PUSH RBP
PXOR XMM0,XMM0
MOV RBP,RSP
PUSH R15
MOV R15,RSI
PUSH R14
LEA R14,[RBP + -0x1d0]
PUSH R13
MOV R13,RDX
PUSH R12
LEA R12,[RBP + -0x1e8]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x218
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RBP + -0x210],XMM0
MOVAP... | /* func0(std::string const&, std::string const&) */
string * func0(string *param_1,string *param_2)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
char cVar2;
int *__src;
int8 uVar3;
int8 uVar4;
bool bVar5;
uint uVar6;
long lVar7;
string *psVar8;
int8 *puVar9;
int iVar10;
uint uVar11;
int8 *in... |
2,427 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::tuple<std::string, int, int> func0(const std::string& text, const std::string& pattern) {
std::smatch match;
std::regex re(pattern);
if (std::regex_search(text, match, re)) {
return {match.str(), match.position(), match.position() + match.length()};
}
throw std::runtime_error("Pat... | int main() {
assert((func0("The quick brown fox jumps over the lazy dog.", "fox") == std::make_tuple("fox", 16, 19)));
assert((func0("Its been a very crazy procedure right", "crazy") == std::make_tuple("crazy", 16, 21)));
assert((func0("Hardest choices required strongest will", "will") == std::make_tuple... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
mov %rsi,%r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
endbr64
push rbp
pxor xmm0, xmm0
mov rbp, rsp
push r15
mov r15, rsi
push r14
mov r14, rdx
push r13
lea r13, [rbp+var_1D0]
push r12
lea r12, [rbp+var_1E8]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub r... | long long func0(long long a1, long long *a2, long long *a3)
{
long long v6; // rsi
long long v7; // rdx
__m128i v8; // xmm0
long long v9; // rdi
void *v10; // rdi
unsigned long long v11; // r14
long long v12; // rdi
long long v13; // rsi
long long v14; // rax
long long v15; // rsi
long long v16; ... | func0:
ENDBR64
PUSH RBP
PXOR XMM0,XMM0
MOV RBP,RSP
PUSH R15
MOV R15,RSI
PUSH R14
MOV R14,RDX
PUSH R13
LEA R13,[RBP + -0x1d0]
PUSH R12
LEA R12,[RBP + -0x1e8]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x218
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RBP + -0x210],XMM0
MOVAP... | /* func0(std::string const&, std::string const&) */
string * func0(string *param_1,string *param_2)
{
char cVar1;
int *__src;
int8 this;
int auVar2 [16];
bool bVar3;
uint uVar4;
string *psVar5;
int8 *puVar6;
ulong uVar7;
int iVar8;
uint uVar9;
int8 *in_RDX;
string *psVar10;
long lVar11;
... |
2,428 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<std::vector<int>> bell(n+1, std::vector<int>(n+1, 0));
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
... | int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %edi,-0x64(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x5d(%rbp),%rax
mov %rax,%rdi
callq 16c2 <_ZNSaISt6vectorIiSaIiEEEC1Ev>
lea -0x5e(%rbp),%rax
mov %rax,%rdi
callq 15b2 <_ZNSaIiEC1Ev>
mov... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_74], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_6D]
mov [rbp+var_58], rax
nop
nop
lea rax, [rbp+var_6E]
mov [rbp+var_60], rax
nop
nop
mov [rbp+var_6C], 0
mov ea... | long long func0(int a1)
{
long long v1; // rax
long long v2; // rax
int v3; // ebx
long long v4; // rax
long long v5; // rax
int v6; // ebx
long long v7; // rax
int v8; // ebx
long long v9; // rax
long long v10; // rax
unsigned int v11; // ebx
char v13; // [rsp+12h] [rbp-6Eh] BYREF
char v14; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV dword ptr [RBP + -0x74],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x6d]
MOV qword ptr [RBP + -0x58],RAX
NOP
NOP
LEA RAX,[RBP + -0x6e]
MOV qword ptr [RBP + -0x60],RAX
NOP
NOP
MOV dword ptr [RBP + -0x6c],0x0
MO... | /* func0(int) */
int4 func0(int param_1)
{
int iVar1;
int iVar2;
int4 uVar3;
vector<int,std::allocator<int>> *pvVar4;
int4 *puVar5;
int *piVar6;
long in_FS_OFFSET;
allocator local_76;
allocator local_75;
int local_74;
int local_70;
int local_6c;
allocator *local_68;
allocator *local_60;
... |
2,429 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<std::vector<int>> bell(n+1, std::vector<int>(n+1, 0));
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
... | int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,0xc(%rsp)
lea 0x1(%rdi),%ebp
movslq %ebp,%rbp
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rbp
ja 12d3 <_Z5func0i+0x6a>
test %rbp,%rbp
je 1477 <_Z5func0i+0x20e>
lea 0x0(,%rbp,4),%r12... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
lea ebx, [rdi+1]
movsxd rbx, ebx
mov rax, rbx
shr rax, 3Dh
jnz short loc_130C
mov r13d, edi
test rbx, rbx
jz loc_144... | long long func0(int a1)
{
unsigned long long v1; // rbx
unsigned long long v2; // r15
_DWORD *v3; // rax
void *v4; // r14
_DWORD *v5; // rdx
long long v6; // rbx
_DWORD **v7; // r9
long long v8; // r8
int v9; // r10d
unsigned long long v10; // rax
_DWORD *v11; // rcx
int v12; // edx
unsigned ... | func0:
ENDBR64
PUSH R15
PUSH R14
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
LEA EBX,[RDI + 0x1]
MOVSXD RBX,EBX
MOV RAX,RBX
SHR RAX,0x3d
JNZ 0x0010130c
MOV R13D,EDI
TEST RBX,RBX
JZ 0x0010144f
LEA R15,[RBX*0x4]
MOV RDI,R15
LAB_001012d1:
CALL 0x0... | /* func0(int) */
int4 func0(int param_1)
{
int *piVar1;
int *piVar2;
int4 uVar3;
void *pvVar4;
int4 *puVar5;
int4 *puVar6;
vector *pvVar7;
long lVar8;
vector *pvVar9;
ulong uVar10;
long lVar11;
vector *pvVar12;
int iVar13;
ulong uVar14;
long in_FS_OFFSET;
int4 *local_58;
int4 *local_... |
2,430 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<std::vector<int>> bell(n+1, std::vector<int>(n+1, 0));
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
... | int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
return 0;
}
| O2 | cpp | func0(int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r15
push %r14
push %r13
push %r12
push %rbp
lea 0x1(%rdi),%ebp
push %rbx
movslq %ebp,%rbp
sub $0x18,%rsp
mov %edi,0xc(%rsp)
cmp %rax,%rbp
ja 1542 <_Z5func0i+0x1e2>
test %rbp,%rbp
je 1512 <_Z5func0i+0x1b2>
lea 0x0(,%rbp,4),%r1... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov ebx, edi
lea ebp, [rbx+1]
movsxd rbp, ebp
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov rax, rbp
shr rax, 3Dh
jnz loc_154A
pxor xmm0, xmm0
lea r13, [rbp+rb... | long long func0(unsigned int a1)
{
long long v1; // rbx
unsigned long long v2; // rbp
unsigned long long v3; // r13
void *v4; // r14
long long *v5; // r12
unsigned long long v6; // rsi
long long v7; // rbp
long long *v8; // r8
long long v9; // rcx
int v10; // edx
int *v11; // rsi
long long v12;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
LEA EBP,[RBX + 0x1]
MOVSXD RBP,EBP
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x0010154a
PXOR XMM0,XMM0
LEA R13,[RBP + RBP*0x2]
MOVUPS xmmword ptr [RSP + 0x18],XMM0
SHL ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int4 func0(int param_1)
{
int4 uVar1;
int *piVar2;
long lVar3;
void *pvVar4;
vector *pvVar5;
vector *pvVar6;
ulong uVar7;
int iVar8;
ulong uVar9;
vector *pvVar10;
ulong uVar11;
long in_FS_OFFS... |
2,431 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<std::vector<int>> bell(n+1, std::vector<int>(n+1, 0));
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
... | int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
return 0;
}
| O3 | cpp | func0(int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r15
push %r14
lea 0x1(%rdi),%r14d
push %r13
movslq %r14d,%r14
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,0xc(%rsp)
cmp %rax,%r14
ja 15bf <_Z5func0i+0x23f>
test %r14,%r14
je 1595 <_Z5func0i+0x215>
lea 0x0(,%r14,4),%... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov ebx, edi
lea ebp, [rbx+1]
movsxd rbp, ebp
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov rax, rbp
shr rax, 3Dh
jnz loc_155B
pxor xmm0, xmm0
lea r13, [rbp+rb... | long long func0(unsigned int a1)
{
long long v1; // rbx
unsigned long long v2; // rbp
unsigned long long v3; // r13
void *v4; // r14
long long *v5; // r12
unsigned long long v6; // rsi
long long v7; // rbp
long long *v8; // r8
long long v9; // rcx
int v10; // edx
int *v11; // rsi
long long v12;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
LEA EBP,[RBX + 0x1]
MOVSXD RBP,EBP
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x0010155b
PXOR XMM0,XMM0
LEA R13,[RBP + RBP*0x2]
MOVUPS xmmword ptr [RSP + 0x18],XMM0
SHL ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int4 func0(int param_1)
{
int4 uVar1;
int *piVar2;
long lVar3;
void *pvVar4;
vector *pvVar5;
vector *pvVar6;
ulong uVar7;
int iVar8;
ulong uVar9;
vector *pvVar10;
ulong uVar11;
long in_FS_OFFS... |
2,432 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::max(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x18(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x10(%rbp)
lea -0x1c(%rbp),%rdx
lea -0x10(%rbp),%r... | _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_18]
sub eax, 1
mov [rbp+var_10], eax
lea rdx, [rbp+var_1C]
lea rax, [rbp+va... | long long func0(int a1, int a2, int a3)
{
int v4; // [rsp+4h] [rbp-1Ch] BYREF
int v5; // [rsp+8h] [rbp-18h]
int v6; // [rsp+Ch] [rbp-14h]
int v7; // [rsp+10h] [rbp-10h] BYREF
int v8; // [rsp+14h] [rbp-Ch]
unsigned long long v9; // [rsp+18h] [rbp-8h]
v6 = a1;
v5 = a2;
v4 = a3;
v9 = __readfsqword(0x... | 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 + -0x1c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
LEA RDX,[RBP + -0x1c]
LEA RA... | /* func0(int, int, int) */
ulong func0(int param_1,int param_2,int param_3)
{
int *piVar1;
long in_FS_OFFSET;
int local_24;
int local_20;
int local_1c;
int local_18;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = param_2 + -1;
local_24 = param_3;
local_20... |
2,433 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::max(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
lea -0x1(%rsi),%ecx
cmp %edx,%ecx
mov %edx,%eax
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
| _Z5func0iii:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | /* func0(int, int, int) */
int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
r... |
2,434 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::max(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
lea -0x1(%rsi),%ecx
mov %edx,%eax
cmp %edx,%ecx
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0iii:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | /* func0(int, int, int) */
int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
r... |
2,435 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::max(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
lea -0x1(%rsi),%ecx
mov %edx,%eax
cmp %edx,%ecx
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0iii:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | /* func0(int, int, int) */
int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
r... |
2,436 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> list1, int L) {
list1.erase(list1.begin() + L - 1);
return list1;
}
| int main() {
assert((func0({1,1,2,3,4,4,5,1},3) == std::vector<int>{1, 1, 3, 4, 4, 5, 1}));
assert((func0({0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4},4) == std::vector<int>{0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}));
assert((func0({10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10},5) == std::vecto... | O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %edx,-0x54(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x54(%rbp),%eax
movslq %eax,%rbx
mov -0x50(%rbp),%rax
mo... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov [rbp+var_54], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_54]
movsxd rbx, eax
mov rax, [rbp+var_50]
mov rdi, rax... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rbx
long long v5; // [rsp+28h] [rbp-38h] BYREF
long long v6; // [rsp+30h] [rbp-30h] BYREF
long long v7; // [rsp+38h] [rbp-28h] BYREF
_QWORD v8[3]; // [rsp+40h] [rbp-20h] BYREF
v8[1] = __readfsqword(0x28u);
v3 = a3;
v5 = std::vector... | 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 EAX,dword ptr [RBP + -0x54]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CAL... | /* func0(std::vector<int, std::allocator<int> >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
int in_EDX;
int4 in_register_00000034;
vector<int,std::allocator<int>> *this;
int4 in_register_0000003c;
long in_FS_OFFSET;
int8 local_40;
int8 local_38;
int8 local_30;
int8... |
2,437 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> list1, int L) {
list1.erase(list1.begin() + L - 1);
return list1;
}
| int main() {
assert((func0({1,1,2,3,4,4,5,1},3) == std::vector<int>{1, 1, 3, 4, 4, 5, 1}));
assert((func0({0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4},4) == std::vector<int>{0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}));
assert((func0({10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10},5) == std::vecto... | O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov (%rsi),%rcx
movslq %edx,%rax
shl $0x2,%rax
lea (%rcx,%rax,1),%rsi
mov 0x8(%rbx),%rdx
cmp %rdx,%rsi
je 127d <_Z5func0St6vectorIiSaIiEEi+0x34>
sub %rsi,%rdx
lea ... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
mov rcx, [rsi]
movsxd rax, edx
shl rax, 2
mov rdx, [rsi+8]
lea rsi, [rcx+rax]; src
cmp rdx, rsi
jz short loc_1283
lea rdi, [rcx+rax-4]; dest
sub rdx, rsi; n
cmp rdx, 4
jle ... | long long * func0(long long *a1, long long *a2, int a3)
{
long long v5; // rcx
long long v6; // rax
char *v7; // rdx
char *v8; // rsi
_DWORD *v9; // rdi
signed long long v10; // rdx
long long v11; // rax
v5 = *a2;
v6 = 4LL * a3;
v7 = (char *)a2[1];
v8 = (char *)(*a2 + v6);
if ( v7 != v8 )
{
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
MOV RCX,qword ptr [RSI]
MOVSXD RAX,EDX
SHL RAX,0x2
MOV RDX,qword ptr [RSI + 0x8]
LEA RSI,[RCX + RAX*0x1]
CMP RDX,RSI
JZ 0x00101283
LEA RDI,[RCX + RAX*0x1 + -0x4]
SUB RDX,RSI
CMP RDX,0x4
JLE 0x001012bf
CALL 0x00101140
LAB_00101283:
MOV RAX,qword ptr [R... | /* func0(std::vector<int, std::allocator<int> >, int) */
long * func0(vector param_1,int param_2)
{
int4 *__src;
int4 *__dest;
long lVar1;
int in_EDX;
size_t __n;
int4 in_register_00000034;
long *plVar2;
int4 in_register_0000003c;
long *plVar3;
plVar3 = (long *)CONCAT44(in_register_0000003c,par... |
2,438 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> list1, int L) {
list1.erase(list1.begin() + L - 1);
return list1;
}
| int main() {
assert((func0({1,1,2,3,4,4,5,1},3) == std::vector<int>{1, 1, 3, 4, 4, 5, 1}));
assert((func0({0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4},4) == std::vector<int>{0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}));
assert((func0({10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10},5) == std::vecto... | O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r12
movslq %edx,%rdx
mov %rdi,%r12
push %rbx
mov %rsi,%rbx
mov %rbx,%rdi
sub $0x8,%rsp
mov (%rsi),%rax
lea -0x4(%rax,%rdx,4),%rsi
callq 1960 <_ZNSt6vectorIiSaIiEE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPiS1_EE>
mov (%rbx),%rax
... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
movsxd rdx, edx
mov rbp, rdi
push rbx
shl rdx, 2
mov rbx, rsi
sub rsp, 8
mov rax, [rsi]
mov rcx, [rsi+8]
lea rsi, [rax+rdx]; src
cmp rcx, rsi
jz short loc_1694
lea rdi, [rax+rdx-4]; dest
mov rdx, rcx
sub rdx, rsi; n
cmp... | _QWORD * func0(_QWORD *a1, long long *a2, int a3)
{
long long v3; // rdx
long long v5; // rax
char *v6; // rcx
char *v7; // rsi
long long v8; // rax
_QWORD *result; // rax
v3 = 4LL * a3;
v5 = *a2;
v6 = (char *)a2[1];
v7 = (char *)(*a2 + v3);
if ( v6 != v7 )
{
if ( v6 - v7 <= 4 )
{
... | func0:
ENDBR64
PUSH RBP
MOVSXD RDX,EDX
MOV RBP,RDI
PUSH RBX
SHL RDX,0x2
MOV RBX,RSI
SUB RSP,0x8
MOV RAX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8]
LEA RSI,[RAX + RDX*0x1]
CMP RCX,RSI
JZ 0x00101694
LEA RDI,[RAX + RDX*0x1 + -0x4]
MOV RDX,RCX
SUB RDX,RSI
CMP RDX,0x4
JLE 0x001016c8
CALL 0x00101140
MOV RAX,qword ptr [RBX... | /* func0(std::vector<int, std::allocator<int> >, int) */
long * func0(long *param_1,int (*param_2) [16],int param_3)
{
int4 *__dest;
void *pvVar1;
long lVar2;
size_t __n;
void *__src;
lVar2 = *(long *)*param_2;
pvVar1 = *(void **)(*param_2 + 8);
__src = (void *)(lVar2 + (long)param_3 * 4);
if (pv... |
2,439 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> list1, int L) {
list1.erase(list1.begin() + L - 1);
return list1;
}
| int main() {
assert((func0({1,1,2,3,4,4,5,1},3) == std::vector<int>{1, 1, 3, 4, 4, 5, 1}));
assert((func0({0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4},4) == std::vector<int>{0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}));
assert((func0({10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10},5) == std::vecto... | O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r12
movslq %edx,%rax
mov %rdi,%r12
push %rbx
shl $0x2,%rax
mov %rsi,%rbx
sub $0x8,%rsp
mov (%rsi),%rcx
mov 0x8(%rsi),%rdx
lea (%rcx,%rax,1),%rsi
cmp %rsi,%rdx
je 16ec <_Z5func0St6vectorIiSaIiEEi+0x3c>
sub %rsi,%rdx
lea ... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
movsxd rdx, edx
mov rbp, rdi
push rbx
shl rdx, 2
mov rbx, rsi
sub rsp, 8
mov rax, [rsi]
mov rcx, [rsi+8]
lea rsi, [rax+rdx]; src
cmp rcx, rsi
jz short loc_1764
lea rdi, [rax+rdx-4]; dest
mov rdx, rcx
sub rdx, rsi; n
cmp... | _QWORD * func0(_QWORD *a1, long long *a2, int a3)
{
long long v4; // rdx
long long v6; // rax
char *v7; // rcx
char *v8; // rsi
_DWORD *v9; // rdi
long long v10; // rax
_QWORD *result; // rax
v4 = 4LL * a3;
v6 = *a2;
v7 = (char *)a2[1];
v8 = (char *)(*a2 + v4);
if ( v7 != v8 )
{
v9 = (_DW... | func0:
ENDBR64
PUSH RBP
MOVSXD RDX,EDX
MOV RBP,RDI
PUSH RBX
SHL RDX,0x2
MOV RBX,RSI
SUB RSP,0x8
MOV RAX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8]
LEA RSI,[RAX + RDX*0x1]
CMP RCX,RSI
JZ 0x00101764
LEA RDI,[RAX + RDX*0x1 + -0x4]
MOV RDX,RCX
SUB RDX,RSI
CMP RDX,0x4
JLE 0x00101798
CALL 0x00101140
MOV RAX,qword ptr [RBX... | /* func0(std::vector<int, std::allocator<int> >, int) */
long * func0(long *param_1,int (*param_2) [16],int param_3)
{
int4 *__src;
int4 *__dest;
int4 *puVar1;
long lVar2;
size_t __n;
int4 *puVar3;
lVar2 = *(long *)*param_2;
puVar1 = *(int4 **)(*param_2 + 8);
__src = (int4 *)(lVar2 + (long)param_... |
2,440 | func0 |
#include <vector>
#include <assert.h>
#include <algorithm>
#include <climits>
| int func0(const std::vector<std::vector<int>>& test_list, int N) {
int res = INT_MIN;
for (const auto& sub : test_list) {
res = std::max(res, sub[N]);
}
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 19);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 10);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 1) == 11);
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
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x80000000,-0x2c(%... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_2C], 80000000h
mov rax, [rbp+var_38]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
m... | long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v4; // [rsp+14h] [rbp-2Ch] BYREF
long long v5; // [rsp+18h] [rbp-28h] BYREF
_QWORD v6[2]; // [rsp+20h] [rbp-20h] BYREF
long long v7; // [rsp+30h] [rbp-10h]
unsigned long long v8; // [rsp+38h] [rbp-8h]
v8 = __readfsqword(0x28u);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x2c],0x80000000
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
M... | /* 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)
{
bool bVar1;
int *piVar2;
long in_FS_OFFSET;
int local_34;
int8 local_30;
int8 local_28;
vector<std::vector<int,std::allocator... |
2,441 | func0 |
#include <vector>
#include <assert.h>
#include <algorithm>
#include <climits>
| int func0(const std::vector<std::vector<int>>& test_list, int N) {
int res = INT_MIN;
for (const auto& sub : test_list) {
res = std::max(res, sub[N]);
}
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 19);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 10);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 1) == 11);
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movl $0x80000000,0x4(%rsp)
mov (%rdi),%rdx
mov 0x8(%rdi),%rdi
cmp %rdi,%rdx
je 1306 <_Z5f... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
sub rsp, 18h
mov rax, fs:28h
mov [rsp+18h+var_10], rax
xor eax, eax
mov [rsp+18h+var_14], 80000000h
mov rax, [rdi]
mov rdi, [rdi+8]
cmp rdi, rax
jz short loc_130B
movsxd rsi, esi
lea rcx, ds:0[rsi*4]
lea rsi, [rsp+18h+var_14]... | long long func0(long long a1, int a2)
{
_QWORD *v2; // rax
_QWORD *i; // rdi
unsigned int *v4; // rdx
unsigned int v6; // [rsp+4h] [rbp-14h] BYREF
unsigned long long v7; // [rsp+8h] [rbp-10h]
v7 = __readfsqword(0x28u);
v6 = 0x80000000;
v2 = *(_QWORD **)a1;
for ( i = *(_QWORD **)(a1 + 8); i != v2; v2... | func0:
ENDBR64
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x4],0x80000000
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RAX
JZ 0x0010130b
MOVSXD RSI,ESI
LEA RCX,[RSI*0x4]
LEA RSI,[RSP + 0x4]
JMP 0x001012f6
LAB_001012e7:
MOV EDX,dword ptr [RDX]... | /* 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;
long in_FS_OFFSET;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
loca... |
2,442 | func0 |
#include <vector>
#include <assert.h>
#include <algorithm>
#include <climits>
| int func0(const std::vector<std::vector<int>>& test_list, int N) {
int res = INT_MIN;
for (const auto& sub : test_list) {
res = std::max(res, sub[N]);
}
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 19);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 10);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 1) == 11);
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdi
cmp %rdi,%rax
je 17b8 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x48>
movslq %esi,%rsi
mov $0x80000000,%r8d
lea 0x0(,%rsi,4),%rcx... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
mov rax, [rdi]
mov rdi, [rdi+8]
cmp rdi, rax
jz short loc_1840
movsxd rsi, esi
mov edx, 80000000h
shl rsi, 2
nop dword ptr [rax+00h]
loc_1820:
mov rcx, [rax]
mov ecx, [rcx+rsi]
cmp edx, ecx
cmovl edx, ecx
add rax, 18h
cmp ... | long long func0(long long a1, int a2)
{
_QWORD *v2; // rax
_QWORD *v3; // rdi
unsigned int v4; // edx
long long v5; // rsi
v2 = *(_QWORD **)a1;
v3 = *(_QWORD **)(a1 + 8);
if ( v3 == v2 )
return 0x80000000LL;
v4 = 0x80000000;
v5 = 4LL * a2;
do
{
if ( (signed int)v4 < *(_DWORD *)(*v2 + v5)... | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RAX
JZ 0x00101840
MOVSXD RSI,ESI
MOV EDX,0x80000000
SHL RSI,0x2
NOP dword ptr [RAX]
LAB_00101820:
MOV RCX,qword ptr [RAX]
MOV ECX,dword ptr [RCX + RSI*0x1]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x18
CMP RDI,RAX
JNZ 0x00101820
MOV EAX,EDX
RET
LAB_0... | /* 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)
{
int iVar1;
long *plVar2;
int iVar3;
plVar2 = *(long **)param_1;
if (*(long **)(param_1 + 8) != plVar2) {
iVar3 = -0x800000... |
2,443 | func0 |
#include <vector>
#include <assert.h>
#include <algorithm>
#include <climits>
| int func0(const std::vector<std::vector<int>>& test_list, int N) {
int res = INT_MIN;
for (const auto& sub : test_list) {
res = std::max(res, sub[N]);
}
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 19);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 10);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 1) == 11);
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdi
cmp %rdi,%rax
je 1848 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x48>
movslq %esi,%rsi
mov $0x80000000,%r8d
lea 0x0(,%rsi,4),%rcx... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
mov rax, [rdi]
mov rdi, [rdi+8]
cmp rdi, rax
jz short loc_18F0
movsxd rsi, esi
mov edx, 80000000h
shl rsi, 2
nop dword ptr [rax+00h]
loc_18D0:
mov rcx, [rax]
mov ecx, [rcx+rsi]
cmp edx, ecx
cmovl edx, ecx
add rax, 18h
cmp ... | long long func0(long long a1, int a2)
{
_QWORD *v2; // rax
_QWORD *v3; // rdi
unsigned int v4; // edx
long long v5; // rsi
v2 = *(_QWORD **)a1;
v3 = *(_QWORD **)(a1 + 8);
if ( v3 == v2 )
return 0x80000000LL;
v4 = 0x80000000;
v5 = 4LL * a2;
do
{
if ( (signed int)v4 < *(_DWORD *)(*v2 + v5)... | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RAX
JZ 0x001018f0
MOVSXD RSI,ESI
MOV EDX,0x80000000
SHL RSI,0x2
NOP dword ptr [RAX]
LAB_001018d0:
MOV RCX,qword ptr [RAX]
MOV ECX,dword ptr [RCX + RSI*0x1]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x18
CMP RDI,RAX
JNZ 0x001018d0
MOV EAX,EDX
RET
LAB_0... | /* 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)
{
int iVar1;
long *plVar2;
int iVar3;
plVar2 = *(long **)param_1;
if (*(long **)(param_1 + 8) != plVar2) {
iVar3 = -0x800000... |
2,444 | func0 |
#include <vector>
#include <cassert>
| std::vector<std::vector<char>> func0(const std::vector<std::vector<char>>& lst) {
std::vector<std::vector<char>> result;
if (!lst.empty()) {
size_t numColumns = lst[0].size();
for (size_t i = 0; i < numColumns; ++i) {
std::vector<char> columnVector;
for (const auto&... | int main() {
// Test case 1
std::vector<std::vector<char>> input1 = {{'x', 'y'}, {'a', 'b'}, {'m', 'n'}};
std::vector<std::vector<char>> expected1 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}};
assert(func0(input1) == expected1);
// Test case 2
std::vector<std::vector<char>> input2 = {{'1', '... | O0 | cpp | func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > 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
mov -0x68(%... | _Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_68]
mov rdi, rax
call _ZNSt6vectorIS_IcSaIcEESaIS1_EEC2Ev; std::vector... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v5; // [rsp+10h] [rbp-60h] BYREF
long long v6; // [rsp+18h] [rbp-58h] BYREF
unsigned long long i; // [rsp+20h] [rbp-50h]
unsigned long long v8; // [rsp+28h] [rbp-48h]
long long v9; // [rsp+30h] [rbp-40h]
l... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RDI,RAX
CALL 0x00102592
MOV RAX,qword ptr [RBP + -0x70]
MOV RDI,RAX
CALL 0x00102702
XOR EA... | /* func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char,
std::allocator<char> > > > const&) */
vector * func0(vector *param_1)
{
char cVar1;
bool bVar2;
vector<char,std::allocator<char>> *this;
char *pcVar3;
vector<std::vector<char,std::allocator<char>>,std::allocat... |
2,445 | func0 |
#include <vector>
#include <cassert>
| std::vector<std::vector<char>> func0(const std::vector<std::vector<char>>& lst) {
std::vector<std::vector<char>> result;
if (!lst.empty()) {
size_t numColumns = lst[0].size();
for (size_t i = 0; i < numColumns; ++i) {
std::vector<char> columnVector;
for (const auto&... | int main() {
// Test case 1
std::vector<std::vector<char>> input1 = {{'x', 'y'}, {'a', 'b'}, {'m', 'n'}};
std::vector<std::vector<char>> expected1 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}};
assert(func0(input1) == expected1);
// Test case 2
std::vector<std::vector<char>> input2 = {{'1', '... | O1 | cpp | func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r13
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,(%r... | _Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r12, rdi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rax,... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
long long i; // rbx
_QWORD *v4; // rbp
_BYTE *v5; // rdx
_BYTE *v6; // rsi
_QWORD *v7; // rbp
_BYTE *v8; // r15
signed long long v9; // r13
_BYTE *v10; // rax
_QWORD *v11; // r13
long long v13; // [rsp+10h] [rbp-68h]
_BYTE *v14; // [rsp+18h] [rbp-60h]
voi... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RAX
JZ 0x00101501
MO... | /* func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char,
std::allocator<char> > > > const&) */
vector * func0(vector *param_1)
{
long lVar1;
long lVar2;
long *plVar3;
int *__src;
int *__dest;
int8 uVar4;
long lVar5;
long *plVar6;
int8 *puVar7;
long *in_RSI... |
2,446 | func0 |
#include <vector>
#include <cassert>
| std::vector<std::vector<char>> func0(const std::vector<std::vector<char>>& lst) {
std::vector<std::vector<char>> result;
if (!lst.empty()) {
size_t numColumns = lst[0].size();
for (size_t i = 0; i < numColumns; ++i) {
std::vector<char> columnVector;
for (const auto&... | int main() {
// Test case 1
std::vector<std::vector<char>> input1 = {{'x', 'y'}, {'a', 'b'}, {'m', 'n'}};
std::vector<std::vector<char>> expected1 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}};
assert(func0(input1) == expected1);
// Test case 2
std::vector<std::vector<char>> input2 = {{'1', '... | O2 | cpp | func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,0x10(%rsp)
mov %rsi,0x28(%rsp)
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor... | _Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov r12, [rsi... | long long func0(long long a1, long long a2)
{
_QWORD *v2; // r12
_QWORD *v3; // rbx
long long v5; // rbp
char *v6; // rax
char *v7; // rsi
char *v8; // rsi
char *v9; // rdx
long long v10; // rbx
_BYTE *v11; // r12
_BYTE *v12; // r14
signed long long v13; // r14
_BYTE *v14; // rax
_BYTE *v15; ... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
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 qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV R12,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
CMP R12,RBX
JZ 0x00101f08... | /* func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char,
std::allocator<char> > > > const&) */
vector * func0(vector *param_1)
{
long lVar1;
long lVar2;
vector *pvVar3;
long lVar4;
char *pcVar5;
vector<char,std::allocator<char>> *__dest;
vector<char,std::allocat... |
2,447 | func0 |
#include <vector>
#include <cassert>
| std::vector<std::vector<char>> func0(const std::vector<std::vector<char>>& lst) {
std::vector<std::vector<char>> result;
if (!lst.empty()) {
size_t numColumns = lst[0].size();
for (size_t i = 0; i < numColumns; ++i) {
std::vector<char> columnVector;
for (const auto&... | int main() {
// Test case 1
std::vector<std::vector<char>> input1 = {{'x', 'y'}, {'a', 'b'}, {'m', 'n'}};
std::vector<std::vector<char>> expected1 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}};
assert(func0(input1) == expected1);
// Test case 2
std::vector<std::vector<char>> input2 = {{'1', '... | O3 | cpp | func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,0x8(%rsp)
mov %rsi,0x28(%rsp)
mov %fs:0x28,%rax
mov %... | _Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_88], rdi
mov [rsp+98h+var_68], rsi
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups... | long long func0(long long a1, long long a2)
{
_QWORD *v2; // r14
_QWORD *v3; // rbx
long long v4; // r13
_BYTE *v5; // rbp
long long v6; // rcx
_BYTE *v7; // r12
unsigned long long v8; // rcx
signed long long v9; // r15
unsigned long long v10; // rax
_BYTE *v11; // r8
unsigned long long v12; // r... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x30],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV R14,qword ptr [RSI + 0x8]... | /* func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char,
std::allocator<char> > > > const&) */
vector * func0(vector *param_1)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
vector *__dest;
vector *pvVar5;
vector *pvVar6;
ulong __n;
long *plVar7;
vector... |
2,448 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
| vector<pair<string, int>> func0(const vector<pair<string, vector<int>>>& test_list) {
vector<pair<string, int>> res;
for (const auto &p : test_list) {
int max_val = *max_element(p.second.begin(), p.second.end());
res.push_back({p.first, max_val});
}
return res;
}
| int main() {
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {3, 4, 5}},
{"key2", {1, 4, 2}},
{"key3", {9, 3}}
};
vector<pair<string, int>> expected = {
{"key1", 5},
{"key2", 4},
{"key3", 9}
... | O0 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > > > > const&):
endbr64
p... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_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
mov rax, [rbp+var_78]
mov rdi,... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
int v5; // [rsp+14h] [rbp-6Ch] BYREF
long long v6; // [rsp+18h] [rbp-68h] BYREF
long long v7; // [rsp+20h] [rbp-60h] BYREF
_QWORD v8[2]; // [rsp+28h] [rbp-58h] BYREF
long long v9; // [rsp+38h] [rbp-48h]
_BYTE v10[40... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDI,RAX
CALL 0x00103d42
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x50],RAX
MO... | /* func0(std::vector<std::pair<std::string, std::vector<int, std::allocator<int> > >,
std::allocator<std::pair<std::string, std::vector<int, std::allocator<int> > > > > const&) */
vector * func0(vector *param_1)
{
bool bVar1;
int8 uVar2;
int8 uVar3;
int *piVar4;
vector<std::pair<std::string,std::vector<i... |
2,449 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
| vector<pair<string, int>> func0(const vector<pair<string, vector<int>>>& test_list) {
vector<pair<string, int>> res;
for (const auto &p : test_list) {
int max_val = *max_element(p.second.begin(), p.second.end());
res.push_back({p.first, max_val});
}
return res;
}
| int main() {
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {3, 4, 5}},
{"key2", {1, 4, 2}},
{"key3", {9, 3}}
};
vector<pair<string, int>> expected = {
{"key1", 5},
{"key2", 4},
{"key3", 9}
... | O1 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > > > > const&):
endbr64
p... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 30h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r13
int *v4; // rdx
long long v5; // rsi
long long v6; // rdx
unsigned int v7; // eax
unsigned long long v8; // r9
long long v9; // rdx
char *v10; // rcx
unsigned int v11; // eax
unsigned int v12; // eax
unsigned int v13;... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBX,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
CMP R13,RBX
JZ 0x00101546... | /* func0(std::vector<std::pair<std::string, std::vector<int, std::allocator<int> > >,
std::allocator<std::pair<std::string, std::vector<int, std::allocator<int> > > > > const&) */
vector * func0(vector *param_1)
{
int iVar1;
int8 *puVar2;
long *plVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar... |
2,450 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
| vector<pair<string, int>> func0(const vector<pair<string, vector<int>>>& test_list) {
vector<pair<string, int>> res;
for (const auto &p : test_list) {
int max_val = *max_element(p.second.begin(), p.second.end());
res.push_back({p.first, max_val});
}
return res;
}
| int main() {
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {3, 4, 5}},
{"key2", {1, 4, 2}},
{"key3", {9, 3}}
};
vector<pair<string, int>> expected = {
{"key1", 5},
{"key2", 4},
{"key3", 9}
... | O2 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > > > > const&):
endbr64
p... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 38h
mov r15, [rsi+8]
mov rbp, [rsi]
mov rax, fs:28h
mov [rsp+68h+var_40], ... | long long func0(long long a1, _QWORD *a2)
{
_QWORD *v3; // r15
_QWORD *v4; // rbp
int *v5; // rcx
int *v6; // rdx
int *v7; // rax
int v8; // ebx
long long v9; // rsi
long long v10; // rdx
long long v11; // rax
unsigned int v13; // ecx
unsigned long long v14; // r8
long long v15; // rdx
char *... | func0:
MOV RDI,R14
CALL 0x00101240
LAB_001012a8:
MOV RDI,R12
CALL 0x00102670
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012c8
MOV RDI,RBX
LAB_001012c3:
CALL 0x00101280
LAB_001012c8:
CALL 0x00101230 | /* func0(std::vector<std::pair<std::string, std::vector<int, std::allocator<int> > >,
std::allocator<std::pair<std::string, std::vector<int, std::allocator<int> > > > > const&) [clone
.cold] */
void func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param... |
2,451 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
| vector<pair<string, int>> func0(const vector<pair<string, vector<int>>>& test_list) {
vector<pair<string, int>> res;
for (const auto &p : test_list) {
int max_val = *max_element(p.second.begin(), p.second.end());
res.push_back({p.first, max_val});
}
return res;
}
| int main() {
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {3, 4, 5}},
{"key2", {1, 4, 2}},
{"key3", {9, 3}}
};
vector<pair<string, int>> expected = {
{"key1", 5},
{"key2", 4},
{"key3", 9}
... | O3 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > > > > const&):
endbr64
p... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 68h
mov rbp, [rsi]
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
... | long long func0(long long a1, long long *a2)
{
long long v3; // rbp
long long v4; // rax
signed int *v5; // rsi
long long v6; // rax
signed int *v7; // rcx
signed int v8; // ebx
unsigned long long v9; // rdi
__m128i v10; // xmm2
long long v11; // rdx
__m128i v12; // xmm0
__m128i v13; // xmm1
__... | func0:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00101220
LAB_0010128a:
MOV RDI,R13
CALL 0x00102630
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012aa
MOV RDI,RBX
LAB_001012a5:
CALL 0x00101260
LAB_001012aa:
CALL 0x00101210 | /* func0(std::vector<std::pair<std::string, std::vector<int, std::allocator<int> > >,
std::allocator<std::pair<std::string, std::vector<int, std::allocator<int> > > > > const&) [clone
.cold] */
void func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int8 para... |
2,452 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<std::vector<int>>& test_list) {
int res = 0;
for (const auto& sublist : test_list) {
res += std::accumulate(sublist.begin(), sublist.end(), 0);
}
return res;
}
| int main() {
assert(func0({{1, 3}, {5, 6, 7}, {2, 6}}) == 30);
assert(func0({{2, 4}, {6, 7, 8}, {3, 7}}) == 37);
assert(func0({{3, 5}, {7, 8, 9}, {4, 8}}) == 44);
return 0;
}
| O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x3c(%rbp)
mov -0x48(%rbp)... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_3C], 0
mov rax, [rbp+var_48]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rdi, rax
call ... | long long func0(long long a1)
{
long long v1; // rbx
long long v2; // rax
unsigned int v4; // [rsp+14h] [rbp-3Ch]
long long v5; // [rsp+18h] [rbp-38h] BYREF
_QWORD v6[2]; // [rsp+20h] [rbp-30h] BYREF
long long v7; // [rsp+30h] [rbp-20h]
unsigned long long v8; // [rsp+38h] [rbp-18h]
v8 = __readfsqword(... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101c82
MO... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
bool bVar1;
int iVar2;
int8 uVar3;
int8 uVar4;
long in_FS_OFFSET;
int local_44;
int8 local_40;
int8 local_38;
vector<std::vector<int,std::... |
2,453 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<std::vector<int>>& test_list) {
int res = 0;
for (const auto& sublist : test_list) {
res += std::accumulate(sublist.begin(), sublist.end(), 0);
}
return res;
}
| int main() {
assert(func0({{1, 3}, {5, 6, 7}, {2, 6}}) == 30);
assert(func0({{2, 4}, {6, 7, 8}, {3, 7}}) == 37);
assert(func0({{3, 5}, {7, 8, 9}, {4, 8}}) == 44);
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%r8
cmp %r8,%rsi
je 12f0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x47>
mov $0x0,%edi
mov $0x0,%r9d
jmp 12d4 <_Z5func0RKSt6vectorIS_IiSa... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rsi, [rdi]
mov r8, [rdi+8]
cmp r8, rsi
jz short loc_12F1
mov edi, 0
mov r9d, 0
loc_12C4:
mov rcx, [rsi+8]
mov rax, [rsi]
cmp rax, rcx
jz short loc_12EC
mov edx, r9d
loc_12D3:
add edx, [rax]
add rax, 4
cmp rax, ... | long long func0(long long *a1)
{
long long v1; // rsi
long long v2; // r8
unsigned int v3; // edi
_DWORD *v4; // rcx
_DWORD *v5; // rax
int v6; // edx
v1 = *a1;
v2 = a1[1];
if ( v2 == *a1 )
{
return 0;
}
else
{
v3 = 0;
do
{
v4 = *(_DWORD **)(v1 + 8);
v5 = *(_DWORD... | func0:
ENDBR64
MOV RSI,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
CMP R8,RSI
JZ 0x001012f1
MOV EDI,0x0
MOV R9D,0x0
LAB_001012c4:
MOV RCX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RSI]
CMP RAX,RCX
JZ 0x001012ec
MOV EDX,R9D
LAB_001012d3:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001012d3
LAB_001012de:
ADD ED... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
int *piVar1;
int iVar2;
int8 *puVar3;
int iVar4;
puVar3 = *(int8 **)param_1;
if (*(int8 **)(param_1 + 8) == puVar3) {
iVar4 = 0;
}
el... |
2,454 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<std::vector<int>>& test_list) {
int res = 0;
for (const auto& sublist : test_list) {
res += std::accumulate(sublist.begin(), sublist.end(), 0);
}
return res;
}
| int main() {
assert(func0({{1, 3}, {5, 6, 7}, {2, 6}}) == 30);
assert(func0({{2, 4}, {6, 7, 8}, {3, 7}}) == 37);
assert(func0({{3, 5}, {7, 8, 9}, {4, 8}}) == 44);
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%rdi
xor %r8d,%r8d
cmp %rdi,%rsi
je 17b7 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x47>
nopl 0x0(%rax,%rax,1)
mov 0x8(%rsi),%rcx
mov (... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rsi, [rdi]
mov r8, [rdi+8]
xor edi, edi
cmp r8, rsi
jz short loc_17F6
nop word ptr [rax+rax+00h]
loc_17C8:
mov rcx, [rsi+8]
mov rax, [rsi]
cmp rax, rcx
jz short loc_17ED
xor edx, edx
nop word ptr [rax+rax+00000000h]
lo... | long long func0(long long *a1)
{
long long v1; // rsi
long long v2; // r8
unsigned int i; // edi
_DWORD *v4; // rcx
_DWORD *v5; // rax
int v6; // edx
v1 = *a1;
v2 = a1[1];
for ( i = 0; v2 != v1; v1 += 24LL )
{
v4 = *(_DWORD **)(v1 + 8);
v5 = *(_DWORD **)v1;
if ( *(_DWORD **)v1 != v4 )
... | func0:
ENDBR64
MOV RSI,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
XOR EDI,EDI
CMP R8,RSI
JZ 0x001017f6
NOP word ptr [RAX + RAX*0x1]
LAB_001017c8:
MOV RCX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RSI]
CMP RAX,RCX
JZ 0x001017ed
XOR EDX,EDX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001017e0:
ADD EDX,dword ptr [RAX]
ADD RAX,0x... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
int *piVar1;
int iVar2;
int8 *puVar3;
int iVar4;
iVar4 = 0;
for (puVar3 = *(int8 **)param_1; *(int8 **)(param_1 + 8) != puVar3;
puVar3 ... |
2,455 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<std::vector<int>>& test_list) {
int res = 0;
for (const auto& sublist : test_list) {
res += std::accumulate(sublist.begin(), sublist.end(), 0);
}
return res;
}
| int main() {
assert(func0({{1, 3}, {5, 6, 7}, {2, 6}}) == 30);
assert(func0({{2, 4}, {6, 7, 8}, {3, 7}}) == 37);
assert(func0({{3, 5}, {7, 8, 9}, {4, 8}}) == 44);
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%r10
xor %r9d,%r9d
cmp %r10,%rsi
je 1acd <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xdd>
movabs $0x3ffffffffffffffc,%r11
nopl 0x0(%rax)
mov ... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rax, rdi
mov rdi, [rdi]
xor r9d, r9d
mov r10, [rax+8]
cmp r10, rdi
jz loc_1B1F
nop word ptr [rax+rax+00h]
loc_1A70:
mov r8, [rdi+8]
mov rdx, [rdi]
cmp rdx, r8
jz loc_1B12
lea rcx, [r8-4]
mov rax, rdx
sub rcx, r... | long long func0(long long *a1)
{
long long v2; // rdi
unsigned int v3; // r9d
long long v4; // r10
unsigned long long *v5; // r8
const __m128i *v6; // rdx
const __m128i *v7; // rax
unsigned long long v8; // rsi
__m128i v9; // xmm0
__m128i v10; // xmm2
__m128i v11; // xmm0
int v12; // eax
v2 = ... | func0:
ENDBR64
MOV RAX,RDI
MOV RDI,qword ptr [RDI]
XOR R9D,R9D
MOV R10,qword ptr [RAX + 0x8]
CMP R10,RDI
JZ 0x00101b1f
NOP word ptr [RAX + RAX*0x1]
LAB_00101a70:
MOV R8,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
CMP RDX,R8
JZ 0x00101b12
LEA RCX,[R8 + -0x4]
MOV RAX,RDX
SUB RCX,RDX
MOV RSI,RCX
SHR RSI,0x2
ADD RSI,0x1
... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
ulong uVar7;
int *piVar8;
ulong uVar9;
int8 *puVar10;
int ... |
2,456 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<std::vector<int>>& nums) {
int tupleSize = nums.size();
int elementCount = nums[0].size();
std::vector<double> result(elementCount, 0.0);
for (int i = 0; i < elementCount; ++i) {
double sum = 0;
for (int j = 0; j < tupleSize; ++j) {
... | int main() {
assert(func0({{10, 10, 10, 12}, {30, 45, 56, 45}, {81, 80, 39, 32}, {1, 2, 3, 4}}) == std::vector<double>({30.5, 34.25, 27.0, 23.25}));
assert(func0({{1, 1, -5}, {30, -15, 56}, {81, -60, -39}, {-10, 2, 3}}) == std::vector<double>({25.5, -18.0, 3.75}));
assert(func0({{100, 100, 100, 120}, {30... | O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x50(%rbp)... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_60]
mov rdi, rax
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EE4sizeEv; std::ve... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
int *v4; // rax
double v6; // [rsp+8h] [rbp-68h]
char v7; // [rsp+2Fh] [rbp-41h] BYREF
int i; // [rsp+30h] [rbp-40h]
int j; // [rsp+34h] [rbp-3Ch]
int v10; // [rsp+38h] [rbp-38h]
int v11; // [rsp+3Ch] [rbp-34h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,RAX
CALL 0x001023da
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x60]
MO... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
vector<int,std::allocator<int>> *pvVar1;
int *piVar2;
double *pdVar3;
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<in... |
2,457 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<std::vector<int>>& nums) {
int tupleSize = nums.size();
int elementCount = nums[0].size();
std::vector<double> result(elementCount, 0.0);
for (int i = 0; i < elementCount; ++i) {
double sum = 0;
for (int j = 0; j < tupleSize; ++j) {
... | int main() {
assert(func0({{10, 10, 10, 12}, {30, 45, 56, 45}, {81, 80, 39, 32}, {1, 2, 3, 4}}) == std::vector<double>({30.5, 34.25, 27.0, 23.25}));
assert(func0({{1, 1, -5}, {30, -15, 56}, {81, -60, -39}, {-10, 2, 3}}) == std::vector<double>({25.5, -18.0, 3.75}));
assert(func0({{100, 100, 100, 120}, {30... | O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov (%rsi),%rax
mov 0x8(%rsi),%r14
sub %rax,%r14
sar $0x3,%r14
movabs $0xaaaaaaaaaaaaa... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rax, [rsi]
mov r14, [rsi+8]
sub r14, rax
sar r14, 3
mov rdx, 0AAAAAAAAAAAAAAABh
imul r14, rdx
mov r15, [rax+8]
sub r15, [rax]
sar r15, 2
movsxd r... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
unsigned long long v2; // r14
long long v3; // r15
_QWORD *v4; // rax
_QWORD *v5; // r13
long long v6; // rcx
_QWORD *v7; // rax
double v8; // xmm0_8
v2 = 0xAAAAAAAAAAAAAAABLL * ((long long)(a2[1] - *a2) >> 3);
v3 = (long long)(*(_QWORD *)(*a2 + 8LL) - *(_QWOR... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RAX,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
SUB R14,RAX
SAR R14,0x3
MOV RDX,-0x5555555555555555
IMUL R14,RDX
MOV R15,qword ptr [RAX + 0x8]
SUB R15,qword ptr [RAX]
SAR R15,0x2
MOVSXD R13,R15D
MOV RAX,R13
SHR RAX,0x3c
JNZ 0x001013a... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
long *plVar1;
int8 *puVar2;
long *plVar3;
long in_RCX;
vector *unaff_RBX;
ulong unaff_RBP;
long *in_RSI;
char *pcVar4;
long in_R8;
... |
2,458 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<std::vector<int>>& nums) {
int tupleSize = nums.size();
int elementCount = nums[0].size();
std::vector<double> result(elementCount, 0.0);
for (int i = 0; i < elementCount; ++i) {
double sum = 0;
for (int j = 0; j < tupleSize; ++j) {
... | int main() {
assert(func0({{10, 10, 10, 12}, {30, 45, 56, 45}, {81, 80, 39, 32}, {1, 2, 3, 4}}) == std::vector<double>({30.5, 34.25, 27.0, 23.25}));
assert(func0({{1, 1, -5}, {30, -15, 56}, {81, -60, -39}, {-10, 2, 3}}) == std::vector<double>({25.5, -18.0, 3.75}));
assert(func0({{100, 100, 100, 120}, {30... | O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
movabs $0xaaaaaaaaaaaaaaab,%rdx
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov (%rsi),%rax
mov 0x8(%rsi),%r14
mov 0x8(%rax),%r15
sub... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov r15, [rsi]
mov r14, [rsi+8]
mov rax, [r15+8]
sub rax, [r15]
sar rax, 2
mov ebx, eax
cdqe
mov rdi, rax
shr rdi, 3Ch
jnz loc_1D5... | long long func0(long long a1, _QWORD *a2)
{
long long v3; // r15
long long v4; // r14
int v5; // ebx
unsigned long long v6; // r12
char *v7; // rax
long long v8; // rdi
double *v9; // r9
int v10; // eax
double v11; // xmm2_8
long long v12; // r10
_QWORD *v13; // r8
_QWORD *v14; // rax
double ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV R15,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [R15 + 0x8]
SUB RAX,qword ptr [R15]
SAR RAX,0x2
MOV EBX,EAX
CDQE
MOV RDI,RAX
SHR RDI,0x3c
JNZ 0x00101d56
PXOR XMM0,XMM0
MOV qword ptr [RBP + 0x10],0x0
MOV... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
long *plVar1;
long *plVar2;
long lVar3;
long *plVar4;
int iVar5;
int iVar6;
ulong uVar7;
void *__s;
void *pvVar8;
long *plVar9;
l... |
2,459 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<std::vector<int>>& nums) {
int tupleSize = nums.size();
int elementCount = nums[0].size();
std::vector<double> result(elementCount, 0.0);
for (int i = 0; i < elementCount; ++i) {
double sum = 0;
for (int j = 0; j < tupleSize; ++j) {
... | int main() {
assert(func0({{10, 10, 10, 12}, {30, 45, 56, 45}, {81, 80, 39, 32}, {1, 2, 3, 4}}) == std::vector<double>({30.5, 34.25, 27.0, 23.25}));
assert(func0({{1, 1, -5}, {30, -15, 56}, {81, -60, -39}, {-10, 2, 3}}) == std::vector<double>({25.5, -18.0, 3.75}));
assert(func0({{100, 100, 100, 120}, {30... | O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
movabs $0xaaaaaaaaaaaaaaab,%rdx
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov (%rsi),%rax
mov 0x8(%rsi),%r13
mov 0x8(%rax),%r14
su... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov r15, [rsi]
mov r14, [rsi+8]
mov rax, [r15+8]
sub rax, [r15]
sar rax, 2
mov ebx, eax
cdqe
mov rdi, rax
shr rdi, 3Ch
jnz loc_1D3... | long long func0(long long a1, _QWORD *a2)
{
long long v3; // r15
long long v4; // r14
int v5; // ebx
unsigned long long v6; // r12
char *v7; // rax
long long v8; // rdi
double *v9; // r9
int v10; // eax
double v11; // xmm2_8
long long v12; // r10
_QWORD *v13; // r8
_QWORD *v14; // rax
double ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV R15,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [R15 + 0x8]
SUB RAX,qword ptr [R15]
SAR RAX,0x2
MOV EBX,EAX
CDQE
MOV RDI,RAX
SHR RDI,0x3c
JNZ 0x00101d36
PXOR XMM0,XMM0
MOV qword ptr [RBP + 0x10],0x0
MOV... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
long *plVar1;
long *plVar2;
long lVar3;
vector *pvVar4;
long *plVar5;
int iVar6;
int iVar7;
ulong uVar8;
void *__s;
void *pvVar9;
... |
2,460 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& test_tup1, const std::vector<int>& test_tup2) {
std::vector<int> res;
for(size_t i = 0; i < test_tup1.size(); ++i) {
res.push_back(test_tup1[i] % test_tup2[i]);
}
return res;
}
| int main() {
assert((func0({10, 4, 5, 6}, {5, 6, 7, 5}) == std::vector<int>{0, 4, 5, 1}));
assert((func0({11, 5, 6, 7}, {6, 7, 8, 6}) == std::vector<int>{5, 5, 6, 1}));
assert((func0({12, 6, 7, 8}, {7, 8, 9, 7}) == std::vector<int>{5, 6, 7, 1}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp)... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std:... | long long func0(long long a1, long long a2, long long a3)
{
int v3; // ebx
unsigned long long v4; // rax
int v7; // [rsp+2Ch] [rbp-24h] BYREF
unsigned long long i; // [rsp+30h] [rbp-20h]
unsigned long long v9; // [rsp+38h] [rbp-18h]
v9 = __readfsqword(0x28u);
std::vector<int>::vector(a1);
for ( i = 0L... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101c96
MOV qword ptr [RBP + -0x20],0x0
JM... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int *piVar2;
ulong uVar3;
vector<int,std::allocator<int>> *in_RDX;
long in_FS_OFFSET;
int local_2c;
ulong local_28;
long local_20;
... |
2,461 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& test_tup1, const std::vector<int>& test_tup2) {
std::vector<int> res;
for(size_t i = 0; i < test_tup1.size(); ++i) {
res.push_back(test_tup1[i] % test_tup2[i]);
}
return res;
}
| int main() {
assert((func0({10, 4, 5, 6}, {5, 6, 7, 5}) == std::vector<int>{0, 4, 5, 1}));
assert((func0({11, 5, 6, 7}, {6, 7, 8, 6}) == std::vector<int>{5, 5, 6, 1}));
assert((func0({12, 6, 7, 8}, {7, 8, 9, 7}) == std::vector<int>{5, 6, 7, 1}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbp
mov %rdx,%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov r13, rdx
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 rdx, [r... | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
unsigned long long v6; // rbx
int v7; // edx
int *v8; // rsi
int v10; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+8h] [rbp-30h]
v11 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v4 = *a2;
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV R13,RDX
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 RDX,qword ptr [RSI]
CMP RDX,qword ptr [RSI + 0x8]
JZ 0x00101314
... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int *piVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28... |
2,462 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& test_tup1, const std::vector<int>& test_tup2) {
std::vector<int> res;
for(size_t i = 0; i < test_tup1.size(); ++i) {
res.push_back(test_tup1[i] % test_tup2[i]);
}
return res;
}
| int main() {
assert((func0({10, 4, 5, 6}, {5, 6, 7, 5}) == std::vector<int>{0, 4, 5, 1}));
assert((func0({11, 5, 6, 7}, {6, 7, 8, 6}) == std::vector<int>{5, 5, 6, 1}));
assert((func0({12, 6, 7, 8}, {7, 8, 9, 7}) == std::vector<int>{5, 6, 7, 1}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi... | _Z5func0RKSt6vectorIiSaIiEES3_:
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
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], r... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rcx
int *v7; // rdi
int *v8; // rsi
long long v9; // rbx
int v10; // edx
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v4 = *a2;
*(_QW... | 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
MOVUPS xmmword ptr [RDI],XMM0
MOV RCX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RCX
JZ 0x00101770
MOV R12,RSI
MOV R13,R... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
long lVar1;
long *in_RDX;
ulong uVar2;
int *piVar3;
int *piVar4;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_F... |
2,463 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& test_tup1, const std::vector<int>& test_tup2) {
std::vector<int> res;
for(size_t i = 0; i < test_tup1.size(); ++i) {
res.push_back(test_tup1[i] % test_tup2[i]);
}
return res;
}
| int main() {
assert((func0({10, 4, 5, 6}, {5, 6, 7, 5}) == std::vector<int>{0, 4, 5, 1}));
assert((func0({11, 5, 6, 7}, {6, 7, 8, 6}) == std::vector<int>{5, 5, 6, 1}));
assert((func0({12, 6, 7, 8}, {7, 8, 9, 7}) == std::vector<int>{5, 6, 7, 1}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rd... | _Z5func0RKSt6vectorIiSaIiEES3_:
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
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], r... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rcx
int *v7; // rdi
int *v8; // rsi
long long v9; // rbx
int v10; // edx
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v4 = *a2;
*(_QW... | 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
MOVUPS xmmword ptr [RDI],XMM0
MOV RCX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RCX
JZ 0x00101770
MOV R12,RSI
MOV R13,R... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
long lVar1;
long *in_RDX;
ulong uVar2;
int *piVar3;
int *piVar4;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_F... |
2,464 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| double func0(int a, int b, int d) {
int temp = a;
a = std::min(a, b);
b = std::max(temp, b);
if (d >= b) {
return static_cast<double>(d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
else {
return 2;
}
}
| int main() {
assert(func0(3, 4, 11) == 3.5);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x14(%rbp),%eax
mov %eax,-0xc(%rbp)
lea -0x18(%rbp),%rdx
lea -0x14(%rbp),%rax
mov %rdx,%rs... | _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_14]
mov [rbp+var_C], eax
lea rdx, [rbp+var_18]
lea rax, [rbp+var_14]
mov rs... | unsigned long long func0(int a1, int a2)
{
int v3; // [rsp+8h] [rbp-18h] BYREF
int v4; // [rsp+Ch] [rbp-14h] BYREF
int v5; // [rsp+14h] [rbp-Ch] BYREF
unsigned long long v6; // [rsp+18h] [rbp-8h]
v4 = a1;
v3 = a2;
v6 = __readfsqword(0x28u);
v5 = a1;
v4 = *(_DWORD *)std::min<int>(&v4, &v3);
std::ma... | 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 + -0x1c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0xc],EAX
LEA RDX,[RBP + -0x18]
LEA RAX,[RBP + -0x1... | /* func0(int, int, int) */
double func0(int param_1,int param_2,int param_3)
{
int *piVar1;
long in_FS_OFFSET;
double dVar2;
int local_20;
int local_1c [2];
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = param_2;
local_1c[0] = param_1;
local_14 = param_1;
... |
2,465 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| double func0(int a, int b, int d) {
int temp = a;
a = std::min(a, b);
b = std::max(temp, b);
if (d >= b) {
return static_cast<double>(d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
else {
return 2;
}
}
| int main() {
assert(func0(3, 4, 11) == 3.5);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
cmp %esi,%edi
mov %esi,%ecx
cmovge %edi,%ecx
cmp %ecx,%edx
jge 11ba <_Z5func0iii+0x31>
pxor %xmm0,%xmm0
test %edx,%edx
je 11b9 <_Z5func0iii+0x30>
cmp %esi,%edi
cmovg %esi,%edi
movsd 0xefb(%rip),%xmm0
cmp %edi,%edx
je 11b9 <_Z5func0iii+0x30>
movsd 0xef7(%rip... | _Z5func0iii:
endbr64
cmp esi, edi
mov eax, edi
cmovge eax, esi
cmp edx, eax
jge short loc_1172
pxor xmm0, xmm0
test edx, edx
jz short locret_1171
cmp esi, edi
cmovg esi, edi
movsd xmm0, cs:qword_2080
cmp esi, edx
jz short loc_118B
locret_1171:
retn
loc_1172:
lea edx, [ra... | double func0(int a1, int a2, int a3)
{
int v3; // eax
double result; // xmm0_8
v3 = a1;
if ( a2 >= a1 )
v3 = a2;
if ( a3 >= v3 )
return (double)(v3 + a3 - 1) / (double)v3;
result = 0.0;
if ( a3 )
{
if ( a2 > a1 )
a2 = a1;
result = 2.0;
if ( a2 == a3 )
return 1.0;
}
... | func0:
ENDBR64
CMP ESI,EDI
MOV EAX,EDI
CMOVGE EAX,ESI
CMP EDX,EAX
JGE 0x00101172
PXOR XMM0,XMM0
TEST EDX,EDX
JZ 0x00101171
CMP ESI,EDI
CMOVG ESI,EDI
MOVSD XMM0,qword ptr [0x00102080]
CMP ESI,EDX
JZ 0x0010118b
LAB_00101171:
RET
LAB_00101172:
LEA EDX,[RAX + RDX*0x1 + -0x1]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
PXOR XMM1,XMM1
... | /* func0(int, int, int) */
double func0(int param_1,int param_2,int param_3)
{
int iVar1;
double dVar2;
iVar1 = param_1;
if (param_1 <= param_2) {
iVar1 = param_2;
}
if (iVar1 <= param_3) {
return (double)(iVar1 + -1 + param_3) / (double)iVar1;
}
dVar2 = 0.0;
if (param_3 != 0) {
if (p... |
2,466 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| double func0(int a, int b, int d) {
int temp = a;
a = std::min(a, b);
b = std::max(temp, b);
if (d >= b) {
return static_cast<double>(d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
else {
return 2;
}
}
| int main() {
assert(func0(3, 4, 11) == 3.5);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
cmp %esi,%edi
jle 11ce <_Z5func0iii+0xe>
mov %esi,%eax
mov %edi,%esi
mov %eax,%edi
cmp %edx,%esi
jle 11f0 <_Z5func0iii+0x30>
pxor %xmm0,%xmm0
test %edx,%edx
je 11ee <_Z5func0iii+0x2e>
movsd 0xe26(%rip),%xmm0
cmp %edi,%edx
je 11ee <_Z5func0iii+0x2e>
movs... | _Z5func0iii:
endbr64
cmp edi, esi
jg short loc_11F1
mov eax, esi
mov esi, edi
cmovge eax, edi
mov edi, eax
loc_11F1:
cmp edi, edx
jle short loc_1210
pxor xmm0, xmm0
test edx, edx
jz short locret_1209
movsd xmm0, cs:qword_2068
cmp edx, esi
jz short loc_1230
locret_1209... | double func0(int a1, int a2, int a3)
{
bool v3; // cc
int v4; // eax
double result; // xmm0_8
v3 = a1 < a2;
if ( a1 <= a2 )
{
v4 = a2;
a2 = a1;
if ( !v3 )
v4 = a1;
a1 = v4;
}
if ( a1 <= a3 )
return (double)(a1 + a3 - 1) / (double)a1;
result = 0.0;
if ( a3 )
{
result... | func0:
ENDBR64
CMP EDI,ESI
JG 0x001011f1
MOV EAX,ESI
MOV ESI,EDI
CMOVGE EAX,EDI
MOV EDI,EAX
LAB_001011f1:
CMP EDI,EDX
JLE 0x00101210
PXOR XMM0,XMM0
TEST EDX,EDX
JZ 0x00101209
MOVSD XMM0,qword ptr [0x00102068]
CMP EDX,ESI
JZ 0x00101230
LAB_00101209:
RET
LAB_00101210:
LEA EAX,[RDI + RDX*0x1 + -0x1]
PXOR XMM0,XMM0
PXOR XM... | /* func0(int, int, int) */
double func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
double dVar3;
iVar1 = param_2;
iVar2 = param_1;
if ((param_1 <= param_2) && (iVar1 = param_1, iVar2 = param_2, param_2 <= param_1)) {
iVar2 = param_1;
}
if (iVar2 <= param_3) {
return (doubl... |
2,467 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| double func0(int a, int b, int d) {
int temp = a;
a = std::min(a, b);
b = std::max(temp, b);
if (d >= b) {
return static_cast<double>(d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
else {
return 2;
}
}
| int main() {
assert(func0(3, 4, 11) == 3.5);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
cmp %esi,%edi
jle 11ce <_Z5func0iii+0xe>
mov %esi,%eax
mov %edi,%esi
mov %eax,%edi
cmp %edx,%esi
jle 11f0 <_Z5func0iii+0x30>
pxor %xmm0,%xmm0
test %edx,%edx
je 11ee <_Z5func0iii+0x2e>
movsd 0xe26(%rip),%xmm0
cmp %edi,%edx
je 11ee <_Z5func0iii+0x2e>
movs... | _Z5func0iii:
endbr64
cmp edi, esi
jg short loc_1151
mov eax, esi
mov esi, edi
cmovge eax, edi
mov edi, eax
loc_1151:
cmp edi, edx
jle short loc_1170
pxor xmm0, xmm0
test edx, edx
jz short locret_1169
movsd xmm0, cs:qword_2010
cmp edx, esi
jz short loc_1190
locret_1169... | double func0(int a1, int a2, int a3)
{
bool v3; // cc
int v4; // eax
double result; // xmm0_8
v3 = a1 < a2;
if ( a1 <= a2 )
{
v4 = a2;
a2 = a1;
if ( !v3 )
v4 = a1;
a1 = v4;
}
if ( a1 <= a3 )
return (double)(a1 + a3 - 1) / (double)a1;
result = 0.0;
if ( a3 )
{
result... | func0:
ENDBR64
CMP EDI,ESI
JG 0x00101151
MOV EAX,ESI
MOV ESI,EDI
CMOVGE EAX,EDI
MOV EDI,EAX
LAB_00101151:
CMP EDI,EDX
JLE 0x00101170
PXOR XMM0,XMM0
TEST EDX,EDX
JZ 0x00101169
MOVSD XMM0,qword ptr [0x00102010]
CMP EDX,ESI
JZ 0x00101190
LAB_00101169:
RET
LAB_00101170:
LEA EAX,[RDI + RDX*0x1 + -0x1]
PXOR XMM0,XMM0
PXOR XM... | /* func0(int, int, int) */
double func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
double dVar3;
iVar1 = param_2;
iVar2 = param_1;
if ((param_1 <= param_2) && (iVar1 = param_1, iVar2 = param_2, param_2 <= param_1)) {
iVar2 = param_1;
}
if (iVar2 <= param_3) {
return (doubl... |
2,468 | func0 |
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<double> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(static_cast<double>(nums1[i]) / nums2[i]);
}
return result;
}
| int main() {
assert(func0({4,5,6},{1, 2, 3}) == std::vector<double>({4.0, 2.5, 2.0}));
assert(func0({3,2},{1,4}) == std::vector<double>({3.0, 0.5}));
assert(func0({90,120},{50,70}) == std::vector<double>({1.8, 1.7142857142857142}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp)... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIdSaIdEEC2Ev; std:... | long long func0(long long a1, long long a2, long long a3)
{
unsigned long long v3; // rax
double v5; // [rsp+0h] [rbp-50h]
double v7; // [rsp+28h] [rbp-28h] BYREF
unsigned long long i; // [rsp+30h] [rbp-20h]
unsigned long long v9; // [rsp+38h] [rbp-18h]
v9 = __readfsqword(0x28u);
std::vector<double>::ve... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101c2a
MOV qword ptr [RBP + -0x20],0x0
JM... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int *piVar2;
ulong uVar3;
vector<int,std::allocator<int>> *in_RDX;
long in_FS_OFFSET;
double local_30;
ulong local_28;
long local_20... |
2,469 | func0 |
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<double> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(static_cast<double>(nums1[i]) / nums2[i]);
}
return result;
}
| int main() {
assert(func0({4,5,6},{1, 2, 3}) == std::vector<double>({4.0, 2.5, 2.0}));
assert(func0({3,2},{1,4}) == std::vector<double>({3.0, 0.5}));
assert(func0({90,120},{50,70}) == std::vector<double>({1.8, 1.7142857142857142}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbp
mov %rdx,%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov r13, rdx
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 rdx, [r... | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
unsigned long long v6; // rbx
double v7; // xmm0_8
double *v8; // rsi
double v10[7]; // [rsp+0h] [rbp-38h] BYREF
*(_QWORD *)&v10[1] = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v4 = *a2;
if ( *a2 != a2[1]... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV R13,RDX
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 RDX,qword ptr [RSI]
CMP RDX,qword ptr [RSI + 0x8]
JZ 0x00101304
... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
double *pdVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
long in_FS_OFFSET;
double local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET ... |
2,470 | func0 |
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<double> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(static_cast<double>(nums1[i]) / nums2[i]);
}
return result;
}
| int main() {
assert(func0({4,5,6},{1, 2, 3}) == std::vector<double>({4.0, 2.5, 2.0}));
assert(func0({3,2},{1,4}) == std::vector<double>({3.0, 0.5}));
assert(func0({90,120},{50,70}) == std::vector<double>({1.8, 1.7142857142857142}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov (%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
m... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rdx, [rsi]
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
c... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
double *v6; // rcx
double *v7; // rsi
long long v8; // rbx
double v9; // xmm0_8
double v11[7]; // [rsp+0h] [rbp-38h] BYREF
v4 = *a2;
*(_QWORD *)&v11[1] = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 ... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RDX,qword ptr [RSI]
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
CMP qword ptr [RSI + 0x8],RDX
JZ 0x00101790
MOV R12,R... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
double *pdVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
double *pdVar4;
long in_FS_OFFSET;
double local_38;
long local_30;
lVar2 = *(long *... |
2,471 | func0 |
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<double> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(static_cast<double>(nums1[i]) / nums2[i]);
}
return result;
}
| int main() {
assert(func0({4,5,6},{1, 2, 3}) == std::vector<double>({4.0, 2.5, 2.0}));
assert(func0({3,2},{1,4}) == std::vector<double>({3.0, 0.5}));
assert(func0({90,120},{50,70}) == std::vector<double>({1.8, 1.7142857142857142}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov (%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
m... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rdx, [rsi]
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
m... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v5; // rdx
long long v6; // rdi
double *v8; // rcx
double *v9; // rsi
long long v10; // rbx
double v11; // xmm0_8
double v13[7]; // [rsp+0h] [rbp-38h] BYREF
v5 = *a2;
*(_QWORD *)&v13[1] = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RDX,qword ptr [RSI]
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 RDI,qword ptr [RSI + 0x8]
CMP RDI,RDX
JZ 0x001017... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
double *pdVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
double *pdVar4;
long lVar5;
long in_FS_OFFSET;
double local_38;
long local_30;
lV... |
2,472 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
using namespace std;
| string func0(string test_str) {
string res = "";
string dig = "";
for (char ele : test_str) {
if (isdigit(ele)) {
dig += ele;
} else {
res += ele;
}
}
res += dig;
return res;
}
| int main() {
assert(func0("I1love143you55three3000thousand") == "Iloveyouthreethousand1143553000");
assert(func0("Avengers124Assemble") == "AvengersAssemble124");
assert(func0("Its11our12path13to14see15things16do17things") == "Itsourpathtoseethingsdothings11121314151617");
cout << "All tests passed ... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
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 -0x50(%rbp),%rax
mov %rax,%rdi
callq 23b0 <_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
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_60]
mov [rbp+var_50], rax
nop
nop
lea rdx, [rbp... | long long func0(long long a1, long long a2)
{
char v3; // [rsp+17h] [rbp-69h]
long long v4; // [rsp+18h] [rbp-68h] BYREF
long long v5; // [rsp+20h] [rbp-60h] BYREF
long long v6; // [rsp+28h] [rbp-58h]
long long *v7; // [rsp+30h] [rbp-50h]
long long *v8; // [rsp+38h] [rbp-48h]
_BYTE v9[40]; // [rsp+40h] [... | 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 + -0x60]
MOV qword ptr [RBP + -0x50],RAX
NOP
NOP
LEA RDX,[RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x78]
LEA RCX,[0... | /* func0(std::string) */
string * func0(string *param_1,int8 param_2)
{
char cVar1;
bool bVar2;
char *pcVar3;
long in_FS_OFFSET;
int8 local_70;
int8 local_68;
int8 local_60;
int8 *local_58;
int8 *local_50;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
loc... |
2,473 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
using namespace std;
| string func0(string test_str) {
string res = "";
string dig = "";
for (char ele : test_str) {
if (isdigit(ele)) {
dig += ele;
} else {
res += ele;
}
}
res += dig;
return res;
}
| int main() {
assert(func0("I1love143you55three3000thousand") == "Iloveyouthreethousand1143553000");
assert(func0("Avengers124Assemble") == "AvengersAssemble124");
assert(func0("Its11our12path13to14see15things16do17things") == "Itsourpathtoseethingsdothings11121314151617");
cout << "All tests passed ... | O1 | cpp | func0(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 $0x48,%rsp
mov %rdi,%rbp
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
mov %rax,0x8(... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rbp, rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rsp+78h+var_78], rax
mov ... | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v2; // rbx
char *v3; // r14
unsigned long long v4; // rax
char v5; // r12
unsigned long long v6; // r13
unsigned long long v7; // r15
long long v8; // r13
unsigned long long v9; // r15
unsigned long long v10; // rax
void *v12; // [rsp+10h] [rbp-68h] BYRE... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RBP,RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RDI],RAX
LEA RBX,[0x102236]
MOV RDX,RBX
MOV RSI,RBX
LAB_00101349:
CALL 0x001017a2
L... | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
char cVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
int8 uVar5;
char *pcVar6;
char *pcVar7;
long in_FS_OFFSET;
ulong *local_68;
ulong local_60;
ulong local_58 [3];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);... |
2,474 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
using namespace std;
| string func0(string test_str) {
string res = "";
string dig = "";
for (char ele : test_str) {
if (isdigit(ele)) {
dig += ele;
} else {
res += ele;
}
}
res += dig;
return res;
}
| int main() {
assert(func0("I1love143you55three3000thousand") == "Iloveyouthreethousand1143553000");
assert(func0("Avengers124Assemble") == "AvengersAssemble124");
assert(func0("Its11our12path13to14see15things16do17things") == "Itsourpathtoseethingsdothings11121314151617");
cout << "All tests passed ... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x48,%rsp
mov 0x8(%rsi),%r14
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
lea rbx, function+0Ah; ""
mov rdx, rbx
mov rsi, rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, ... | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v2; // rbx
char *v3; // r14
unsigned long long v4; // r13
_BYTE *v5; // rax
unsigned long long v6; // r15
unsigned long long v7; // rdx
int v8; // r12d
long long v9; // r13
_QWORD *v10; // rax
unsigned long long v11; // r15
unsigned long long v12; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
LEA RBX,[0x102023]
MOV RDX,RBX
MOV RSI,RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV qword ptr [RSP + 0x10],RAX
LAB_001016f1:
CALL 0x001... | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
char cVar1;
ulong uVar2;
long *plVar3;
ulong uVar4;
ulong uVar5;
char *pcVar6;
char *pcVar7;
long in_FS_OFFSET;
ulong *local_68;
ulong local_60;
ulong local_58 [3];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28... |
2,475 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
using namespace std;
| string func0(string test_str) {
string res = "";
string dig = "";
for (char ele : test_str) {
if (isdigit(ele)) {
dig += ele;
} else {
res += ele;
}
}
res += dig;
return res;
}
| int main() {
assert(func0("I1love143you55three3000thousand") == "Iloveyouthreethousand1143553000");
assert(func0("Avengers124Assemble") == "AvengersAssemble124");
assert(func0("Its11our12path13to14see15things16do17things") == "Itsourpathtoseethingsdothings11121314151617");
cout << "All tests passed ... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x48,%rsp
mov 0x8(%rsi),%r14
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov byte ptr [rdi+10h], 0
mov [rdi], rax
mov ... | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v2; // rbx
char *v3; // r14
unsigned long long v4; // r13
_BYTE *v5; // rax
unsigned long long v6; // r15
unsigned long long v7; // rdx
int v8; // r12d
long long v9; // r13
long long v10; // rax
unsigned long long v11; // r15
unsigned long long v12; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV byte ptr [RDI + 0x10],0x0
MOV qword ptr [RDI],RAX
MOV RBX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],0x0
MOV R14,qword ptr [RSI + 0... | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
char cVar1;
ulong uVar2;
long *plVar3;
ulong uVar4;
ulong uVar5;
char *pcVar6;
char *pcVar7;
long in_FS_OFFSET;
int *local_68;
ulong local_60;
int local_58;
int7 uStack_57;
long local_40;
local_40 = *(long *)(in_FS_OFF... |
2,476 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int n) {
std::vector<int> dp(n, 0);
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; --i) {
int mxm = 0;
for (int j = i + 1; j < n; ++j) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
mxm = std::max(mxm, dp[j]);
}
... | int main() {
assert(func0({1, 3, 6, 13, 17, 18}, 6) == 4);
assert(func0({10, 5, 3, 15, 20}, 5) == 3);
assert(func0({18, 1, 3, 6, 13, 17}, 6) == 4);
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,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x41(%rbp),%rax
mov %rax,%rdi
callq 1844 <_ZNSaIiEC1Ev>
movl $0x0,-0x3... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_49]
mov [rbp+var_38], rax
nop
nop
mov dword ptr [rbp+var_40], 0
mov eax, [r... | long long func0(long long a1, int a2)
{
int v2; // ebx
int v3; // ebx
long long v5; // rax
int v6; // ebx
long long v7; // rbx
long long v8; // rax
char v10; // [rsp+17h] [rbp-49h] BYREF
int i; // [rsp+18h] [rbp-48h]
int j; // [rsp+1Ch] [rbp-44h]
_QWORD v13[2]; // [rsp+20h] [rbp-40h] BYREF
_BYTE ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x49]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV dword ptr [RBP + -0x40],0x0
MOV EAX,dword ptr [RBP + -0x5c]
... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int4 func0(vector *param_1,int param_2)
{
int iVar1;
int4 uVar2;
bool bVar3;
__normal_iterator _Var4;
__normal_iterator _Var5;
int4 *puVar6;
int *piVar7;
int4 extraout_var;
long in_FS_OFFSET;
allocator local_51;
int local_50;
int ... |
2,477 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int n) {
std::vector<int> dp(n, 0);
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; --i) {
int mxm = 0;
for (int j = i + 1; j < n; ++j) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
mxm = std::max(mxm, dp[j]);
}
... | int main() {
assert(func0({1, 3, 6, 13, 17, 18}, 6) == 4);
assert(func0({10, 5, 3, 15, 20}, 5) == 3);
assert(func0({18, 1, 3, 6, 13, 17}, 6) == 4);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movslq %esi,%rax
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 12d8 <_Z5func0RKSt6vectorIiSaI... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
movsxd r12, esi
mov rax, r12
shr rax, 3Dh
jnz short loc_128F
mov rbp, rdi
mov ebx, esi
test r12, r12
j... | long long func0(long long *a1, int a2)
{
unsigned long long v2; // r12
unsigned int *v4; // rax
unsigned int *v5; // r14
unsigned int *v6; // r15
int v7; // r11d
long long v8; // r13
int *v9; // rax
long long v10; // rsi
int *v11; // rcx
long long v12; // r9
int v13; // r8d
unsigned int *v14; /... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVSXD R12,ESI
MOV RAX,R12
SHR RAX,0x3d
JNZ 0x0010128f
MOV RBP,RDI
MOV EBX,ESI
TEST R12,R12
JZ 0x00101371
SHL R12,0x2
MOV RDI,R12
CALL 0x001010e0
MOV R14,RAX
LEA R15,[R... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int *piVar7;
long lVar8;
int iVar9;
... |
2,478 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int n) {
std::vector<int> dp(n, 0);
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; --i) {
int mxm = 0;
for (int j = i + 1; j < n; ++j) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
mxm = std::max(mxm, dp[j]);
}
... | int main() {
assert(func0({1, 3, 6, 13, 17, 18}, 6) == 4);
assert(func0({10, 5, 3, 15, 20}, 5) == 3);
assert(func0({18, 1, 3, 6, 13, 17}, 6) == 4);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
movabs $0x1fffffffffffffff,%rdx
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movslq %esi,%rax
cmp %rdx,%rax
ja 1626 <_Z5func0RKSt6vectorIiSaI... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r15
movsxd rax, esi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rax
sub rsp, 18h
shr rbx, 3Dh
jnz loc_1579
lea r13d, [rax-1]
mov rbp, rax
movsxd r15, r13d
lea rcx, ds:0[r15*4]
test rax, rax
jz loc_1565
lea r... | long long func0(long long *a1, int a2)
{
int v2; // r13d
long long v3; // rcx
size_t v4; // rbx
char *v5; // rax
char *v6; // r12
char *v7; // rax
char *v8; // r10
long long v9; // r9
int v10; // r11d
long long v11; // r13
int v12; // edi
long long v13; // rcx
int v14; // r8d
char *v15; // ... | func0:
ENDBR64
PUSH R15
MOVSXD RAX,ESI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RAX
SUB RSP,0x18
SHR RBX,0x3d
JNZ 0x00101579
LEA R13D,[RAX + -0x1]
MOV RBP,RAX
MOVSXD R15,R13D
LEA RCX,[R15*0x4]
TEST RAX,RAX
JZ 0x00101565
LEA RBX,[RCX + 0x4]
MOV R14,RDI
MOV qword ptr [RSP + 0x8],RCX
MOV RDI,RBX
CALL 0x0010110... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&, int) */
void * func0(vector *param_1,int param_2)
{
ulong __n;
uint *puVar1;
int iVar2;
int iVar3;
long lVar4;
void *pvVar5;
uint *puVar6;
uint *puVar7;
void *... |
2,479 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int n) {
std::vector<int> dp(n, 0);
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; --i) {
int mxm = 0;
for (int j = i + 1; j < n; ++j) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
mxm = std::max(mxm, dp[j]);
}
... | int main() {
assert(func0({1, 3, 6, 13, 17, 18}, 6) == 4);
assert(func0({10, 5, 3, 15, 20}, 5) == 3);
assert(func0({18, 1, 3, 6, 13, 17}, 6) == 4);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
movabs $0x1fffffffffffffff,%rdx
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movslq %esi,%rax
cmp %rdx,%rax
ja 16c9 <_Z5func0RKSt6vectorIiSaI... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r15
movsxd rax, esi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rax
sub rsp, 18h
shr rbx, 3Dh
jnz loc_1621
lea r13d, [rax-1]
mov rbp, rax
movsxd r15, r13d
lea rcx, ds:0[r15*4]
test rax, rax
jz loc_160D
lea r... | long long func0(long long *a1, int a2)
{
int v2; // r13d
long long v3; // rcx
size_t v4; // rbx
char *v5; // rax
signed int *v6; // r12
char *v7; // rax
char *v8; // r10
long long v9; // r9
int v10; // r11d
long long v11; // r13
int v12; // edi
long long v13; // rcx
int v14; // r8d
signed i... | func0:
ENDBR64
PUSH R15
MOVSXD RAX,ESI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RAX
SUB RSP,0x18
SHR RBX,0x3d
JNZ 0x00101621
LEA R13D,[RAX + -0x1]
MOV RBP,RAX
MOVSXD R15,R13D
LEA RCX,[R15*0x4]
TEST RAX,RAX
JZ 0x0010160d
LEA RBX,[RCX + 0x4]
MOV R14,RDI
MOV qword ptr [RSP + 0x8],RCX
MOV RDI,RBX
CALL 0x0010110... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&, int) */
void * func0(vector *param_1,int param_2)
{
ulong __n;
uint *puVar1;
uint *puVar2;
int iVar3;
int iVar4;
long lVar5;
uint *puVar6;
uint *puVar7;
uint *... |
2,480 | 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",... | 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&, int)::{lambda(char)#1}::operator()(char) const:
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov %esi,%e... | _ZZ5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEiENKUlcE_clEc:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov eax, esi
mov [rbp+var_C], al
movsx eax, [rbp+var_C]
sub eax, 30h ; '0'
cmp eax, 9
setbe al
movzx eax, al
pop rbp
retn | _BOOL8 func0(std::vector<std::string> const&,int)::{lambda(char)#1}::operator()(long long a1, char a2)
{
return (unsigned int)(a2 - 48) <= 9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV dword ptr [RBP + -0x84],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDI,RAX
CALL 0x001034ba
MOV RAX,qword ptr [RBP + -0x80]
MO... | /* func0(std::vector<std::string, std::allocator<std::string > > const&, int) */
vector * func0(vector *param_1,int param_2)
{
char cVar1;
bool bVar2;
int8 uVar3;
int8 uVar4;
int4 in_register_00000034;
long in_FS_OFFSET;
int8 local_68;
int8 local_60;
vector<std::string,std::allocator<std::string>> *... |
2,481 | 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",... | 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&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rd... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 128h
mov r13, rdi
mov [rsp+158h+var_154], edx
mov rax, fs:28h
mov [rsp+158h+var_40], rax
xor eax, eax
mov qword ptr [rdi... | _QWORD * func0(_QWORD *a1, char ***a2, int a3, char *a4)
{
char **v5; // rbp
char **v6; // r15
char *v7; // rax
_QWORD *v8; // rdi
long long v9; // rax
char *v10; // rbx
char *v11; // rdi
long long v12; // rax
signed long long v13; // rax
int *v14; // r12
int v15; // r14d
long long v16; // rax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x128
MOV R13,RDI
MOV dword ptr [RSP + 0x4],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x118],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 R15,qword ... | /* func0(std::vector<std::string, std::allocator<std::string > > const&, int) */
vector * func0(vector *param_1,int param_2)
{
int iVar1;
string *psVar2;
long *plVar3;
char *pcVar4;
uint uVar5;
uint uVar6;
uint uVar7;
int8 uVar8;
char *pcVar9;
long lVar10;
int *piVar11;
long lVar12;
int in_E... |
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.