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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
394 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string s){
string uvowel="AEIOU";
int count=0;
for (int i=0;i*2<s.length();i++)
if (find(uvowel.begin(),uvowel.end(),s[i*2])!=uvowel.end())
count+=1;
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("aBCdEf") == 1);
assert (func0("abcdefg") == 0);
assert (func0("dBBE") == 0);
assert (func0("B") == 0);
assert (func0("U") == 1);
assert (func0("") == 0);
assert (func0("EEEE") == 2);
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
sub $0x38,%rsp
mov 0x8(%rdi),%rcx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rax
movl $0x4f494541,0x10(%rsp)
mov %rax,(%rsp)
movb $0x55,0x14(%rsp)
movq $0x5,0x8(%rsp)
movb ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rdx, [rdi+8]
test rdx, rdx
jz short loc_14A6
mov rax, [rdi]
lea rcx, [rdx-1]
xor esi, esi
and rcx, 0FFFFFFFFFFFFFFFEh
lea rdx, [rax+2]
movzx eax, byte ptr [rax]
add rcx, rdx
cmp al, 41h ; 'A'
jz shor... | long long func0(char **a1)
{
char *v1; // rdx
unsigned int v2; // esi
unsigned long long v3; // rcx
long long v4; // rdx
char v5; // al
unsigned long long v6; // rcx
char *v7; // rax
v1 = a1[1];
if ( !v1 )
return 0LL;
v2 = 0;
v3 = (unsigned long long)(v1 - 1) & 0xFFFFFFFFFFFFFFFELL;
v4 = (... | func0:
ENDBR64
MOV RDX,qword ptr [RDI + 0x8]
TEST RDX,RDX
JZ 0x001014a6
MOV RAX,qword ptr [RDI]
LEA RCX,[RDX + -0x1]
XOR ESI,ESI
AND RCX,-0x2
LEA RDX,[RAX + 0x2]
MOVZX EAX,byte ptr [RAX]
ADD RCX,RDX
CMP AL,0x41
JZ 0x00101498
NOP dword ptr [RAX + RAX*0x1]
LAB_00101470:
CMP AL,0x45
JZ 0x00101498
CMP AL,0x49
JZ 0x00101498... | /* func0(std::string) */
int func0(int8 *param_1)
{
int iVar1;
char cVar2;
char *pcVar3;
char *pcVar4;
int iVar5;
if (param_1[1] == 0) {
return 0;
}
iVar5 = 0;
pcVar4 = (char *)*param_1 + 2;
cVar2 = *(char *)*param_1;
pcVar3 = pcVar4 + (param_1[1] - 1 & 0xfffffffffffffffe);
iVar1 = 0;
... |
395 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string s){
string uvowel="AEIOU";
int count=0;
for (int i=0;i*2<s.length();i++)
if (find(uvowel.begin(),uvowel.end(),s[i*2])!=uvowel.end())
count+=1;
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("aBCdEf") == 1);
assert (func0("abcdefg") == 0);
assert (func0("dBBE") == 0);
assert (func0("B") == 0);
assert (func0("U") == 1);
assert (func0("") == 0);
assert (func0("EEEE") == 2);
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
sub $0x38,%rsp
mov 0x8(%rdi),%rcx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rax
movl $0x4f494541,0x10(%rsp)
mov %rax,(%rsp)
movb $0x55,0x14(%rsp)
movq $0x5,0x8(%rsp)
movb ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov r8, [rdi+8]
test r8, r8
jz loc_1835
lea rsi, [r8-1]
mov rcx, [rdi]
mov rdi, rsi
shr rdi, 1
cmp rsi, 1Fh
jbe loc_183A
mov rax, rsi
and rsi, 0FFFFFFFFFFFFFFE0h
mov rdx, rcx
movdqa xmm6, cs:xmmword_21... | long long func0(const __m128i **a1)
{
const __m128i *v1; // r8
const __m128i *v2; // rcx
const __m128i *v3; // rdx
__m128i si128; // xmm6
__m128i v5; // xmm11
__m128i v6; // xmm10
__m128i v7; // xmm7
__m128i v8; // xmm4
__m128i v9; // xmm9
__m128i v10; // xmm8
__m128i v11; // xmm3
__m128i v12; ... | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
TEST R8,R8
JZ 0x00101835
LEA RSI,[R8 + -0x1]
MOV RCX,qword ptr [RDI]
MOV RDI,RSI
SHR RDI,0x1
CMP RSI,0x1f
JBE 0x0010183a
MOV RAX,RSI
AND RSI,-0x20
MOV RDX,RCX
MOVDQA XMM6,xmmword ptr [0x00102110]
MOVDQA XMM11,xmmword ptr [0x00102120]
SHR RAX,0x5
ADD RSI,RCX
MOVDQA XMM10,xmmwo... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::string) */
int func0(long *param_1)
{
ushort *puVar1;
ulong uVar2;
ushort *puVar3;
bool bVar4;
char cVar8;
ushort *puVar17;
ushort *puVar18;
ushort *puVar19;
ushort *puVar20;
ushort *puVar21;
ushor... |
396 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string value){
double w;
w=atof(value.c_str());
return round(w);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("10") == 10);
assert (func0("14.5") == 15);
assert (func0("-15.5") == -16);
assert (func0("15.3") == 15);
assert (func0("0") == 0);
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 11d0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv@plt>
mov %rax,%rdi
callq 12b0 <a... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov rax, [rbp+var_18]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax; nptr
call _atof
... | long long func0(long long a1)
{
const char *v1; // rax
double v2; // xmm0_8
v1 = (const char *)std::string::c_str(a1);
v2 = atof(v1);
return (unsigned int)(int)round(v2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101160
MOV RDI,RAX
CALL 0x00101240
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVQ XMM0,RAX
CALL 0x00101170
CVTTSD2SI EAX,XMM0
LEAVE
RET | /* func0(std::string) */
int func0(void)
{
char *__nptr;
double dVar1;
__nptr = (char *)std::string::c_str();
dVar1 = atof(__nptr);
dVar1 = round(dVar1);
return (int)dVar1;
} |
397 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string value){
double w;
w=atof(value.c_str());
return round(w);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("10") == 10);
assert (func0("14.5") == 15);
assert (func0("-15.5") == -16);
assert (func0("15.3") == 15);
assert (func0("0") == 0);
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
sub $0x8,%rsp
mov $0x0,%esi
mov (%rdi),%rdi
callq 10f0 <strtod@plt>
callq 10c0 <round@plt>
cvttsd2si %xmm0,%eax
add $0x8,%rsp
retq
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
sub rsp, 8
mov rdi, [rdi]; nptr
mov esi, 0; endptr
call _strtod
call _round
cvttsd2si eax, xmm0
add rsp, 8
retn | long long func0(const char **a1)
{
double v1; // xmm0_8
v1 = strtod(*a1, 0LL);
return (unsigned int)(int)round(v1);
} | func0:
ENDBR64
SUB RSP,0x8
MOV RDI,qword ptr [RDI]
MOV ESI,0x0
CALL 0x00101110
CALL 0x001010d0
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET | /* func0(std::string) */
int func0(int8 *param_1)
{
double dVar1;
dVar1 = strtod((char *)*param_1,(char **)0x0);
dVar1 = round(dVar1);
return (int)dVar1;
} |
398 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string value){
double w;
w=atof(value.c_str());
return round(w);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("10") == 10);
assert (func0("14.5") == 15);
assert (func0("-15.5") == -16);
assert (func0("15.3") == 15);
assert (func0("0") == 0);
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
sub $0x8,%rsp
mov (%rdi),%rdi
xor %esi,%esi
callq 1110 <strtod@plt>
callq 10d0 <round@plt>
add $0x8,%rsp
cvttsd2si %xmm0,%eax
retq
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
sub rsp, 8
mov rdi, [rdi]; nptr
xor esi, esi; endptr
call _strtod
call _round
add rsp, 8
cvttsd2si eax, xmm0
retn | long long func0(const char **a1)
{
double v1; // xmm0_8
v1 = strtod(*a1, 0LL);
return (unsigned int)(int)round(v1);
} | func0:
ENDBR64
SUB RSP,0x8
MOV RDI,qword ptr [RDI]
XOR ESI,ESI
CALL 0x00101110
CALL 0x001010d0
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET | /* func0(std::string) */
int func0(int8 *param_1)
{
double dVar1;
dVar1 = strtod((char *)*param_1,(char **)0x0);
dVar1 = round(dVar1);
return (int)dVar1;
} |
399 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string value){
double w;
w=atof(value.c_str());
return round(w);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("10") == 10);
assert (func0("14.5") == 15);
assert (func0("-15.5") == -16);
assert (func0("15.3") == 15);
assert (func0("0") == 0);
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
sub $0x8,%rsp
mov (%rdi),%rdi
xor %esi,%esi
callq 1110 <strtod@plt>
callq 10d0 <round@plt>
add $0x8,%rsp
cvttsd2si %xmm0,%eax
retq
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
sub rsp, 8
mov rdi, [rdi]; nptr
xor esi, esi; endptr
call _strtod
call _round
add rsp, 8
cvttsd2si eax, xmm0
retn | long long func0(const char **a1)
{
double v1; // xmm0_8
v1 = strtod(*a1, 0LL);
return (unsigned int)(int)round(v1);
} | func0:
ENDBR64
SUB RSP,0x8
MOV RDI,qword ptr [RDI]
XOR ESI,ESI
CALL 0x00101110
CALL 0x001010d0
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET | /* func0(std::string) */
int func0(int8 *param_1)
{
double dVar1;
dVar1 = strtod((char *)*param_1,(char **)0x0);
dVar1 = round(dVar1);
return (int)dVar1;
} |
400 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
vector<int> out={n};
for (int i=1;i<n;i++)
out.push_back(out[out.size()-1]+2);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(3) , {3, 5, 7}));
assert (issame(func0(4) , {4,6,8,10}));
as... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov -0x4c(%rbp),%eax
mov %eax,-0x2c(%rbp)
lea -0x2c(%rbp),%rax
mov %rax,%r12
mov $0x1,%r13d
... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rcx, fs:28h
mov [rbp+var_18], rcx
xor ecx, ecx
mov ecx, [rbp+var_3C]
mov [rbp+var_1C], ecx
lea rcx, [rbp+var_1C]
mov rax, rcx
mov edx, 1
lea rcx, [rbp+... | long long func0(long long a1, int a2)
{
long long v2; // rax
int v4; // [rsp+10h] [rbp-30h] BYREF
int i; // [rsp+14h] [rbp-2Ch]
int *v6; // [rsp+18h] [rbp-28h]
int v7; // [rsp+24h] [rbp-1Ch] BYREF
unsigned long long v8; // [rsp+28h] [rbp-18h]
v8 = __readfsqword(0x28u);
v7 = a2;
v6 = &v4;
std::vect... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RCX
XOR ECX,ECX
MOV ECX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x1c],ECX
LEA RCX,[RBP + -0x1c]
MOV RAX,RCX
MOV EDX,0x1
LEA RCX,[RBP + -... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
long lVar1;
int *piVar2;
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_38;
int local_34;
int *local_30;
allocator local_24 [4];
long local_20;
this = (vector<... |
401 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
vector<int> out={n};
for (int i=1;i<n;i++)
out.push_back(out[out.size()-1]+2);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(3) , {3, 5, 7}));
assert (issame(func0(4) , {4,6,8,10}));
as... | O1 | cpp | func0(int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %esi,%r12d
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov $0x4,%edi
callq 1100 <_Znwm@plt>
mov %rax,(%rbx)
lea 0x4(%rax... | _Z5func0i:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov r12d, esi
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 edi, 4; unsigned __int64
call __Znwm... | int ** func0(int **a1, int a2)
{
int *v3; // rax
int v4; // ebp
int *v6; // rsi
int v7; // eax
int v8; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v9; // [rsp+8h] [rbp-30h]
v9 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v3 = (int *)operator new(4uLL);
*a1 = v3;
a1[2] = v3 ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R12D,ESI
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 EDI,0x4
LAB_001012c3:
CALL 0x001010f0
MOV qword ptr [RBX],RAX
LEA RDX,[R... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int *piVar1;
int iVar2;
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_34;
long local_30;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,par... |
402 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
vector<int> out={n};
for (int i=1;i<n;i++)
out.push_back(out[out.size()-1]+2);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(3) , {3, 5, 7}));
assert (issame(func0(4) , {4,6,8,10}));
as... | O2 | cpp | func0(int):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %esi,%ebp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov $0x4,%edi
callq 1100 <_Znwm@plt>
lea 0x4(%rax),%rsi
mov %rax,(... | _Z5func0i:
endbr64
push r13
pxor xmm0, xmm0
push r12
mov r12d, esi
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
movups xmmword ptr [rdi], xmm0
mov edi, 4; unsigned __int64
call __Znwm; ope... | long long func0(long long a1, int a2)
{
int *v3; // rax
int *v4; // rdx
int v5; // ebp
int *v6; // rsi
int v7; // eax
int v8; // eax
int v10; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+4h] [rbp-30h]
v11 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
MOV R12D,ESI
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
MOVUPS xmmword ptr [RDI],XMM0
MOV EDI,0x4
LAB_00101628:
CALL 0x001010f0
LEA RDX,[RAX + 0x4]
MOV qword ptr [RBX],RAX... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int iVar1;
int *piVar2;
int *piVar3;
int iVar4;
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_34;
long local_30;
this = (vector<int,std::allocator<int>> *)CONCA... |
403 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
vector<int> out={n};
for (int i=1;i<n;i++)
out.push_back(out[out.size()-1]+2);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(3) , {3, 5, 7}));
assert (issame(func0(4) , {4,6,8,10}));
as... | O3 | cpp | func0(int):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
mov %esi,%ebp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov $0x4,%edi
callq 1100 <_Znwm@plt>
lea 0x4(%rax),%rsi
mov %rax,(%r... | _Z5func0i:
endbr64
push r13
pxor xmm0, xmm0
push r12
mov r12d, esi
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
movups xmmword ptr [rdi], xmm0
mov edi, 4; unsigned __int64
call __Znwm; ope... | long long func0(long long a1, int a2)
{
int *v3; // rax
int *v4; // rsi
int v5; // ebp
int *v6; // rdx
int v7; // eax
int v8; // eax
int v10; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+4h] [rbp-30h]
v11 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
MOV R12D,ESI
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
MOVUPS xmmword ptr [RDI],XMM0
MOV EDI,0x4
LAB_00101728:
CALL 0x001010f0
LEA RSI,[RAX + 0x4]
MOV qword ptr [RBX],RAX... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int iVar1;
int *piVar2;
int *piVar3;
int iVar4;
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_34;
long local_30;
this = (vector<int,std::allocator<int>> *)CONCA... |
404 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(string s){
string current="";
vector<string> out={};
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ' or s[i]==',')
{
if (current.length()>0)
{
out.push_back(current);
current="";
}
}
else current=current+s[i];... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("Hi, my name is John") , {"Hi", "my", "name", "is", "John"}));... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x98,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x85(%rbp),%rax
mov %rax,%rdi
callq 2440 <_... | _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_6D]
mov [rbp+var_68], rax
nop
nop
lea rdx, [rbp... | long long func0(long long a1, long long a2)
{
char *v3; // rax
unsigned long long v4; // rbx
char v6; // [rsp+13h] [rbp-6Dh] BYREF
int i; // [rsp+14h] [rbp-6Ch]
char *v8; // [rsp+18h] [rbp-68h]
_BYTE v9[32]; // [rsp+20h] [rbp-60h] BYREF
_BYTE v10[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v11... | 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 + -0x6d]
MOV qword ptr [RBP + -0x68],RAX
NOP
NOP
LEA RDX,[RBP + -0x6d]
LEA RAX,[RBP + -0x60]
LEA RCX,[0x105008]
M... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,string *param_2)
{
bool bVar1;
char *pcVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
long in_FS_OFFSET;
allocator local_75;
int local_74;
allocator *local_70;
str... |
405 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(string s){
string current="";
vector<string> out={};
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ' or s[i]==',')
{
if (current.length()>0)
{
out.push_back(current);
current="";
}
}
else current=current+s[i];... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("Hi, my name is John") , {"Hi", "my", "name", "is", "John"}));... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x70,%rsp
mov %rdi,%r13
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rdi
lea 0x10(%rsp),%rax
mov %rax... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r12, rdi
mov rbp, rsi
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rdi, [rsp+0A8h+var_88]
lea rax, [rsp+0A8h+var_7... | long long func0(long long a1, void **a2)
{
unsigned long long v4; // rbx
_BYTE *v5; // r13
_BYTE *v6; // rax
void *v7; // rcx
unsigned long long i; // rbx
unsigned int v9; // edx
unsigned long long v10; // rax
unsigned long long v11; // rsi
_BYTE *v12; // rax
char *v13; // rcx
unsigned int v14; /... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R12,RDI
MOV RBP,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x20]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LEA RSI,[0x1032d6]
MOV RDX,RSI
LAB_00101447:
CALL 0x00102116
PXOR XMM0... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,ulong *param_2)
{
char cVar1;
ulong *puVar2;
long *plVar3;
char *pcVar4;
uint uVar5;
int8 uVar6;
long lVar7;
uint uVar8;
ulong uVar9;
ulong uVar10;
long in_FS... |
406 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(string s){
string current="";
vector<string> out={};
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ' or s[i]==',')
{
if (current.length()>0)
{
out.push_back(current);
current="";
}
}
else current=current+s[i];... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("Hi, my name is John") , {"Hi", "my", "name", "is", "John"}));... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
sub $0x88,%rsp
mov (%rsi),%rsi
mov 0x8(%r12),%rdx
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%ea... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
lea rdx, function+0Ah; ""
push r14
push r13
mov r13, rdi
push r12
push rbp
mov rbp, rsi
mov rsi, rdx
push rbx
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rdi,... | long long func0(long long a1, void **a2)
{
size_t v3; // rbx
double *v4; // r15
double *v5; // rdi
size_t v6; // rdx
double v7; // rcx
long long v8; // rbx
size_t v9; // r15
double *v10; // rdi
size_t v11; // rdx
__m128 v12; // xmm0
double v13; // rdx
char v14; // al
unsigned long long v15; /... | func0:
ENDBR64
PUSH R15
LEA RDX,[0x1032f2]
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
MOV RBP,RSI
MOV RSI,RDX
PUSH RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x30]
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x18],RDI
LEA R14,[RSP + 0x50]
LEA R12,[RSP + 0x6... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,ulong *param_2)
{
char cVar1;
ulong uVar2;
long *plVar3;
char *pcVar4;
ulong uVar5;
ulong *puVar6;
long in_FS_OFFSET;
int local_8a;
char local_89;
ulong *local_... |
407 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(string s){
string current="";
vector<string> out={};
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ' or s[i]==',')
{
if (current.length()>0)
{
out.push_back(current);
current="";
}
}
else current=current+s[i];... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("Hi, my name is John") , {"Hi", "my", "name", "is", "John"}));... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0xa8,%rsp
mov (%rsi),%r13
mov 0x8(%rsi),%r12
mov %fs:0x28,%rax
mov %rax,0x98(%r... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
mov r14, rdi
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 98h
mov rbx, [rsi+8]
mov rbp, [rsi]
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
... | long long func0(long long a1, void **a2)
{
size_t v3; // rbx
double *v4; // rbp
double *v5; // rdi
size_t v6; // rdx
double v7; // rcx
void *v8; // rdx
long long v9; // rbx
void *v10; // r15
double *v11; // rdi
size_t v12; // rdx
__m128 v13; // xmm0
double v14; // rdx
size_t v15; // rbp
cha... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV RBX,qword ptr [RSI + 0x8]
MOV RBP,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x50]
MOVUPS xmmword ptr [RDI],XMM0
LEA R13,[RSP + 0x70]
MO... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,ulong *param_2)
{
char cVar1;
ulong *puVar2;
ulong *__dest;
int8 uVar3;
ulong uVar4;
char *pcVar5;
ulong uVar6;
ulong *puVar7;
long in_FS_OFFSET;
ulong **local_... |
408 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int x,int y){
if (y<x) return -1;
if (y==x and y%2==1) return -1;
if (y%2==1) return y-1;
return y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(12, 15) == 14);
assert (func0(13, 12) == -1);
assert (func0(33, 12354) == 12354);
assert (func0(5234, 5233) == -1);
assert (func0(6, 29) == 28);
assert (func0(27, 10) == -1);
assert (func0(7, 7) == -1);
assert (func0(546, 546) =... | O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jge 1166 <_Z5func0ii+0x1d>
mov $0xffffffff,%eax
jmp 11a6 <_Z5func0ii+0x5d>
mov -0x8(%rbp),%eax
cmp -0x4(%rbp),%eax
jne 1188 <_Z5func0ii+0x3f>
mov -0x8(%r... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jge short loc_1166
mov eax, 0FFFFFFFFh
jmp short loc_11B2
loc_1166:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_4]
jnz short loc_118E
mov edx, [rbp+... | long long func0(signed int a1, signed int a2)
{
if ( a2 < a1 )
return 0xFFFFFFFFLL;
if ( a2 == a1 && a2 % 2 == 1 )
return 0xFFFFFFFFLL;
if ( a2 % 2 == 1 )
return (unsigned int)(a2 - 1);
return (unsigned int)a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JGE 0x00101166
MOV EAX,0xffffffff
JMP 0x001011b2
LAB_00101166:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x4]
JNZ 0x0010118e
MOV EDX,dword ptr [R... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
param_2 = -1;
}
else if ((param_2 == param_1) && (param_2 % 2 == 1)) {
param_2 = -1;
}
else if (param_2 % 2 == 1) {
param_2 = param_2 + -1;
}
return param_2;
} |
409 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int x,int y){
if (y<x) return -1;
if (y==x and y%2==1) return -1;
if (y%2==1) return y-1;
return y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(12, 15) == 14);
assert (func0(13, 12) == -1);
assert (func0(33, 12354) == 12354);
assert (func0(5234, 5233) == -1);
assert (func0(6, 29) == 28);
assert (func0(27, 10) == -1);
assert (func0(7, 7) == -1);
assert (func0(546, 546) =... | O1 | cpp | func0(int, int):
endbr64
mov %esi,%eax
cmp %edi,%esi
jl 1167 <_Z5func0ii+0x3e>
je 114e <_Z5func0ii+0x25>
mov %esi,%ecx
shr $0x1f,%ecx
lea (%rsi,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp $0x1,%edx
sete %dl
movzbl %dl,%edx
sub %edx,%eax
retq
mov %esi,%ecx
shr $0x1f,%ecx
lea ... | _Z5func0ii:
endbr64
mov eax, esi
cmp esi, edi
jl short loc_1167
jz short loc_114E
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
and edx, 1
sub edx, ecx
cmp edx, 1
setz dl
movzx edx, dl
sub eax, edx
retn
loc_114E:
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
... | long long func0(signed int a1, signed int a2)
{
long long result; // rax
result = (unsigned int)a2;
if ( a2 < a1 )
return 0xFFFFFFFFLL;
if ( a2 != a1 )
return a2 - (unsigned int)(a2 % 2 == 1);
if ( a2 % 2 == 1 )
return 0xFFFFFFFFLL;
return result;
} | func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDI
JL 0x00101167
JZ 0x0010114e
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP EDX,0x1
SETZ DL
MOVZX EDX,DL
SUB EAX,EDX
RET
LAB_0010114e:
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP EDX,0x1
MOV EDX,0xffffffff
CMOVZ EAX,EDX... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return -1;
}
if (param_2 != param_1) {
return param_2 - (uint)(param_2 % 2 == 1);
}
if (param_2 % 2 == 1) {
param_2 = -1;
}
return param_2;
} |
410 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int x,int y){
if (y<x) return -1;
if (y==x and y%2==1) return -1;
if (y%2==1) return y-1;
return y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(12, 15) == 14);
assert (func0(13, 12) == -1);
assert (func0(33, 12354) == 12354);
assert (func0(5234, 5233) == -1);
assert (func0(6, 29) == 28);
assert (func0(27, 10) == -1);
assert (func0(7, 7) == -1);
assert (func0(546, 546) =... | O2 | cpp | func0(int, int):
endbr64
mov %esi,%eax
cmp %edi,%esi
jl 1180 <_Z5func0ii+0x40>
mov %esi,%ecx
shr $0x1f,%ecx
lea (%rsi,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp %edi,%esi
je 1170 <_Z5func0ii+0x30>
cmp $0x1,%edx
sete %dl
movzbl %dl,%edx
sub %edx,%eax
retq
nopw 0x0(%rax,%rax,1)... | _Z5func0ii:
endbr64
mov eax, esi
cmp esi, edi
jl short loc_1180
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
and edx, 1
sub edx, ecx
cmp esi, edi
jz short loc_1170
cmp edx, 1
setz dl
movzx edx, dl
sub eax, edx
retn
loc_1170:
cmp edx, 1
mov edx, 0FFFFFFFFh
c... | long long func0(int a1, signed int a2)
{
long long result; // rax
int v3; // edx
result = (unsigned int)a2;
if ( a2 < a1 )
return 0xFFFFFFFFLL;
v3 = a2 % 2;
if ( a2 != a1 )
return a2 - (unsigned int)(v3 == 1);
if ( v3 == 1 )
return 0xFFFFFFFFLL;
return result;
} | func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDI
JL 0x00101180
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP ESI,EDI
JZ 0x00101170
CMP EDX,0x1
SETZ DL
MOVZX EDX,DL
SUB EAX,EDX
RET
LAB_00101170:
CMP EDX,0x1
MOV EDX,0xffffffff
CMOVZ EAX,EDX
RET
LAB_00101180:
MOV EAX,0xffffffff
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return -1;
}
if (param_2 != param_1) {
return param_2 - (uint)(param_2 % 2 == 1);
}
if (param_2 % 2 == 1) {
param_2 = -1;
}
return param_2;
} |
411 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int x,int y){
if (y<x) return -1;
if (y==x and y%2==1) return -1;
if (y%2==1) return y-1;
return y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(12, 15) == 14);
assert (func0(13, 12) == -1);
assert (func0(33, 12354) == 12354);
assert (func0(5234, 5233) == -1);
assert (func0(6, 29) == 28);
assert (func0(27, 10) == -1);
assert (func0(7, 7) == -1);
assert (func0(546, 546) =... | O3 | cpp | func0(int, int):
endbr64
mov %esi,%eax
cmp %edi,%esi
jl 1180 <_Z5func0ii+0x40>
mov %esi,%ecx
shr $0x1f,%ecx
lea (%rsi,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp %edi,%esi
je 1170 <_Z5func0ii+0x30>
cmp $0x1,%edx
sete %dl
movzbl %dl,%edx
sub %edx,%eax
retq
nopw 0x0(%rax,%rax,1)... | _Z5func0ii:
endbr64
mov eax, esi
cmp esi, edi
jl short loc_1180
mov ecx, esi
shr ecx, 1Fh
lea edx, [rsi+rcx]
and edx, 1
sub edx, ecx
cmp esi, edi
jz short loc_1170
cmp edx, 1
setz dl
movzx edx, dl
sub eax, edx
retn
loc_1170:
cmp edx, 1
mov edx, 0FFFFFFFFh
c... | long long func0(int a1, signed int a2)
{
long long result; // rax
int v3; // edx
result = (unsigned int)a2;
if ( a2 < a1 )
return 0xFFFFFFFFLL;
v3 = a2 % 2;
if ( a2 != a1 )
return a2 - (unsigned int)(v3 == 1);
if ( v3 == 1 )
return 0xFFFFFFFFLL;
return result;
} | func0:
ENDBR64
MOV EAX,ESI
CMP ESI,EDI
JL 0x00101180
MOV ECX,ESI
SHR ECX,0x1f
LEA EDX,[RSI + RCX*0x1]
AND EDX,0x1
SUB EDX,ECX
CMP ESI,EDI
JZ 0x00101170
CMP EDX,0x1
SETZ DL
MOVZX EDX,DL
SUB EAX,EDX
RET
LAB_00101170:
CMP EDX,0x1
MOV EDX,0xffffffff
CMOVZ EAX,EDX
RET
LAB_00101180:
MOV EAX,0xffffffff
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
if (param_2 < param_1) {
return -1;
}
if (param_2 != param_1) {
return param_2 - (uint)(param_2 % 2 == 1);
}
if (param_2 % 2 == 1) {
param_2 = -1;
}
return param_2;
} |
412 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int n,int m){
if (n>m) return "-1";
int num=(m+n)/2;
string out="";
while (num>0)
{
out=to_string(num%2)+out;
num=num/2;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1, 5) == "11");
assert (func0(7, 13) == "1010");
assert (func0(964,977) == "1111001010");
assert (func0(996,997) == "1111100100");
assert (func0(560,851) == "1011000001");
assert (func0(185,546) == "101101101");
assert (func0(362,... | O0 | cpp | func0[abi:cxx11](int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x98,%rsp
mov %rdi,-0x98(%rbp)
mov %esi,-0x9c(%rbp)
mov %edx,-0xa0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x9c(%rbp),%eax
cmp -0xa0(%rbp),%eax
jle 24c9 <_Z5func0B5cxx11ii+0x80>
lea ... | _Z5func0B5cxx11ii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+var_A8], rdi
mov [rbp+var_AC], esi
mov [rbp+var_B0], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_AC]
cmp eax, [rbp+var_B0]
jle short loc_248D
lea rax, [rbp+... | long long func0[abi:cxx11](long long a1, int a2, int a3)
{
char v4; // [rsp+1Bh] [rbp-95h] BYREF
int v5; // [rsp+1Ch] [rbp-94h]
char *v6; // [rsp+20h] [rbp-90h]
char *v7; // [rsp+28h] [rbp-88h]
_BYTE v8[32]; // [rsp+30h] [rbp-80h] BYREF
_BYTE v9[32]; // [rsp+50h] [rbp-60h] BYREF
_BYTE v10[40]; // [rsp+70... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0xa8],RDI
MOV dword ptr [RBP + -0xac],ESI
MOV dword ptr [RBP + -0xb0],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0xac]
CMP EAX,dword ptr [RBP + -0xb0]
JLE 0x0010248d
LEA ... | /* func0[abi:cxx11](int, int) */
string * func0_abi_cxx11_(int param_1,int param_2)
{
int in_EDX;
int4 in_register_0000003c;
string *this;
long in_FS_OFFSET;
allocator local_9d;
int local_9c;
allocator *local_98;
allocator *local_90;
string local_88 [32];
string local_68 [32];
string local_48 [4... |
413 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int n,int m){
if (n>m) return "-1";
int num=(m+n)/2;
string out="";
while (num>0)
{
out=to_string(num%2)+out;
num=num/2;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1, 5) == "11");
assert (func0(7, 13) == "1010");
assert (func0(964,977) == "1111001010");
assert (func0(996,997) == "1111100100");
assert (func0(560,851) == "1011000001");
assert (func0(185,546) == "101101101");
assert (func0(362,... | O1 | cpp | func0[abi:cxx11](int, int):
endbr64
push %r12
push %rbp
push %rbx
sub $0x70,%rsp
mov %rdi,%r12
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
cmp %edx,%esi
jle 1288 <_Z5func0B5cxx11ii+0x3f>
lea 0x10(%rdi),%rax
mov %rax,(%rdi)
lea 0xdba(%rip),%rdx
lea -0x2(%rdx),%rsi
callq 1b... | _Z5func0B5cxx11ii:
endbr64
push r12
push rbp
push rbx
sub rsp, 70h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+88h+var_20], rax
xor eax, eax
cmp esi, edx
jle short loc_1303
lea rax, [rdi+10h]
mov [rdi], rax
lea rdx, unk_2006
lea rsi, [rdx-2]
call _ZNSt7__cxx1112basic_st... | char ** func0[abi:cxx11](char **a1, int a2, int a3)
{
int v5; // r12d
int v6; // ebx
long long v7; // rdx
char *v8; // rax
long long v9; // rcx
long long v10; // rax
long long v11; // rsi
_DWORD *v12; // r9
_DWORD *v13; // rcx
long long v14; // rdi
unsigned int v15; // ecx
unsigned long long v16... | func0[abi:cxx11]:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
CMP ESI,EDX
JLE 0x00101303
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
LEA RDX,[0x102006]
LEA RSI,[RDX + -0x2]
LAB_001012de:
CALL 0x00101c92
LAB_001012e3:
MOV RAX,qword p... | /* func0[abi:cxx11](int, int) */
long * func0_abi_cxx11_(int param_1,int param_2)
{
char cVar1;
long *plVar2;
uint uVar3;
int8 uVar4;
int8 *puVar5;
ulong uVar6;
long *plVar7;
int in_EDX;
uint uVar8;
long *plVar9;
int iVar10;
long lVar11;
int4 in_register_0000003c;
long *plVar12;
long lVa... |
414 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int n,int m){
if (n>m) return "-1";
int num=(m+n)/2;
string out="";
while (num>0)
{
out=to_string(num%2)+out;
num=num/2;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1, 5) == "11");
assert (func0(7, 13) == "1010");
assert (func0(964,977) == "1111001010");
assert (func0(996,997) == "1111100100");
assert (func0(560,851) == "1011000001");
assert (func0(185,546) == "101101101");
assert (func0(362,... | O2 | cpp | func0[abi:cxx11](int, int):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
cmp %edx,%esi
jle 17e0 <_Z5func0B5cxx11ii+0x70>
lea 0x10(%rdi),%rax
lea 0x890(%rip),%rdx
mov %rax,(%r... | _Z5func0B5cxx11ii:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
cmp esi, edx
jle short loc_18A0
lea rax, [rdi+10h]
lea rdx, unk_2006
mov [rdi], rax
lea rsi, [r... | __m128i ** func0[abi:cxx11](__m128i **a1, int a2, int a3)
{
int v5; // ebp
int v6; // ebx
__m128i *v7; // rcx
long long *v8; // rax
long long *v9; // rdi
__m128i v10; // xmm0
long long v11; // rdx
long long v12; // rax
long long v13; // rdi
long long v14; // rdx
unsigned int v15; // edx
long lon... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
CMP ESI,EDX
JLE 0x001018a0
LEA RAX,[RDI + 0x10]
LEA RDX,[0x102006]
MOV qword ptr [RDI],RAX
LEA RSI,[RDX + -0x2]
LAB_0010186e:
CALL 0x00101780
LA... | /* func0[abi:cxx11](int, int) */
long * func0_abi_cxx11_(int param_1,int param_2)
{
long *plVar1;
uint uVar2;
int8 *puVar3;
long lVar4;
long *plVar5;
int uVar6;
long *in_RCX;
ulong uVar7;
ulong uVar8;
long *plVar9;
int extraout_DL;
int in_EDX;
uint uVar10;
int *puVar11;
int iVar12;
lon... |
415 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int n,int m){
if (n>m) return "-1";
int num=(m+n)/2;
string out="";
while (num>0)
{
out=to_string(num%2)+out;
num=num/2;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1, 5) == "11");
assert (func0(7, 13) == "1010");
assert (func0(964,977) == "1111001010");
assert (func0(996,997) == "1111100100");
assert (func0(560,851) == "1011000001");
assert (func0(185,546) == "101101101");
assert (func0(362,... | O3 | cpp | func0[abi:cxx11](int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
cmp %edx,%esi
jle 1988 <_Z5func0B5cxx11ii+0x78>
lea 0x10(%rdi),%rax
movq $0x2,0x8(%rdi)
mov %rax,(%rdi... | _Z5func0B5cxx11ii:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
cmp esi, edx
jle short loc_17B0
lea rax, [rdi+10h]
mov qword ptr [rdi+8], 2
mov [rdi], rax
mov ... | long long func0[abi:cxx11](long long a1, int a2, int a3)
{
int v5; // esi
int v6; // ebx
long long v7; // rax
long long v8; // rdi
long long v9; // rdx
__m128i *v10; // rcx
long long *v11; // rax
long long *v12; // rdi
__m128i v13; // xmm0
long long v14; // rdx
long long v15; // rcx
__m128i *v1... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
CMP ESI,EDX
JLE 0x001017b0
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI + 0x8],0x2
MOV qword ptr [RDI],RAX
MOV EAX,0x312d
MOV word ptr [RDI + 0x10],A... | /* func0[abi:cxx11](int, int) */
int8 * func0_abi_cxx11_(int param_1,int param_2)
{
ulong *puVar1;
uint uVar2;
int8 *puVar3;
ulong *puVar4;
long lVar5;
int8 *puVar6;
int uVar7;
ulong *in_RCX;
ulong uVar8;
ulong uVar9;
ulong *puVar10;
int extraout_DL;
int in_EDX;
uint uVar11;
int *puVar12... |
416 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> x){
vector<int> out={};
for (int i=0;i<x.size();i++)
{
int num=x[i];
bool u=true;
if (num==0) u=false;
while (num>0 and u)
{
if (num%2==0) u=false;
num=num/10;
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({15, 33, 1422, 1}) , {1, 15, 33}));
assert (issame(func0({152, 3... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
movq $0x0,0x10(%rax)
mov -... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, [rbp+var_28]
pxor xmm0, xmm0
movups xmmword ptr [rax], xmm0
movq qword ptr [rax+10h], xmm0
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorI... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rbx
long long v4; // rax
bool v6; // [rsp+17h] [rbp-19h]
int i; // [rsp+18h] [rbp-18h]
int v8; // [rsp+1Ch] [rbp-14h]
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
std::vector<int>::vector(a1);
for ( i = 0; i < ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x28]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword ptr [RAX + 0x10],XMM0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101c34
MOV dword ptr [RBP + -0x18],... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
uint *puVar4;
int *piVar5;
ulong uVar6;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
vector<int,std::allo... |
417 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> x){
vector<int> out={};
for (int i=0;i<x.size();i++)
{
int num=x[i];
bool u=true;
if (num==0) u=false;
while (num>0 and u)
{
if (num%2==0) u=false;
num=num/10;
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({15, 33, 1422, 1}) , {1, 15, 33}));
assert (issame(func0({152, 3... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r12
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
je 132a <_Z5func0St6vectorIiSaIiEE+0xaa>
mov %rsi,%rbp
mov $0x0,%ebx... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp [rsi+8], rdx
jz short loc_1325
mov rbp, rsi
mov ebx, 0
jmp short loc_12EF
loc_1... | char ** func0(char **a1, long long *a2)
{
long long v3; // rdx
unsigned long long v5; // rbx
int i; // edx
int *v7; // rdi
int v8; // esi
int *v9; // rax
char *v10; // rbp
char *v11; // r13
int v12; // eax
unsigned long long v13; // rax
char *v14; // rbx
int v15; // ecx
char *v16; // rax
int... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDX
JZ 0x00101325
MOV RBP,RSI
MOV EBX,0x0
JMP 0x001012ef
LAB_001012b6:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
uint *puVar1;
int iVar2;
int iVar3;
uint *puVar4;
int *piVar5;
bool bVar6;
int *piVar7;
int *piVar8;
int *piVar9;
uint uVar10;
_Iter_less_iter _Var11;
ulong in_RCX;
uint uVar12;
_I... |
418 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> x){
vector<int> out={};
for (int i=0;i<x.size();i++)
{
int num=x[i];
bool u=true;
if (num==0) u=false;
while (num>0 and u)
{
if (num%2==0) u=false;
num=num/10;
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({15, 33, 1422, 1}) , {1, 15, 33}));
assert (issame(func0({152, 3... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdi
cmp 0x8(%rsi),%rdi
je 184c <_Z5func0St6vectorIiSaIiEE+0x10c>
mov %rsi,%r13
xor %ebp,%ebp
xor... | _Z5func0St6vectorIiSaIiEE:
endbr64
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rdi, [rsi]
cmp [rsi+8], rdi
jz loc_1AF4
mov r12, rsi
xor ebp, ebp
xor r14d, r14d
mov ebx, 0CC... | int ** func0(int **a1, long long *a2)
{
long long v3; // rdi
unsigned long long v5; // rbp
int *v6; // r14
int v7; // esi
unsigned int v8; // eax
int v9; // edx
char v10; // cl
int *v11; // rbp
long long v12; // rdx
unsigned long long v13; // rax
int *v14; // rbx
int v15; // ecx
int v16; // ed... | func0:
ENDBR64
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDI
JZ 0x00101af4
MOV R12,RSI
XOR EBP,EBP
XOR R14D,R14D
MOV EBX,0xcccccccd
NOP dword ptr [RAX + RAX*0x1]
LAB_00101a20:
LEA... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
uint uVar1;
uint *puVar2;
uint uVar3;
ulong uVar4;
uint *puVar5;
char cVar6;
uint uVar7;
ulong in_RCX;
_Iter_less_iter extraout_EDX;
long lVar8;
uint *puVar9;
ulong uVar10;
long *in_... |
419 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> x){
vector<int> out={};
for (int i=0;i<x.size();i++)
{
int num=x[i];
bool u=true;
if (num==0) u=false;
while (num>0 and u)
{
if (num%2==0) u=false;
num=num/10;
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({15, 33, 1422, 1}) , {1, 15, 33}));
assert (issame(func0({152, 3... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rdi
mov 0x8(%rsi),%r8
cmp %r8,%rdi
je 1884 <_Z5func0St6vectorIiSaIiEE+0x... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 8
movups xmmword ptr [rdi], xmm0
mov r8, [rsi+8]
mov qword ptr [rdi+10h], 0
mov rdi, [rsi]
cmp rdi, r8
jz loc_1B1C
mov r13, rsi
xor eb... | int ** func0(int **a1, long long *a2)
{
long long v3; // r8
long long v4; // rdi
unsigned long long v6; // rbp
int *v7; // r14
int v8; // esi
unsigned int v9; // eax
int v10; // edx
char v11; // cl
int *v12; // r15
int *v13; // rbx
unsigned long long v14; // rdx
int *v15; // rbp
int v16; // r1... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVUPS xmmword ptr [RDI],XMM0
MOV R8,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOV RDI,qword ptr [RSI]
CMP RDI,R8
JZ 0x00101b1c
MOV R13,RSI
XOR EBP,EBP
XOR R14D,R14D
MOV EBX,0xcccccccd
NOP dword ptr [R... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
uint uVar4;
ulong uVar5;
char cVar6;
uint uVar7;
ulong in_RCX;
size_t sVar8;
uint *puVar9;
ulong uVar10;
uint *puVar11;
long *in_RSI;
int4 i... |
420 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(vector<int> arr){
map<int,string> numto={{0,"Zero"},{1,"One"},{2,"Two"},{3,"Three"},{4,"Four"},{5,"Five"},{6,"Six"},{7,"Seven"},{8,"Eight"},{9,"Nine"}};
sort(arr.begin(),arr.end());
vector<string> out={};
for (int i=arr.size()-1;i>=0;i-=1)
if (arr[i]>=1 and arr[i]<=9)
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({2, 1, 1, 4, 5, 8, 2, 3}) , {"Eight", "Five", "Four", "Three",... | O0 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x218,%rsp
mov %rdi,-0x228(%rbp)
mov %rsi,-0x230(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movl $0x0,-0x21c(%rbp)
lea -0x21c(%rbp),%rcx
lea -... | _Z5func0B5cxx11St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 228h
mov [rbp+var_248], rdi
mov [rbp+var_250], rsi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea r13, [rbp+var_1D0]
mov ebx, 9
mov rcx,... | long long func0[abi:cxx11](long long a1, long long a2)
{
_BYTE *i; // rbx
long long v3; // rbx
long long v4; // rax
long long v6; // rax
long long v7; // rax
char v9; // [rsp+1Ah] [rbp-236h] BYREF
char v10; // [rsp+1Bh] [rbp-235h] BYREF
int v11; // [rsp+1Ch] [rbp-234h] BYREF
int v12; // [rsp+20h] [rb... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x228
MOV qword ptr [RBP + -0x248],RDI
MOV qword ptr [RBP + -0x250],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA R13,[RBP + -0x1d0]
MOV EBX,0x9
MOV RCX,R13
MOV dword ptr [RBP + -0x234],... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> >) */
vector<std::string,std::allocator<std::string>> * func0_abi_cxx11_(vector param_1)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int *piVar4;
string *psVar5;
pair<int_const,std::string> *this;
vector<int,std::allocator<int>... |
421 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(vector<int> arr){
map<int,string> numto={{0,"Zero"},{1,"One"},{2,"Two"},{3,"Three"},{4,"Four"},{5,"Five"},{6,"Six"},{7,"Seven"},{8,"Eight"},{9,"Nine"}};
sort(arr.begin(),arr.end());
vector<string> out={};
for (int i=arr.size()-1;i>=0;i-=1)
if (arr[i]>=1 and arr[i]<=9)
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({2, 1, 1, 4, 5, 8, 2, 3}) , {"Eight", "Five", "Four", "Three",... | O1 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1f8,%rsp
mov %rdi,%r15
mov %rsi,%r14
mov %fs:0x28,%rax
mov %rax,0x1e8(%rsp)
xor %eax,%eax
movl $0x0,0x50(%rsp)
lea 0x50(%rsp),%rbx
lea 0x68(%rsp),%ra... | _Z5func0B5cxx11St6vectorIiSaIiEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1E0h
mov r12, rdi
mov rbp, rsi
mov rax, fs:28h
mov [rsp+208h+var_30], rax
xor eax, eax
mov [rsp+208h+var_1C8], 0
lea rax, [rsp+208h+var_1B0]
mov [rsp+208h+var_1C0], rax
lea ... | long long func0[abi:cxx11](long long a1, char **a2)
{
int *v4; // rbx
_QWORD *v5; // rbx
_QWORD *v6; // rdi
char *v7; // rbx
char *v8; // r14
int v9; // eax
unsigned long long v10; // rax
char *v11; // rdi
char *v12; // rsi
int v13; // ecx
char *v14; // rax
int v15; // edx
int v16; // ebx
l... | func0[abi:cxx11]:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1e0
MOV R12,RDI
MOV RBP,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1d8],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x40],0x0
LEA RAX,[RSP + 0x58]
MOV qword ptr [RSP + 0x48],RAX
LEA RDI,[RSP + 0x48]
LEA RDX,[0x1031c3]
LEA RSI,[RDX + -... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> >) */
vector<std::string,std::allocator<std::string>> *
func0_abi_cxx11_(vector param_1,int param_2,int param_3,int param_4,
int param_5,int param_6,int8 param_7,int1 param_8,
int1 param_9,int8 param_10,int8 param_11)
{
int iVa... |
422 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(vector<int> arr){
map<int,string> numto={{0,"Zero"},{1,"One"},{2,"Two"},{3,"Three"},{4,"Four"},{5,"Five"},{6,"Six"},{7,"Seven"},{8,"Eight"},{9,"Nine"}};
sort(arr.begin(),arr.end());
vector<string> out={};
for (int i=arr.size()-1;i>=0;i-=1)
if (arr[i]>=1 and arr[i]<=9)
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({2, 1, 1, 4, 5, 8, 2, 3}) , {"Eight", "Five", "Four", "Three",... | O2 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> >):
endbr64
push %r15
mov $0x7754,%edx
mov $0x6953,%ecx
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x1f8,%rsp
mov %rsi,0x8(%rsp)
lea 0x50(%rsp),%rbx
lea 0x28(%rsp),%rbp
lea 0x20(%rsp),%r14
mov %fs:0x28... | _Z5func0B5cxx11St6vectorIiSaIiEE:
endbr64
push r15
mov edx, 7754h
mov ecx, 6953h
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
sub rsp, 208h
mov [rsp+238h+var_220], rdi
lea rbx, [rsp+238h+var_1D8]
lea r13, [rsp+238h+var_200]
lea r15, [rsp+238h+var_48]
mov ... | long long func0[abi:cxx11](long long a1, char **a2)
{
unsigned int *v3; // rbx
long long v4; // r12
long long v5; // rsi
long long v6; // rdx
int v7; // r12d
long long insert_hint_unique_pos; // rax
int *v9; // rdx
int *v10; // rbp
char *v11; // rbx
char *v12; // rdi
char *v13; // rbp
char *v14... | func0[abi:cxx11]:
ENDBR64
PUSH R15
MOV EDX,0x7754
MOV ECX,0x6953
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x208
MOV qword ptr [RSP + 0x18],RDI
LEA RBX,[RSP + 0x60]
LEA R13,[RSP + 0x38]
LEA R15,[RSP + 0x1f0]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1f8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> >) */
vector<std::string,std::allocator<std::string>> *
func0_abi_cxx11_(vector param_1,int param_2,int param_3,int param_4,
int param_5,int param_6,int8 param_7,int8 param_8,
int8 param_9,int param_10,int8 param_11,int8 param_12,... |
423 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(vector<int> arr){
map<int,string> numto={{0,"Zero"},{1,"One"},{2,"Two"},{3,"Three"},{4,"Four"},{5,"Five"},{6,"Six"},{7,"Seven"},{8,"Eight"},{9,"Nine"}};
sort(arr.begin(),arr.end());
vector<string> out={};
for (int i=arr.size()-1;i>=0;i-=1)
if (arr[i]>=1 and arr[i]<=9)
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({2, 1, 1, 4, 5, 8, 2, 3}) , {"Eight", "Five", "Four", "Three",... | O3 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> >):
endbr64
push %r15
mov $0x7754,%edx
mov $0x6953,%ecx
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x228,%rsp
mov %rdi,0x28(%rsp)
lea 0x58(%rsp),%r12
lea 0x50(%rsp),%r13
mov %rsi,0x8(%rsp)
lea 0x80(%rsp),%rbx
mov %f... | _Z5func0B5cxx11St6vectorIiSaIiEE:
endbr64
push r15
mov edx, 7754h
mov ecx, 6953h
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 228h
mov [rsp+258h+var_230], rdi
lea rbx, [rsp+258h+var_1D8]
lea r12, [rsp+258h+var_200]
mov [rsp+258h+var_248], rsi
lea r15, [rsp+258h... | long long func0[abi:cxx11](long long a1, int **a2)
{
unsigned int *v2; // rbx
int v3; // ebp
long long insert_hint_unique_pos; // rax
int *v5; // rdx
int *v6; // r13
long long v7; // rbp
_BYTE *v8; // rsi
size_t v9; // r14
_BYTE *v10; // rdi
long long v11; // rax
char *v12; // rbx
char *v13; //... | func0[abi:cxx11]:
ENDBR64
PUSH R15
MOV EDX,0x7754
MOV ECX,0x6953
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x228
MOV qword ptr [RSP + 0x28],RDI
LEA RBX,[RSP + 0x80]
LEA R12,[RSP + 0x58]
MOV qword ptr [RSP + 0x10],RSI
LEA R15,[RSP + 0x210]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x218],RAX
XOR EAX,EA... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> >) */
vector<std::string,std::allocator<std::string>> *
func0_abi_cxx11_(vector param_1,int param_2,int param_3,int param_4,
int param_5,int param_6,int8 param_7,int8 param_8,
int8 param_9,int param_10,int8 param_11,int8 param_12,... |
424 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
int sum=0,prod=1;
vector<int> out={};
for (int i=1;i<=n;i++)
{
sum+=i;
prod*=i;
if (i%2==0) out.push_back(prod);
else out.push_back(sum);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5) , {1, 2, 6, 24, 15}));
assert (issame(func0(7) , {1, 2, 6, 24... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x24(%rbp)
movl $0x1,-0x20(%rbp)
mov -0x38(%rbp),%rax
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
movq $0x0,0x10(%... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_24], 0
mov [rbp+var_20], 1
mov rax, [rbp+var_38]
pxor xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov... | long long func0(long long a1, int a2)
{
int v3; // [rsp+1Ch] [rbp-24h] BYREF
int v4; // [rsp+20h] [rbp-20h] BYREF
int i; // [rsp+24h] [rbp-1Ch]
unsigned long long v6; // [rsp+28h] [rbp-18h]
v6 = __readfsqword(0x28u);
v3 = 0;
v4 = 1;
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
std::vector<int>... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x1
MOV RAX,qword ptr [RBP + -0x38]
PXOR XMM0,XMM0
MOVUPS xmmword ... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_2c;
int local_28;
uint local_24;
long local_20;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003... |
425 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
int sum=0,prod=1;
vector<int> out={};
for (int i=1;i<=n;i++)
{
sum+=i;
prod*=i;
if (i%2==0) out.push_back(prod);
else out.push_back(sum);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5) , {1, 2, 6, 24, 15}));
assert (issame(func0(7) , {1, 2, 6, 24... | 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
movl $0x0,(%rsp)
movl $0x1,0x4(%rsp)
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
test %esi,%esi
jle 1359 <_Z5func0i+0xd9>
mov ... | _Z5func0i:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
mov [rsp+28h+var_28], 0
mov [rsp+28h+var_24], 1
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
test esi, esi
jle l... | long long func0(long long a1, int a2)
{
int i; // ebx
_DWORD *v4; // rsi
int v5; // eax
int v6; // edx
int *v7; // rsi
int v9; // [rsp+0h] [rbp-28h] BYREF
int v10; // [rsp+4h] [rbp-24h] BYREF
unsigned long long v11; // [rsp+8h] [rbp-20h]
v11 = __readfsqword(0x28u);
v9 = 0;
v10 = 1;
*(_OWORD *)... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x4],0x1
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
TEST ESI,ESI
JLE 0x0010135e
MOV R12D,ESI
MOV EBX,0x1
... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int *piVar1;
uint uVar2;
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_28;
int local_24;
long local_20;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_regi... |
426 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
int sum=0,prod=1;
vector<int> out={};
for (int i=1;i<=n;i++)
{
sum+=i;
prod*=i;
if (i%2==0) out.push_back(prod);
else out.push_back(sum);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5) , {1, 2, 6, 24, 15}));
assert (issame(func0(7) , {1, 2, 6, 24... | 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
movl $0x0,(%rsp)
movl $0x1,0x4(%rsp)
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
test %esi,%esi
jle 16f8 <_Z5func0i+0xb8>
mov ... | _Z5func0i:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov [rsp+38h+var_38], 0
mov [rsp+38h+var_34], 1
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
te... | long long func0(long long a1, int a2)
{
int *v2; // rax
int v4; // r12d
int *v5; // rsi
int v6; // ebp
int v7; // ebx
int v9; // [rsp+0h] [rbp-38h] BYREF
int v10; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+8h] [rbp-30h]
v11 = __readfsqword(0x28u);
v2 = 0LL;
v9 = 0;
v10 = 1;
... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x4],0x1
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
TEST ESI,ESI
JLE 0x001015ea
MOV R14... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int *piVar1;
uint uVar2;
int iVar3;
int in_ESI;
int *piVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int iVar5;
long in_FS_OFFSET;
int local_38;
int local_34;
long local_30;
this = (vector<in... |
427 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
int sum=0,prod=1;
vector<int> out={};
for (int i=1;i<=n;i++)
{
sum+=i;
prod*=i;
if (i%2==0) out.push_back(prod);
else out.push_back(sum);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5) , {1, 2, 6, 24, 15}));
assert (issame(func0(7) , {1, 2, 6, 24... | 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
movl $0x0,(%rsp)
movl $0x1,0x4(%rsp)
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
test %esi,%esi
jle 16d0 <_Z5func0i+0xb0>
mov %... | _Z5func0i:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov [rsp+38h+var_38], 0
mov [rsp+38h+var_34], 1
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
te... | long long func0(long long a1, int a2)
{
int *v2; // rax
int v4; // r12d
int *v5; // rsi
int v6; // ebp
int v7; // ebx
int v9; // [rsp+0h] [rbp-38h] BYREF
int v10; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+8h] [rbp-30h]
v11 = __readfsqword(0x28u);
v2 = 0LL;
v9 = 0;
v10 = 1;
... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x4],0x1
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
TEST ESI,ESI
JLE 0x001016ba
MOV R14... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int *piVar1;
uint uVar2;
int iVar3;
int in_ESI;
int *piVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int iVar5;
long in_FS_OFFSET;
int local_38;
int local_34;
long local_30;
this = (vector<in... |
428 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
int num1=0,num2=0;
for (int i=1;i<=n;i++)
{
string w=to_string(i);
string p(w.rbegin(),w.rend());
if (w==p and i%2==1) num1+=1;
if (w==p and i%2==0) num2+=1;
}
return {num2,num1};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(123) , {8, 13}));
assert (issame(func0(12) , {4, 6}));
asser... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x88,%rsp
mov %rdi,-0x98(%rbp)
mov %esi,-0x9c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movl $0x0,-0x8c(%rbp)
movl $0x0,-0x88(%rbp)
movl $0x1,-0x84(%rbp)
mov -0x84(%rbp),%eax
cmp -0x9... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 98h
mov [rbp+var_A8], rdi
mov [rbp+var_AC], esi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov [rbp+var_9C], 0
mov [rbp+var_98], 0
mov [rbp+var_94], 1
jmp loc_25BE
loc_249C:
lea ... | long long func0(long long a1, int a2)
{
char v5; // [rsp+13h] [rbp-9Dh] BYREF
int v6; // [rsp+14h] [rbp-9Ch]
int v7; // [rsp+18h] [rbp-98h]
int i; // [rsp+1Ch] [rbp-94h]
_BYTE v9[8]; // [rsp+20h] [rbp-90h] BYREF
_BYTE v10[8]; // [rsp+28h] [rbp-88h] BYREF
char *v11; // [rsp+30h] [rbp-80h]
_BYTE *v12; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0xa8],RDI
MOV dword ptr [RBP + -0xac],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x9c],0x0
MOV dword ptr [RBP + -0x98],0x0
MOV dword ptr [RBP + -0x94],0x1
JMP 0x001025... | /* func0(int) */
int8 func0(int param_1)
{
bool bVar1;
int in_ESI;
int4 in_register_0000003c;
long in_FS_OFFSET;
allocator local_a5;
int local_a4;
int local_a0;
uint local_9c;
int local_98 [8];
__new_allocator<int> local_90 [8];
allocator *local_88;
__new_allocator<int> *local_80;
string loc... |
429 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
int num1=0,num2=0;
for (int i=1;i<=n;i++)
{
string w=to_string(i);
string p(w.rbegin(),w.rend());
if (w==p and i%2==1) num1+=1;
if (w==p and i%2==0) num2+=1;
}
return {num2,num1};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(123) , {8, 13}));
assert (issame(func0(12) , {4, 6}));
asser... | O1 | cpp | func0(int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %rdi,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
test %esi,%esi
jle 143b <_Z5func0i+0x19b>
mov %esi,%r14d
mov $0x1,%r12d
movl $0x0,0x14(%rsp)
mov $0x0,%r15d
le... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 148h
mov [rsp+178h+var_170], rdi
mov rax, fs:28h
mov [rsp+178h+var_40], rax
xor eax, eax
test esi, esi
jle loc_1948
mov r13d, esi
mov r12d, 1
mov [rsp+178h+var_174], 0
mov r14d,... | unsigned long long ** func0(unsigned long long **a1, int a2)
{
int v2; // r12d
long long v3; // r14
unsigned int v4; // ebx
char *v5; // r15
int v6; // ebp
char v7; // bp
char *v8; // r15
size_t v9; // rbp
char *v10; // rbx
char *v11; // rax
char *v12; // rbx
char *v13; // rbp
unsigned int v14... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x148
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x138],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x00101948
MOV R13D,ESI
MOV R12D,0x1
MOV dword ptr [RSP + 0x4],0x0
MOV R14D,0x0
JMP 0x00101606
LAB_00101334:
MOV EBX,0... | /* func0(int) */
int8 * func0(int param_1)
{
byte bVar1;
long *plVar2;
uint uVar3;
int iVar4;
ulong *puVar5;
int8 *puVar6;
uint uVar7;
uint uVar8;
ulong uVar9;
uint uVar10;
long *plVar11;
char cVar12;
ulong uVar13;
int in_ESI;
int4 in_register_0000003c;
int8 *puVar14;
uint uVar15;
... |
430 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
int num1=0,num2=0;
for (int i=1;i<=n;i++)
{
string w=to_string(i);
string p(w.rbegin(),w.rend());
if (w==p and i%2==1) num1+=1;
if (w==p and i%2==0) num2+=1;
}
return {num2,num1};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(123) , {8, 13}));
assert (issame(func0(12) , {4, 6}));
asser... | O2 | cpp | func0(int):
endbr64
push %r15
mov %esi,%eax
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %rdi,0x28(%rsp)
mov %esi,0x8(%rsp)
mov %fs:0x28,%rsi
mov %rsi,0x88(%rsp)
xor %esi,%esi
test %eax,%eax
jle 1b38 <_Z5func0i+0x218>
lea 0x60(%rsp),%rax
movl $0x0,0xc(%... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 168h
mov [rsp+198h+var_170], rdi
mov [rsp+198h+var_180], esi
mov rax, fs:28h
mov [rsp+198h+var_40], rax
xor eax, eax
test esi, esi
jle loc_1CF0
lea rax, [rsp+198h+s1]
mov ebp, 1
lea... | long long func0(long long a1, int a2)
{
int v2; // ebp
unsigned int v3; // r12d
unsigned int v4; // ebx
long long v5; // rsi
_BYTE *v6; // rcx
unsigned int v7; // eax
unsigned int v8; // esi
long long v9; // rax
long long v10; // rdi
long long v11; // rdx
__int8 v12; // r12
size_t v13; // r12
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x168
MOV qword ptr [RSP + 0x28],RDI
MOV dword ptr [RSP + 0x18],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x158],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x00101cf0
LEA RAX,[RSP + 0x40]
MOV EBP,0x1
LEA R15,[RSP + 0x50]
MOV dword ptr [RSP + ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int (*) [16] func0(int param_1)
{
uint uVar1;
int uVar2;
long *plVar3;
uint uVar4;
int iVar5;
ulong *puVar6;
ulong *puVar7;
int8 *puVar8;
ulong *__s2;
uint uVar9;
uint uVar10;
long *plVar11;
... |
431 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
int num1=0,num2=0;
for (int i=1;i<=n;i++)
{
string w=to_string(i);
string p(w.rbegin(),w.rend());
if (w==p and i%2==1) num1+=1;
if (w==p and i%2==0) num2+=1;
}
return {num2,num1};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(123) , {8, 13}));
assert (issame(func0(12) , {4, 6}));
asser... | O3 | cpp | func0(int):
endbr64
push %r15
mov %esi,%eax
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %rdi,0x28(%rsp)
mov %esi,0x8(%rsp)
mov %fs:0x28,%rsi
mov %rsi,0x88(%rsp)
xor %esi,%esi
test %eax,%eax
jle 1cd0 <_Z5func0i+0x230>
lea 0x60(%rsp),%rax
movl $0x0,0xc(%... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 168h
mov [rsp+198h+var_170], rdi
mov [rsp+198h+var_180], esi
mov rax, fs:28h
mov [rsp+198h+var_40], rax
xor eax, eax
test esi, esi
jle loc_1E4A
lea rax, [rsp+198h+s1]
mov ebp, 1
lea... | long long func0(long long a1, int a2)
{
int v2; // ebp
unsigned int v3; // r12d
unsigned int v4; // ebx
long long v5; // rsi
_BYTE *v6; // rcx
unsigned int v7; // eax
unsigned int v8; // esi
long long v9; // rax
long long v10; // rdi
long long v11; // rdx
__int8 v12; // r12
size_t v13; // r12
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x168
MOV qword ptr [RSP + 0x28],RDI
MOV dword ptr [RSP + 0x18],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x158],RAX
XOR EAX,EAX
TEST ESI,ESI
JLE 0x00101e4a
LEA RAX,[RSP + 0x40]
MOV EBP,0x1
LEA R15,[RSP + 0x50]
MOV dword ptr [RSP + ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int (*) [16] func0(int param_1)
{
uint uVar1;
int uVar2;
long *plVar3;
uint uVar4;
int iVar5;
ulong *puVar6;
ulong *puVar7;
int8 *puVar8;
ulong *__s2;
uint uVar9;
long *plVar10;
uint uVar11;
... |
432 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> n){
int num=0;
for (int i=0;i<n.size();i++)
if (n[i]>0) num+=1;
else
{
int sum=0;
int w;
w=abs(n[i]);
while (w>=10)
{
sum+=w%10;
w=w/10;
}
sum-=w;
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == 0);
assert (func0({-1, -2, 0}) == 0);
assert (func0({1, 1, 2, -2, 3, 4, 5}) == 6);
assert (func0({1, 6, 9, -6, 0, 1, 5}) == 5);
assert (func0({1, 100, 98, -7, 1, -1}) == 4);
assert (func0({12, 23, 34, -45, -56, 0}) == 5);
ass... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1c2c <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %r... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
jmp loc_1325
loc_126D:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiS... | long long func0(long long a1)
{
int v1; // eax
unsigned int v3; // [rsp+10h] [rbp-20h]
int i; // [rsp+14h] [rbp-1Ch]
int v5; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
v3 = 0;
for ( i = 0; i < (unsigned long long)std::vector<int>::size(a1); ++i )
{
if ( *(int *)std::vector<int>::operator... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101325
LAB_0010126d:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101d66
MOV EAX,dword ptr ... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int *piVar1;
ulong uVar2;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int local_28;
int local_24;
int local_20;
int local_1c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_000000... |
433 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> n){
int num=0;
for (int i=0;i<n.size();i++)
if (n[i]>0) num+=1;
else
{
int sum=0;
int w;
w=abs(n[i]);
while (w>=10)
{
sum+=w%10;
w=w/10;
}
sum-=w;
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == 0);
assert (func0({-1, -2, 0}) == 0);
assert (func0({1, 1, 2, -2, 3, 4, 5}) == 6);
assert (func0({1, 6, 9, -6, 0, 1, 5}) == 5);
assert (func0({1, 100, 98, -7, 1, -1}) == 4);
assert (func0({12, 23, 34, -45, -56, 0}) == 5);
ass... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%r9
sub %rax,%r9
mov %r9,%rsi
shr $0x2,%rsi
je 128f <_Z5func0St6vectorIiSaIiEE+0x86>
mov %rax,%rsi
add %rax,%r9
mov $0x0,%r8d
jmp 1283 <_Z5func0St6vectorIiSaIiEE+0x7a>
mov %edx,%eax
sar $0x1f,%eax
x... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov r10, [rdi]
mov r11, rax
sub r11, r10
sar r11, 2
cmp rax, r10
jz short loc_128F
mov esi, 0
mov r9d, 0
jmp short loc_1281
loc_1230:
mov edx, eax
neg edx
cmovs edx, eax
cmp edx, 9
jle short loc_1278
mov e... | long long func0(long long *a1)
{
long long v1; // r10
unsigned long long v2; // r11
unsigned long long v3; // rsi
unsigned int v4; // r9d
int v5; // edx
int v6; // edi
int v7; // eax
int v8; // ecx
int v9; // eax
v1 = *a1;
v2 = (a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
{
return 0;
}
el... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV R10,qword ptr [RDI]
MOV R11,RAX
SUB R11,R10
SAR R11,0x2
CMP RAX,R10
JZ 0x0010128f
MOV ESI,0x0
MOV R9D,0x0
JMP 0x00101281
LAB_00101230:
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
CMP EDX,0x9
JLE 0x00101278
MOV EDI,0x0
LAB_00101241:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
long lVar1;
long lVar2;
bool bVar3;
int iVar4;
int iVar5;
ulong uVar6;
int iVar7;
int4 in_register_0000003c;
int iVar8;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_reg... |
434 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> n){
int num=0;
for (int i=0;i<n.size();i++)
if (n[i]>0) num+=1;
else
{
int sum=0;
int w;
w=abs(n[i]);
while (w>=10)
{
sum+=w%10;
w=w/10;
}
sum-=w;
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == 0);
assert (func0({-1, -2, 0}) == 0);
assert (func0({1, 1, 2, -2, 3, 4, 5}) == 6);
assert (func0({1, 6, 9, -6, 0, 1, 5}) == 5);
assert (func0({1, 100, 98, -7, 1, -1}) == 4);
assert (func0({12, 23, 34, -45, -56, 0}) == 5);
ass... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%r10
sub %rsi,%r10
mov %r10,%rax
shr $0x2,%rax
je 172a <_Z5func0St6vectorIiSaIiEE+0x8a>
add %rsi,%r10
xor %r8d,%r8d
mov $0xcccccccd,%r9d
jmp 16d5 <_Z5func0St6vectorIiSaIiEE+0x35>
nopl (%rax)
add $0x1... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbx
mov rax, [rdi+8]
mov r11, [rdi]
mov rbx, rax
sub rbx, r11
sar rbx, 2
cmp rax, r11
jz short loc_1689
xor esi, esi
xor r9d, r9d
mov r10d, 0CCCCCCCDh
jmp short loc_163D
loc_1630:
add r9d, 1
loc_1634:
add rsi, 1
cmp rsi,... | long long func0(long long *a1)
{
long long v1; // r11
unsigned long long v2; // rbx
unsigned long long v3; // rsi
unsigned int v4; // r9d
int v5; // eax
unsigned int v6; // edx
int v7; // edi
unsigned int v8; // r8d
int v9; // ecx
v1 = *a1;
v2 = (a1[1] - *a1) >> 2;
if ( a1[1] != *a1 )
{
... | func0:
ENDBR64
PUSH RBX
MOV RAX,qword ptr [RDI + 0x8]
MOV R11,qword ptr [RDI]
MOV RBX,RAX
SUB RBX,R11
SAR RBX,0x2
CMP RAX,R11
JZ 0x00101689
XOR ESI,ESI
XOR R9D,R9D
MOV R10D,0xcccccccd
JMP 0x0010163d
LAB_00101630:
ADD R9D,0x1
LAB_00101634:
ADD RSI,0x1
CMP RSI,RBX
JNC 0x00101684
LAB_0010163d:
MOV EAX,dword ptr [R11 + RSI... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
long lVar2;
long lVar3;
bool bVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
int iVar8;
int4 in_register_0000003c;
int iVar9;
lVar2 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar3 = *(long *)... |
435 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> n){
int num=0;
for (int i=0;i<n.size();i++)
if (n[i]>0) num+=1;
else
{
int sum=0;
int w;
w=abs(n[i]);
while (w>=10)
{
sum+=w%10;
w=w/10;
}
sum-=w;
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == 0);
assert (func0({-1, -2, 0}) == 0);
assert (func0({1, 1, 2, -2, 3, 4, 5}) == 6);
assert (func0({1, 6, 9, -6, 0, 1, 5}) == 5);
assert (func0({1, 100, 98, -7, 1, -1}) == 4);
assert (func0({12, 23, 34, -45, -56, 0}) == 5);
ass... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%r10
sub %rsi,%r10
mov %r10,%rax
shr $0x2,%rax
je 177a <_Z5func0St6vectorIiSaIiEE+0x8a>
add %rsi,%r10
xor %r8d,%r8d
mov $0xcccccccd,%r9d
jmp 1725 <_Z5func0St6vectorIiSaIiEE+0x35>
nopl (%rax)
add $0x1... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbx
mov rax, [rdi+8]
mov r11, [rdi]
mov rbx, rax
sub rbx, r11
sar rbx, 2
cmp rax, r11
jz short loc_1689
xor esi, esi
xor r9d, r9d
mov r10d, 0CCCCCCCDh
jmp short loc_163D
loc_1630:
add r9d, 1
loc_1634:
add rsi, 1
cmp rsi,... | long long func0(long long *a1)
{
long long v1; // r11
unsigned long long v2; // rbx
unsigned long long v3; // rsi
unsigned int v4; // r9d
int v5; // eax
unsigned int v6; // edx
int v7; // edi
unsigned int v8; // r8d
int v9; // ecx
v1 = *a1;
v2 = (a1[1] - *a1) >> 2;
if ( a1[1] != *a1 )
{
... | func0:
ENDBR64
PUSH RBX
MOV RAX,qword ptr [RDI + 0x8]
MOV R11,qword ptr [RDI]
MOV RBX,RAX
SUB RBX,R11
SAR RBX,0x2
CMP RAX,R11
JZ 0x00101689
XOR ESI,ESI
XOR R9D,R9D
MOV R10D,0xcccccccd
JMP 0x0010163d
LAB_00101630:
ADD R9D,0x1
LAB_00101634:
ADD RSI,0x1
CMP RSI,RBX
JNC 0x00101684
LAB_0010163d:
MOV EAX,dword ptr [R11 + RSI... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
long lVar2;
long lVar3;
bool bVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
int iVar8;
int4 in_register_0000003c;
int iVar9;
lVar2 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar3 = *(long *)... |
436 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> arr){
int num=0;
if (arr.size()==0) return true;
for (int i=1;i<arr.size();i++)
if (arr[i]<arr[i-1]) num+=1;
if (arr[arr.size()-1]>arr[0]) num+=1;
if (num<2) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({3, 4, 5, 1, 2})==true);
assert (func0({3, 5, 10, 1, 2})==true);
assert (func0({4, 3, 1, 2})==false);
assert (func0({3, 5, 4, 1, 2})==false);
assert (func0({})==true);
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 17a4 <_ZNKSt6vectorIiSaIiEE4sizeEv>
test %rax,%rax
sete %al
test %al,%al
je 1261 <_Z5func0St6vectorI... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_18], 0
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
test rax, rax
setz al
test al, al
jz short loc_1281
m... | _BOOL8 func0(long long a1)
{
int v2; // ebx
long long v3; // rax
int v4; // ebx
int v5; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v5 = 0;
if ( !std::vector<int>::size(a1) )
return 1LL;
for ( i = 1; i < (unsigned long long)std::vector<int>::size(a1); ++i )
{
v2 = *(_DWORD *)std::ve... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101830
TEST RAX,RAX
SETZ AL
TEST AL,AL
JZ 0x00101281
MOV EAX,0x1
JMP 0x0010133b
LAB_00101281:
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001012cc
LAB_... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int iVar1;
long lVar2;
int8 uVar3;
ulong uVar4;
int *piVar5;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int4 local_20;
int4 local_1c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_reg... |
437 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> arr){
int num=0;
if (arr.size()==0) return true;
for (int i=1;i<arr.size();i++)
if (arr[i]<arr[i-1]) num+=1;
if (arr[arr.size()-1]>arr[0]) num+=1;
if (num<2) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({3, 4, 5, 1, 2})==true);
assert (func0({3, 5, 10, 1, 2})==true);
assert (func0({4, 3, 1, 2})==false);
assert (func0({3, 5, 4, 1, 2})==false);
assert (func0({})==true);
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov 0x8(%rdi),%r8
mov (%rdi),%rdi
mov %r8,%rdx
sub %rdi,%rdx
mov %rdx,%rax
sar $0x2,%rax
cmp %r8,%rdi
je 126b <_Z5func0St6vectorIiSaIiEE+0x62>
cmp $0x1,%rax
jbe 1264 <_Z5func0St6vectorIiSaIiEE+0x5b>
mov %rdi,%rax
lea -0x4(%rdi,%... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov r8, [rdi+8]
mov rdx, [rdi]
mov rax, r8
sub rax, rdx
mov rsi, rax
sar rsi, 2
cmp rdx, r8
jz short loc_1269
cmp rax, 4
jbe short loc_124F
mov ecx, 0
mov eax, 1
jmp short loc_1241
loc_1238:
add rax, 1
cmp rax, rsi
jnb s... | bool func0(long long a1)
{
long long v1; // r8
_DWORD *v2; // rdx
int v3; // ecx
unsigned long long v4; // rax
v1 = *(_QWORD *)(a1 + 8);
v2 = *(_DWORD **)a1;
if ( *(_QWORD *)a1 == v1 )
return 1;
if ( *(_QWORD *)(a1 + 8) - *(_QWORD *)a1 <= 4uLL )
{
v3 = 0;
}
else
{
v3 = 0;
v4 = ... | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RAX,R8
SUB RAX,RDX
MOV RSI,RAX
SAR RSI,0x2
CMP RDX,R8
JZ 0x00101269
CMP RAX,0x4
JBE 0x0010124f
MOV ECX,0x0
MOV EAX,0x1
JMP 0x00101241
LAB_00101238:
ADD RAX,0x1
CMP RAX,RSI
JNC 0x00101254
LAB_00101241:
MOV EDI,dword ptr [RDX + RAX*0x4 + -0x4]
CMP dw... | /* func0(std::vector<int, std::allocator<int> >) */
bool func0(vector param_1)
{
int *piVar1;
int *piVar2;
ulong uVar3;
int iVar4;
int4 in_register_0000003c;
piVar1 = (int *)((int8 *)CONCAT44(in_register_0000003c,param_1))[1];
piVar2 = *(int **)CONCAT44(in_register_0000003c,param_1);
if (piVar2 != ... |
438 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> arr){
int num=0;
if (arr.size()==0) return true;
for (int i=1;i<arr.size();i++)
if (arr[i]<arr[i-1]) num+=1;
if (arr[arr.size()-1]>arr[0]) num+=1;
if (num<2) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({3, 4, 5, 1, 2})==true);
assert (func0({3, 5, 10, 1, 2})==true);
assert (func0({4, 3, 1, 2})==false);
assert (func0({3, 5, 4, 1, 2})==false);
assert (func0({})==true);
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rdi
mov %rdi,%rdx
sub %r8,%rdx
mov %rdx,%rax
sar $0x2,%rax
cmp %rdi,%r8
je 14e0 <_Z5func0St6vectorIiSaIiEE+0x60>
cmp $0x1,%rax
jbe 14f0 <_Z5func0St6vectorIiSaIiEE+0x70>
lea -0x4(%r8,%rdx,1),%rsi
mov ... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov r9, [rdi+8]
mov rdi, [rdi]
mov rax, r9
sub rax, rdi
mov r8, rax
sar r8, 2
cmp rdi, r9
jz short loc_1460
cmp rax, 4
jbe short loc_1470
mov edx, [rdi]
mov eax, 1
xor ecx, ecx
nop dword ptr [rax+00h]
loc_1430:
mov esi, edx
... | bool func0(char **a1)
{
char *v1; // r9
char *v2; // rdi
int v3; // edx
unsigned long long v4; // rax
int v5; // ecx
int v6; // esi
v1 = a1[1];
v2 = *a1;
if ( v2 == v1 )
return 1;
if ( (unsigned long long)(v1 - v2) <= 4 )
{
v5 = 0;
}
else
{
v3 = *(_DWORD *)v2;
v4 = 1LL;
... | func0:
ENDBR64
MOV R9,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RDI]
MOV RAX,R9
SUB RAX,RDI
MOV R8,RAX
SAR R8,0x2
CMP RDI,R9
JZ 0x00101460
CMP RAX,0x4
JBE 0x00101470
MOV EDX,dword ptr [RDI]
MOV EAX,0x1
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_00101430:
MOV ESI,EDX
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,ESI
SETL SIL
ADD RA... | /* func0(std::vector<int, std::allocator<int> >) */
bool func0(vector param_1)
{
int *piVar1;
int *piVar2;
int *piVar3;
ulong uVar4;
int iVar5;
int iVar6;
int4 in_register_0000003c;
piVar2 = (int *)((int8 *)CONCAT44(in_register_0000003c,param_1))[1];
piVar3 = *(int **)CONCAT44(in_register_0000003... |
439 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> arr){
int num=0;
if (arr.size()==0) return true;
for (int i=1;i<arr.size();i++)
if (arr[i]<arr[i-1]) num+=1;
if (arr[arr.size()-1]>arr[0]) num+=1;
if (num<2) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({3, 4, 5, 1, 2})==true);
assert (func0({3, 5, 10, 1, 2})==true);
assert (func0({4, 3, 1, 2})==false);
assert (func0({3, 5, 4, 1, 2})==false);
assert (func0({})==true);
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rdi
mov %rdi,%rsi
sub %rdx,%rsi
sar $0x2,%rsi
cmp %rdi,%rdx
je 1538 <_Z5func0St6vectorIiSaIiEE+0x108>
cmp $0x1,%rsi
jbe 1540 <_Z5func0St6vectorIiSaIiEE+0x110>
lea -0x2(%rsi),%rax
lea -0x1(%rsi),%r8
cm... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rsi, [rdi+8]
mov rdx, [rdi]
mov rax, rsi
sub rax, rdx
mov rdi, rax
sar rdi, 2
cmp rdx, rsi
jz loc_1518
cmp rax, 4
jbe loc_1520
mov eax, 2
cmp rdi, rax
cmovnb rax, rdi
lea r8, [rax-1]
sub rax, 2
cmp rax, 2
jbe loc_15... | char func0(long long a1)
{
_DWORD *v1; // rsi
_DWORD *v2; // rdx
long long v3; // rax
unsigned long long v4; // rdi
long long v5; // rax
unsigned long long v6; // r8
_DWORD *v7; // rax
__m128i v8; // xmm1
__m128i v9; // xmm0
__m128i v10; // xmm2
__m128i v11; // xmm1
unsigned long long v12; // r... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RAX,RSI
SUB RAX,RDX
MOV RDI,RAX
SAR RDI,0x2
CMP RDX,RSI
JZ 0x00101518
CMP RAX,0x4
JBE 0x00101520
MOV EAX,0x2
CMP RDI,RAX
CMOVNC RAX,RDI
LEA R8,[RAX + -0x1]
SUB RAX,0x2
CMP RAX,0x2
JBE 0x00101524
MOV RCX,R8
MOV RAX,RDX
PXOR XMM1,XMM1
SHR RCX,0x2
SH... | /* func0(std::vector<int, std::allocator<int> >) */
int4 func0(vector param_1)
{
ulong uVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int *piVar9;
int *piVar10;
ulong uVar11;
int *piVar12;
int iVar13;
int4 in_register_0000003c;
ulong uVa... |
440 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<int> lst1,vector<int> lst2){
int num=0;
for (int i=0;i<lst1.size();i++)
if (lst1[i]%2==0) num+=1;
for (int i=0;i<lst2.size();i++)
if (lst2[i]%2==0) num+=1;
if (num>=lst1.size()) return "YES";
return "NO";
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 3, 4}, {1, 2, 3, 4}) == "YES");
assert (func0({1, 2, 3, 4}, {1, 5, 3, 4}) == "NO");
assert (func0({1, 2, 3, 4}, {2, 1, 4, 3}) == "YES" );
assert (func0({5, 7, 3}, {2, 6, 4}) == "YES");
assert (func0({5, 7, 3}, {2, 6, 3}) == "NO" );
... | O0 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x24(%rb... | _Z5func0B5cxx11St6vectorIiSaIiEES1_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov [rbp+var_58], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_34], 0
mov [rbp+var_30], 0
jmp short loc_248C
loc_2... | long long func0[abi:cxx11](long long a1, long long a2, long long a3)
{
char v5; // [rsp+2Bh] [rbp-35h] BYREF
int v6; // [rsp+2Ch] [rbp-34h]
int i; // [rsp+30h] [rbp-30h]
int j; // [rsp+34h] [rbp-2Ch]
char *v9; // [rsp+38h] [rbp-28h]
char *v10; // [rsp+40h] [rbp-20h]
unsigned long long v11; // [rsp+48h] [... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV qword ptr [RBP + -0x58],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x34],0x0
MOV dword ptr [RBP + -0x30],0x0
JMP 0x0010248c
LAB_... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >)
*/
string * func0_abi_cxx11_(vector param_1,vector param_2)
{
ulong uVar1;
uint *puVar2;
vector<int,std::allocator<int>> *in_RDX;
ulong uVar3;
int4 in_register_00000034;
vector<int,std::allocator<int>> ... |
441 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<int> lst1,vector<int> lst2){
int num=0;
for (int i=0;i<lst1.size();i++)
if (lst1[i]%2==0) num+=1;
for (int i=0;i<lst2.size();i++)
if (lst2[i]%2==0) num+=1;
if (num>=lst1.size()) return "YES";
return "NO";
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 3, 4}, {1, 2, 3, 4}) == "YES");
assert (func0({1, 2, 3, 4}, {1, 5, 3, 4}) == "NO");
assert (func0({1, 2, 3, 4}, {2, 1, 4, 3}) == "YES" );
assert (func0({5, 7, 3}, {2, 6, 4}) == "YES");
assert (func0({5, 7, 3}, {2, 6, 3}) == "NO" );
... | O1 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %rbx
mov %rdi,%rbx
mov (%rsi),%rax
mov 0x8(%rsi),%rdi
sub %rax,%rdi
mov %rdi,%r8
sar $0x2,%r8
je 12f4 <_Z5func0B5cxx11St6vectorIiSaIiEES1_+0x8b>
mov %rax,%rcx
add %rax,%rdi
mov ... | _Z5func0B5cxx11St6vectorIiSaIiEES1_:
endbr64
push rbx
mov rbx, rdi
mov rax, [rsi+8]
mov r8, [rsi]
mov rdi, rax
sub rdi, r8
sar rdi, 2
cmp rax, r8
jz short loc_131D
mov ecx, 0
mov eax, 0
loc_12B1:
mov esi, [r8+rcx*4]
and esi, 1
cmp esi, 1
adc eax, 0
add rcx... | _QWORD * func0[abi:cxx11](_QWORD *a1, _QWORD *a2, long long *a3)
{
unsigned long long v4; // rdi
unsigned long long v5; // rcx
int v6; // eax
long long v7; // rsi
unsigned long long v8; // r8
unsigned long long v9; // rdx
v4 = (long long)(a2[1] - *a2) >> 2;
if ( a2[1] == *a2 )
{
v6 = 0;
}
els... | func0[abi:cxx11]:
ENDBR64
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x8]
MOV R8,qword ptr [RSI]
MOV RDI,RAX
SUB RDI,R8
SAR RDI,0x2
CMP RAX,R8
JZ 0x0010131d
MOV ECX,0x0
MOV EAX,0x0
LAB_001012b1:
MOV ESI,dword ptr [R8 + RCX*0x4]
AND ESI,0x1
CMP ESI,0x1
ADC EAX,0x0
ADD RCX,0x1
CMP RCX,RDI
JC 0x001012b1
LAB_001012c7:
M... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >)
*/
long * func0_abi_cxx11_(vector param_1,vector param_2)
{
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
long *in_RDX;
int4 in_register_00000034;
int4 in_register_0000003c;
long *plVar5;
ulong ... |
442 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<int> lst1,vector<int> lst2){
int num=0;
for (int i=0;i<lst1.size();i++)
if (lst1[i]%2==0) num+=1;
for (int i=0;i<lst2.size();i++)
if (lst2[i]%2==0) num+=1;
if (num>=lst1.size()) return "YES";
return "NO";
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 3, 4}, {1, 2, 3, 4}) == "YES");
assert (func0({1, 2, 3, 4}, {1, 5, 3, 4}) == "NO");
assert (func0({1, 2, 3, 4}, {2, 1, 4, 3}) == "YES" );
assert (func0({5, 7, 3}, {2, 6, 4}) == "YES");
assert (func0({5, 7, 3}, {2, 6, 3}) == "NO" );
... | O2 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r12
mov (%rsi),%rcx
mov %rdi,%r12
mov %rdx,%rax
mov 0x8(%rsi),%r9
sub %rcx,%r9
mov %r9,%rdi
sar $0x2,%rdi
je 1ac0 <_Z5func0B5cxx11St6vectorIiSaIiEES1_+0xa0>
add %rcx,%r9
xor %... | _Z5func0B5cxx11St6vectorIiSaIiEES1_:
endbr64
push rbx
mov rax, [rsi+8]
mov rbx, rdi
mov r8, [rsi]
mov rdi, rax
sub rdi, r8
sar rdi, 2
cmp rax, r8
jz loc_1A40
xor ecx, ecx
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_19B0:
mov esi, [r8+rcx*4]
and esi, 1
cmp ... | _QWORD * func0[abi:cxx11](_QWORD *a1, _QWORD *a2, long long *a3)
{
unsigned long long v4; // rdi
unsigned long long v5; // rcx
int v6; // eax
long long v7; // rsi
unsigned long long v8; // r8
unsigned long long v9; // rdx
v4 = (long long)(a2[1] - *a2) >> 2;
if ( a2[1] == *a2 )
{
v6 = 0;
}
els... | func0[abi:cxx11]:
ENDBR64
PUSH RBX
MOV RAX,qword ptr [RSI + 0x8]
MOV RBX,RDI
MOV R8,qword ptr [RSI]
MOV RDI,RAX
SUB RDI,R8
SAR RDI,0x2
CMP RAX,R8
JZ 0x00101a40
XOR ECX,ECX
XOR EAX,EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001019b0:
MOV ESI,dword ptr [R8 + RCX*0x4]
AND ESI,0x1
CMP ESI,0x1
ADC EAX,0x0
ADD RCX,0x1
CMP RCX,R... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >)
*/
long * func0_abi_cxx11_(vector param_1,vector param_2)
{
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
long *in_RDX;
int4 in_register_00000034;
int4 in_register_0000003c;
long *plVar5;
ulong ... |
443 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<int> lst1,vector<int> lst2){
int num=0;
for (int i=0;i<lst1.size();i++)
if (lst1[i]%2==0) num+=1;
for (int i=0;i<lst2.size();i++)
if (lst2[i]%2==0) num+=1;
if (num>=lst1.size()) return "YES";
return "NO";
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 3, 4}, {1, 2, 3, 4}) == "YES");
assert (func0({1, 2, 3, 4}, {1, 5, 3, 4}) == "NO");
assert (func0({1, 2, 3, 4}, {2, 1, 4, 3}) == "YES" );
assert (func0({5, 7, 3}, {2, 6, 4}) == "YES");
assert (func0({5, 7, 3}, {2, 6, 3}) == "NO" );
... | O3 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
mov (%rsi),%r9
mov 0x8(%rsi),%rsi
mov %rdi,%rax
sub %r9,%rsi
sar $0x2,%rsi
je 1ae0 <_Z5func0B5cxx11St6vectorIiSaIiEES1_+0x210>
lea -0x1(%rsi),%rcx
cmp $0x3,%rcx
jbe 1b19 <_Z5func0B5cxx11... | _Z5func0B5cxx11St6vectorIiSaIiEES1_:
endbr64
mov r9, rdx
mov rdx, [rsi+8]
mov rsi, [rsi]
mov rcx, rdi
mov rax, rdx
sub rax, rsi
mov r8, rax
sar r8, 2
cmp rsi, rdx
jz loc_1A90
test rax, rax
mov edi, 1
cmovnz rdi, r8
cmp rax, 0Ch
jbe loc_1A97
mov rdx, rdi
pxor ... | long long func0[abi:cxx11](long long a1, const __m128i **a2, const __m128i **a3)
{
const __m128i *v4; // rdx
const __m128i *v5; // rsi
unsigned long long v7; // rax
unsigned long long v8; // r8
unsigned long long v9; // rdi
__m128i v10; // xmm1
__m128i si128; // xmm2
const __m128i *v12; // rax
__m128... | func0[abi:cxx11]:
ENDBR64
MOV R9,RDX
MOV RDX,qword ptr [RSI + 0x8]
MOV RSI,qword ptr [RSI]
MOV RCX,RDI
MOV RAX,RDX
SUB RAX,RSI
MOV R8,RAX
SAR R8,0x2
CMP RSI,RDX
JZ 0x00101a90
TEST RAX,RAX
MOV EDI,0x1
CMOVNZ RDI,R8
CMP RAX,0xc
JBE 0x00101a97
MOV RDX,RDI
PXOR XMM1,XMM1
MOVDQA XMM2,xmmword ptr [0x001021c0]
MOV RAX,RSI
SHR... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >)
*/
long * func0_abi_cxx11_(vector param_1,vector param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
ulong... |
444 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| map<char,int> func0(string test){
map<char,int> count={},out={};
map <char,int>::iterator it;
int max=0;
for (int i=0;i<test.length();i++)
if (test[i]!=' ')
{
count[test[i]]+=1;
if (count[test[i]]>max) max=count[test[i]];
}
for (it=count.begin();it!=co... | #undef NDEBUG
#include<assert.h>
bool issame(map<char,int> a,map<char,int> b){
if (a.size()!=b.size()) return false;
map <char,int>::iterator it;
for (it=a.begin();it!=a.end();it++)
{
char w1=it->first;
int w2=it->second;
if (b.find(w1)==b.end()) return false;
if (b[w1]!... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %rsi,-0x80(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movq $0x0,-0x50(%rbp)
movq $0x0,-0x48(%rbp)
movq ... | _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
pxor xmm0, xmm0
movaps [rbp+var_50], xmm0
movaps [rbp+var_40], xmm0
mova... | _OWORD * func0(_OWORD *a1, long long a2)
{
long long v2; // rax
_DWORD *v3; // rax
long long v4; // rax
long long v5; // rax
int v7; // [rsp+14h] [rbp-6Ch]
int i; // [rsp+18h] [rbp-68h]
int v9; // [rsp+1Ch] [rbp-64h]
long long j; // [rsp+20h] [rbp-60h] BYREF
long long v11; // [rsp+28h] [rbp-58h] BYREF... | 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
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x50],XMM0
MOVAPS xmmword ptr [RBP + -0x40],XMM0
MOVAPS xmmword ptr [RBP + -0x30],XM... | /* func0(std::string) */
map<char,int,std::less<char>,std::allocator<std::pair<char_const,int>>> *
func0(map<char,int,std::less<char>,std::allocator<std::pair<char_const,int>>> *param_1,ulong param_2
)
{
int iVar1;
char cVar2;
char *pcVar3;
ulong uVar4;
int *puVar5;
long lVar6;
int *piVar7;
long ... |
445 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| map<char,int> func0(string test){
map<char,int> count={},out={};
map <char,int>::iterator it;
int max=0;
for (int i=0;i<test.length();i++)
if (test[i]!=' ')
{
count[test[i]]+=1;
if (count[test[i]]>max) max=count[test[i]];
}
for (it=count.begin();it!=co... | #undef NDEBUG
#include<assert.h>
bool issame(map<char,int> a,map<char,int> b){
if (a.size()!=b.size()) return false;
map <char,int>::iterator it;
for (it=a.begin();it!=a.end();it++)
{
char w1=it->first;
int w2=it->second;
if (b.find(w1)==b.end()) return false;
if (b[w1]!... | 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 $0x68,%rsp
mov %rdi,%r14
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
movl $0x0,0x28(%rsp)
movq $0x0,0x30(%rsp)
lea 0x2... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov r14, rdi
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
mov [rsp+0B8h+var_70], 0
mov [rsp+0B8h+var_68], 0
lea rax, [rsp+... | long long func0(long long a1, _QWORD *a2)
{
unsigned long long v2; // rbx
int v3; // r15d
_BYTE *v4; // r12
long long v5; // rax
char *v6; // r12
char v7; // r13
long long v8; // rax
_BYTE *v9; // r12
long long v10; // rax
long long i; // rbx
char v12; // r12
int v13; // ebp
long long v14; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x0
LEA RAX,[RSP + 0x48]
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RAX
MOV qword ... | /* func0(std::string) */
_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
* func0(_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
... |
446 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| map<char,int> func0(string test){
map<char,int> count={},out={};
map <char,int>::iterator it;
int max=0;
for (int i=0;i<test.length();i++)
if (test[i]!=' ')
{
count[test[i]]+=1;
if (count[test[i]]>max) max=count[test[i]];
}
for (it=count.begin();it!=co... | #undef NDEBUG
#include<assert.h>
bool issame(map<char,int> a,map<char,int> b){
if (a.size()!=b.size()) return false;
map <char,int>::iterator it;
for (it=a.begin();it!=a.end();it++)
{
char w1=it->first;
int w2=it->second;
if (b.find(w1)==b.end()) return false;
if (b[w1]!... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x38(%rsp),%rbp
lea 0x8(%rd... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rax, [rdi+8]
movups xmmword ptr [rdi+10h], xmm0
... | long long func0(long long a1, long long *a2)
{
bool v3; // zf
unsigned long long v5; // rbx
int v6; // r13d
char *v7; // r8
char v8; // cl
char *v9; // rdx
char *v10; // rax
char *v11; // r9
long long v12; // rsi
long long v13; // rdi
char v14; // al
char *v15; // rsi
long long v16; // rcx
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x8]
MOVUPS xmmword ptr [RDI + 0x10],XMM0
LEA RBP,[RSP + 0x38]
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI],... | /* func0(std::string) */
int (*) [16] func0(int (*param_1) [16],long *param_2)
{
piecewise_construct_t *ppVar1;
int *piVar2;
byte bVar3;
_Rb_tree_node_base _Var4;
char cVar5;
int iVar6;
long lVar7;
piecewise_construct_t *ppVar8;
_Rb_tree_iterator _Var9;
tuple *ptVar10;
int4 extraout_var;
piece... |
447 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| map<char,int> func0(string test){
map<char,int> count={},out={};
map <char,int>::iterator it;
int max=0;
for (int i=0;i<test.length();i++)
if (test[i]!=' ')
{
count[test[i]]+=1;
if (count[test[i]]>max) max=count[test[i]];
}
for (it=count.begin();it!=co... | #undef NDEBUG
#include<assert.h>
bool issame(map<char,int> a,map<char,int> b){
if (a.size()!=b.size()) return false;
map <char,int>::iterator it;
for (it=a.begin();it!=a.end();it++)
{
char w1=it->first;
int w2=it->second;
if (b.find(w1)==b.end()) return false;
if (b[w1]!... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
mov %rsi,%r14
lea 0x8(%rdi),%rsi
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rdi,0x20(%rsp)
lea 0x38(%rsp),%rbp
mov %fs:0x28,%rax
mov %r... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rax, [rdi+8]
movups xmmword ptr [rdi+10h], xmm0
... | long long func0(long long a1, long long *a2, long long a3, long long a4, long long a5, int *a6)
{
unsigned long long v7; // rax
unsigned long long v9; // rbx
int v10; // r13d
char *v11; // r8
char v12; // di
int *v13; // rsi
int *v14; // rax
long long v15; // rdx
long long i; // rbx
char v17; // al... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x8]
MOVUPS xmmword ptr [RDI + 0x10],XMM0
LEA RBP,[RSP + 0x38]
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI],... | /* func0(std::string) */
int (*) [16] func0(int (*param_1) [16],long *param_2,int8 param_3,tuple *param_4)
{
tuple *ptVar1;
int *piVar2;
piecewise_construct_t pVar3;
tuple tVar4;
byte bVar5;
_Rb_tree_node_base _Var6;
int iVar7;
long lVar8;
piecewise_construct_t *ppVar9;
piecewise_construct_t *ppVa... |
448 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string s,string c){
string n="";
for (int i=0;i<s.length();i++)
if (find(c.begin(),c.end(),s[i])==c.end())
n=n+s[i];
if (n.length()==0) return {n,"True"};
string w(n.rbegin(),n.rend());
if (w==n) return {n,"True"};
return {n,"False"};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("abcde","ae") , {"bcd","False"}));
assert (issame(func0("a... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x188,%rsp
mov %rdi,-0x188(%rbp)
mov %rs... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 138h
mov [rbp+var_128], rdi
mov [rbp+var_130], rsi
mov [rbp+var_138], rdx
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, ... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // r12
long long v4; // rbx
long long v5; // rax
char *v6; // rax
_BYTE *m; // rbx
_BYTE *j; // rbx
_BYTE *k; // rbx
char v12; // [rsp+4Bh] [rbp-115h] BYREF
int i; // [rsp+4Ch] [rbp-114h]
long long v14; // [rsp+50h] [rbp-110h... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x138
MOV qword ptr [RBP + -0x128],RDI
MOV qword ptr [RBP + -0x130],RSI
MOV qword ptr [RBP + -0x138],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x108]
MOV qword ptr [RBP + -0x100],RA... | /* func0(std::string, std::string) */
int8 func0(int8 param_1,ulong param_2)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
char *pcVar4;
int4 extraout_var;
ulong uVar5;
long lVar6;
ulong uVar7;
string *psVar8;
initializer_list iVar9;
long in_FS_OFFSET;
allocator local_11d;
... |
449 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string s,string c){
string n="";
for (int i=0;i<s.length();i++)
if (find(c.begin(),c.end(),s[i])==c.end())
n=n+s[i];
if (n.length()==0) return {n,"True"};
string w(n.rbegin(),n.rend());
if (w==n) return {n,"True"};
return {n,"False"};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("abcde","ae") , {"bcd","False"}));
assert (issame(func0("a... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,%r13
mov %rsi,%rbp
mov %rdx,%r12
mo... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov r13, rdi
mov rbp, rsi
mov r12, rdx
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
xor eax, eax
lea rdi, [rsp+0E8h+s2]
lea rax... | _QWORD * func0(_QWORD *a1, _QWORD *a2, long long a3)
{
long long v6; // rbx
_BYTE *v7; // rax
long long v8; // rdx
_BYTE *v9; // rdi
_BYTE *v10; // rsi
long long v11; // rcx
_BYTE *v12; // rcx
long long v13; // rax
unsigned long long v14; // r14
char *v15; // rax
long long v16; // rcx
unsigned l... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV R13,RDI
MOV RBP,RSI
MOV R12,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x20]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LEA RSI,[0x10329c]
MOV RDX,RSI
LAB_00101430:
CALL 0x001027... | /* func0(std::string, std::string) */
int8 * func0(int8 *param_1,long *param_2,int8 *param_3)
{
char *pcVar1;
char *pcVar2;
char cVar3;
int iVar4;
ulong *puVar5;
ulong *puVar6;
uint uVar7;
int iVar8;
char *pcVar9;
int8 uVar10;
string *psVar11;
size_t *psVar12;
long lVar13;
uint uVar14;
u... |
450 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string s,string c){
string n="";
for (int i=0;i<s.length();i++)
if (find(c.begin(),c.end(),s[i])==c.end())
n=n+s[i];
if (n.length()==0) return {n,"True"};
string w(n.rbegin(),n.rend());
if (w==n) return {n,"True"};
return {n,"False"};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("abcde","ae") , {"bcd","False"}));
assert (issame(func0("a... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0xc8,%rsp
mov %fs:0x28,%rax
mov %rax,0xb... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0C8h
mov [rsp+0F8h+var_E0], rdi
mov rax, fs:28h
mov [rsp+0F8h+var_40], rax
xor eax, eax
lea rax, [rsp+0F8h+var_C0+8]
cmp qword ptr [rsi+8]... | long long func0(long long a1, _QWORD *a2, long long a3, _BYTE *a4)
{
bool v4; // zf
unsigned long long v7; // rbx
size_t v8; // r13
_BYTE *v9; // rax
long long v10; // rsi
_BYTE *v11; // rdi
long long v12; // rsi
long long v13; // rdx
size_t *v14; // rbp
_QWORD *v15; // rax
char *v16; // rbp
_Q... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
CMP qword ptr [RSI + 0x8],0x0
MOV qword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x... | /* func0(std::string, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2,int8 *param_3)
{
char *pcVar1;
char *pcVar2;
char cVar3;
int iVar4;
int iVar5;
ulong *puVar6;
int iVar7;
char *pcVar8;
ulong *puVar9;
... |
451 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string s,string c){
string n="";
for (int i=0;i<s.length();i++)
if (find(c.begin(),c.end(),s[i])==c.end())
n=n+s[i];
if (n.length()==0) return {n,"True"};
string w(n.rbegin(),n.rend());
if (w==n) return {n,"True"};
return {n,"False"};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("abcde","ae") , {"bcd","False"}));
assert (issame(func0("a... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xc8,%rsp
mov 0x8(%rsi),%r8
mov %fs:0x28... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
mov r15, rdi
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0D8h
mov r8, [rsi+8]
mov rax, fs:28h
mov [rsp+108h+var_40], rax
xor eax, eax
lea rax, [rsp+108h+var_C0+8]
mov byte ptr [r... | long long func0(long long a1, _QWORD *a2, long long a3)
{
unsigned long long v4; // r8
unsigned long long v7; // rbx
size_t v8; // r12
_BYTE *v9; // rax
long long v10; // rsi
_BYTE *v11; // rdi
_BYTE *v12; // rcx
long long v13; // rsi
long long v14; // rdx
char *v15; // rbp
double v16; // rdx
_... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xd8
MOV R8,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x50]
MOV byte ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr ... | /* func0(std::string, std::string) */
int (*) [16] func0(int (*param_1) [16],long *param_2,int8 *param_3)
{
char *pcVar1;
char *pcVar2;
char cVar3;
void *pvVar4;
int4 *__src;
int iVar5;
char *pcVar6;
ulong *puVar7;
ulong *puVar8;
ulong *puVar9;
int8 uVar10;
long lVar11;
ulong uVar12;
ulong... |
452 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<string> lst){
vector<string> out={};
for (int i=0;i<lst.size();i++)
{
int sum=0;
for (int j=0;j<lst[i].length();j++)
if (lst[i][j]>=48 and lst[i][j]<=57 and lst[i][j]%2==1)
sum+=1;
string s="the number of odd... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({"1234567"}) , {"the number of odd elements 4n the str4ng 4 of... | O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xc8,%rsp
mov %rdi,-0xc8(%rbp)
mov %rsi,-0xd0(%rbp)
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0D8h
mov [rbp+var_D8], rdi
mov [rbp+var_E0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_D8]
pxor xmm0, xmm0
movups xmmwo... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rax
unsigned long long v6; // rbx
long long v7; // rax
char *v8; // rax
unsigned long long v9; // rbx
unsigned long long v10; // rbx
char v12; // [rsp+1Fh] [rbp-C1h] BYREF
int i; // [rsp+20h] [r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xd8
MOV qword ptr [RBP + -0xd8],RDI
MOV qword ptr [RBP + -0xe0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0xd8]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword ptr [RAX + 0x10],XMM0
MOV RAX,qword pt... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<std::string,std::allocator<std::string>> * func0(vector param_1)
{
bool bVar1;
char *pcVar2;
ulong uVar3;
ulong uVar4;
vector<std::string,std::allocator<std::string>> *in_RSI;
int4 in_register_0000003c;
vector<std::string,std::a... |
453 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<string> lst){
vector<string> out={};
for (int i=0;i<lst.size();i++)
{
int sum=0;
for (int j=0;j<lst[i].length();j++)
if (lst[i][j]>=48 and lst[i][j]<=57 and lst[i][j]%2==1)
sum+=1;
string s="the number of odd... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({"1234567"}) , {"the number of odd elements 4n the str4ng 4 of... | O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xb8,%rsp
mov %rdi,%r14
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 198h
mov r15, rdi
mov [rsp+1C8h+var_1B0], rsi
mov rax, fs:28h
mov [rsp+1C8h+var_40], rax
xor eax, eax
pxor xmm0, xmm0
movups... | long long func0(long long a1, long long *a2)
{
long long v3; // rax
int v5; // ebx
char *v6; // rax
unsigned int v7; // r14d
unsigned int v8; // r12d
long long v9; // rbx
unsigned int v10; // eax
unsigned int v11; // ebp
unsigned int v12; // edx
char *v13; // rsi
unsigned int v14; // ecx
int v1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x198
MOV R15,RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x188],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI]
MOV qword ptr [RSP + 0... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<std::string,std::allocator<std::string>> * func0(vector param_1)
{
ulong *puVar1;
long *plVar2;
uint uVar3;
ulong *puVar4;
uint uVar5;
uint uVar6;
uint uVar7;
char *pcVar8;
int8 uVar9;
long lVar10;
int8 *puVar11;
char ... |
454 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<string> lst){
vector<string> out={};
for (int i=0;i<lst.size();i++)
{
int sum=0;
for (int j=0;j<lst[i].length();j++)
if (lst[i][j]>=48 and lst[i][j]<=57 and lst[i][j]%2==1)
sum+=1;
string s="the number of odd... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({"1234567"}) , {"the number of odd elements 4n the str4ng 4 of... | O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xe8,%rsp
mov %rdi,0x10(%rsp)... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1B8h
mov [rsp+1E8h+var_1D0], rdi
mov [rsp+1E8h+var_1B0], rsi
mov rax, fs:28h
mov [rsp+1E8h+var_40], rax
xor ... | long long func0(long long a1, long long *a2)
{
long long v2; // rax
int v3; // ebp
long long v4; // rax
long long v5; // rsi
_BYTE *v6; // rax
_BYTE *v7; // rsi
unsigned int v8; // ebx
unsigned long long v9; // r12
unsigned long long v10; // r14
void *v11; // r15
long long *v12; // rdi
long lon... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1b8
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1a8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<std::string,std::allocator<std::string>> * func0(vector param_1)
{
uint uVar1;
ulong *puVar2;
long *plVar3;
ulong uVar4;
char cVar5;
ulong *puVar... |
455 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<string> lst){
vector<string> out={};
for (int i=0;i<lst.size();i++)
{
int sum=0;
for (int j=0;j<lst[i].length();j++)
if (lst[i][j]>=48 and lst[i][j]<=57 and lst[i][j]%2==1)
sum+=1;
string s="the number of odd... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({"1234567"}) , {"the number of odd elements 4n the str4ng 4 of... | O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xe8,%rsp
mov... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1B8h
mov [rsp+1E8h+var_1C8], rdi
mov [rsp+1E8h+var_1B0], rsi
mov rax, fs:28h
mov [rsp+1E8h+var_40], rax
xor ... | long long func0(long long a1, long long *a2)
{
long long v2; // rax
int v3; // ebp
const __m128i **v4; // rax
const __m128i *v5; // rcx
const __m128i *v6; // rsi
__m128 v7; // xmm1
const __m128i *v8; // rdx
unsigned long long v9; // rax
__m128i v10; // xmm5
__m128i v11; // xmm0
__m128i v12; // xm... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1b8
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1a8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<std::string,std::allocator<std::string>> * func0(vector param_1)
{
uint uVar1;
ulong uVar2;
byte *pbVar3;
ulong *puVar4;
int auVar5 [14];
int auV... |
456 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| long long func0(vector<long long> nums){
long long current,min;
current=nums[0];
min=nums[0];
for (int i=1;i<nums.size();i++)
{
if (current<0) current=current+nums[i];
else current=nums[i];
if (current<min) min=current;
}
return min;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({2, 3, 4, 1, 2, 4}) == 1);
assert (func0({-1, -2, -3}) == -6);
assert (func0({-1, -2, -3, 2, -10}) == -14);
assert (func0({-9999999999999999}) == -9999999999999999);
assert (func0({0, 10, 20, 1000000}) == 0);
assert (func0({-1, -2, -3, ... | O0 | cpp | func0(std::vector<long long, std::allocator<long long> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov -0x38(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 1e5e <_ZNSt6vectorIxSaIxEEixEm>
mov (%rax),%rax
mov %rax,-0x20(%rbp)
mov -0x38(%rbp),%rax
mov ... | _Z5func0St6vectorIxSaIxEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov rax, [rbp+var_38]
mov esi, 0
mov rdi, rax
call _ZNSt6vectorIxSaIxEEixEm; std::vector<long long>::operator[](ulong)
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_... | long long func0(long long a1)
{
int i; // [rsp+1Ch] [rbp-24h]
long long v3; // [rsp+20h] [rbp-20h]
long long v4; // [rsp+28h] [rbp-18h]
v3 = *(_QWORD *)std::vector<long long>::operator[](a1, 0LL);
v4 = *(_QWORD *)std::vector<long long>::operator[](a1, 0LL);
for ( i = 1; i < (unsigned long long)std::vector... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr [RBP + -0x38]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101fbe
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101fbe
MOV RAX,qword ptr [RAX]
MOV qw... | /* func0(std::vector<long long, std::allocator<long long> >) */
long func0(vector param_1)
{
long *plVar1;
ulong uVar2;
int4 in_register_0000003c;
vector<long_long,std::allocator<long_long>> *this;
int4 local_2c;
int8 local_28;
int8 local_20;
this = (vector<long_long,std::allocator<long_long>> *)CO... |
457 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| long long func0(vector<long long> nums){
long long current,min;
current=nums[0];
min=nums[0];
for (int i=1;i<nums.size();i++)
{
if (current<0) current=current+nums[i];
else current=nums[i];
if (current<min) min=current;
}
return min;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({2, 3, 4, 1, 2, 4}) == 1);
assert (func0({-1, -2, -3}) == -6);
assert (func0({-1, -2, -3, 2, -10}) == -14);
assert (func0({-9999999999999999}) == -9999999999999999);
assert (func0({0, 10, 20, 1000000}) == 0);
assert (func0({-1, -2, -3, ... | O1 | cpp | func0(std::vector<long long, std::allocator<long long> >):
endbr64
mov (%rdi),%rcx
mov (%rcx),%rax
mov 0x8(%rdi),%rsi
sub %rcx,%rsi
cmp $0xf,%rsi
jbe 1249 <_Z5func0St6vectorIxSaIxEE+0x40>
lea 0x8(%rcx),%rdx
add %rcx,%rsi
mov %rax,%rcx
jmp 123f <_Z5func0St6vectorIxSaIxEE+0x36>
add (%rdx)... | _Z5func0St6vectorIxSaIxEE:
endbr64
mov rsi, [rdi]
mov rax, [rsi]
mov rdx, [rdi+8]
sub rdx, rsi
mov rdi, rdx
sar rdi, 3
cmp rdx, 8
jbe short loc_1250
mov rcx, rax
mov edx, 1
jmp short loc_1245
loc_1231:
mov rax, [rsi+rdx*8]
loc_1235:
cmp rcx, rax
cmovg rcx, rax
add ... | long long func0(long long a1)
{
long long *v1; // rsi
long long v2; // rax
long long v3; // rdx
unsigned long long v4; // rdi
long long v5; // rcx
unsigned long long v6; // rdx
v1 = *(long long **)a1;
v2 = **(_QWORD **)a1;
v3 = *(_QWORD *)(a1 + 8) - *(_QWORD *)a1;
v4 = v3 >> 3;
if ( (unsigned lo... | func0:
ENDBR64
MOV RSI,qword ptr [RDI]
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RDI + 0x8]
SUB RDX,RSI
MOV RDI,RDX
SAR RDI,0x3
CMP RDX,0x8
JBE 0x00101250
MOV RCX,RAX
MOV EDX,0x1
JMP 0x00101245
LAB_00101231:
MOV RAX,qword ptr [RSI + RDX*0x8]
LAB_00101235:
CMP RCX,RAX
CMOVG RCX,RAX
ADD RDX,0x1
CMP RDX,RDI
JNC 0x0010125... | /* func0(std::vector<long long, std::allocator<long long> >) */
long func0(vector param_1)
{
long *plVar1;
long lVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
int4 in_register_0000003c;
plVar1 = *(long **)CONCAT44(in_register_0000003c,param_1);
lVar2 = *plVar1;
uVar4 = ((long *)CONCAT44(in_register... |
458 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| long long func0(vector<long long> nums){
long long current,min;
current=nums[0];
min=nums[0];
for (int i=1;i<nums.size();i++)
{
if (current<0) current=current+nums[i];
else current=nums[i];
if (current<min) min=current;
}
return min;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({2, 3, 4, 1, 2, 4}) == 1);
assert (func0({-1, -2, -3}) == -6);
assert (func0({-1, -2, -3, 2, -10}) == -14);
assert (func0({-9999999999999999}) == -9999999999999999);
assert (func0({0, 10, 20, 1000000}) == 0);
assert (func0({-1, -2, -3, ... | O2 | cpp | func0(std::vector<long long, std::allocator<long long> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdi
sub %rcx,%rdi
mov (%rcx),%rax
cmp $0xf,%rdi
jbe 1b60 <_Z5func0St6vectorIxSaIxEE+0x50>
lea 0x8(%rcx),%rdx
add %rcx,%rdi
mov %rax,%r8
nopl 0x0(%rax)
mov (%rdx),%rcx
test %rax,%rax
lea ... | _Z5func0St6vectorIxSaIxEE:
endbr64
mov r8, [rdi]
mov rdx, [rdi+8]
mov rax, [r8]
sub rdx, r8
mov r9, rdx
sar r9, 3
mov rcx, rax
cmp rdx, 8
jbe short loc_1782
mov edx, 1
nop word ptr [rax+rax+00000000h]
loc_1760:
mov rsi, [r8+rdx*8]
test rax, rax
lea rdi, [rax+rsi]
m... | long long func0(long long a1)
{
long long *v1; // r8
long long v2; // rax
unsigned long long v3; // r9
long long v4; // rcx
unsigned long long v5; // rdx
bool v6; // sf
long long v7; // rdi
v1 = *(long long **)a1;
v2 = **(_QWORD **)a1;
v3 = (long long)(*(_QWORD *)(a1 + 8) - *(_QWORD *)a1) >> 3;
... | func0:
ENDBR64
MOV R8,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [R8]
SUB RDX,R8
MOV R9,RDX
SAR R9,0x3
MOV RCX,RAX
CMP RDX,0x8
JBE 0x00101782
MOV EDX,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101760:
MOV RSI,qword ptr [R8 + RDX*0x8]
TEST RAX,RAX
LEA RDI,[RAX + RSI*0x1]
MOV RAX,RSI
CMOVS RAX,RDI
CMP... | /* func0(std::vector<long long, std::allocator<long long> >) */
long func0(vector param_1)
{
long lVar1;
long *plVar2;
long lVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
int4 in_register_0000003c;
bool bVar7;
plVar2 = *(long **)CONCAT44(in_register_0000003c,param_1);
lVar3 = *plVar2;
uVar5 = (... |
459 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| long long func0(vector<long long> nums){
long long current,min;
current=nums[0];
min=nums[0];
for (int i=1;i<nums.size();i++)
{
if (current<0) current=current+nums[i];
else current=nums[i];
if (current<min) min=current;
}
return min;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({2, 3, 4, 1, 2, 4}) == 1);
assert (func0({-1, -2, -3}) == -6);
assert (func0({-1, -2, -3, 2, -10}) == -14);
assert (func0({-9999999999999999}) == -9999999999999999);
assert (func0({0, 10, 20, 1000000}) == 0);
assert (func0({-1, -2, -3, ... | O3 | cpp | func0(std::vector<long long, std::allocator<long long> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdi
sub %rcx,%rdi
mov (%rcx),%rax
cmp $0xf,%rdi
jbe 1b70 <_Z5func0St6vectorIxSaIxEE+0x50>
lea 0x8(%rcx),%rdx
add %rcx,%rdi
mov %rax,%r8
nopl 0x0(%rax)
mov (%rdx),%rcx
test %rax,%rax
lea ... | _Z5func0St6vectorIxSaIxEE:
endbr64
mov r8, [rdi]
mov rdx, [rdi+8]
mov rax, [r8]
sub rdx, r8
mov r9, rdx
sar r9, 3
mov rcx, rax
cmp rdx, 8
jbe short loc_1B32
mov edx, 1
nop word ptr [rax+rax+00000000h]
loc_1B10:
mov rsi, [r8+rdx*8]
test rax, rax
lea rdi, [rax+rsi]
m... | long long func0(long long a1)
{
long long *v1; // r8
long long v2; // rax
unsigned long long v3; // r9
long long v4; // rcx
unsigned long long v5; // rdx
bool v6; // sf
long long v7; // rdi
v1 = *(long long **)a1;
v2 = **(_QWORD **)a1;
v3 = (long long)(*(_QWORD *)(a1 + 8) - *(_QWORD *)a1) >> 3;
... | func0:
ENDBR64
MOV R8,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [R8]
SUB RDX,R8
MOV R9,RDX
SAR R9,0x3
MOV RCX,RAX
CMP RDX,0x8
JBE 0x00101b32
MOV EDX,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101b10:
MOV RSI,qword ptr [R8 + RDX*0x8]
TEST RAX,RAX
LEA RDI,[RAX + RSI*0x1]
MOV RAX,RSI
CMOVS RAX,RDI
CMP... | /* func0(std::vector<long long, std::allocator<long long> >) */
long func0(vector param_1)
{
long lVar1;
long *plVar2;
long lVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
int4 in_register_0000003c;
bool bVar7;
plVar2 = *(long **)CONCAT44(in_register_0000003c,param_1);
lVar3 = *plVar2;
uVar5 = (... |
460 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<vector<int>> grid,int capacity){
int out=0;
for (int i=0;i<grid.size();i++)
{
int sum=0;
for (int j=0;j<grid[i].size();j++)
sum+=grid[i][j];
if (sum>0) out+=(sum-1)/capacity+1;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({{0,0,1,0}, {0,1,0,0}, {1,1,1,1}}, 1) == 6);
assert (func0({{0,0,1,1}, {0,0,0,0}, {1,1,1,1}, {0,1,1,1}}, 2) == 5);
assert (func0({{0,0,0}, {0,0,0}}, 5) == 0);
assert (func0({{1,1,1,1}, {1,1,1,1}}, 2) == 4);
assert (func0({{1,1,1,1}, {1,1,1,... | O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
movslq %ea... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
jmp loc_1358
loc_12D0:
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_1311
loc_12E0:
mov ... | long long func0(long long a1, int a2)
{
long long v2; // rax
long long v3; // rax
unsigned int v5; // [rsp+10h] [rbp-20h]
int i; // [rsp+14h] [rbp-1Ch]
int v7; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
v5 = 0;
for ( i = 0; i < (unsigned long long)std::vector<std::vector<int>>::size(a1); ++i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101358
LAB_001012d0:
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101311
LAB_001012e0:
MOV EAX,dwor... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
int func0(vector param_1,int param_2)
{
int *piVar1;
vector<int,std::allocator<int>> *pvVar2;
ulong uVar3;
int4 in_register_0000003c;
vector<std::vector<int,std::allocator<int>>... |
461 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<vector<int>> grid,int capacity){
int out=0;
for (int i=0;i<grid.size();i++)
{
int sum=0;
for (int j=0;j<grid[i].size();j++)
sum+=grid[i][j];
if (sum>0) out+=(sum-1)/capacity+1;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({{0,0,1,0}, {0,1,0,0}, {1,1,1,1}}, 1) == 6);
assert (func0({{0,0,1,1}, {0,0,0,0}, {1,1,1,1}, {0,1,1,1}}, 2) == 5);
assert (func0({{0,0,0}, {0,0,0}}, 5) == 0);
assert (func0({{1,1,1,1}, {1,1,1,1}}, 2) == 4);
assert (func0({{1,1,1,1}, {1,1,1,... | O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%r8
sub %rax,%r8
mov %r8,%rdx
sar $0x3,%rdx
movabs $0xaaaaaaaaaaaaaaab,%rcx
imul %rcx,%rdx
test %rdx,%rdx
je 1326 <_Z5func0St6vectorIS_I... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push rbp
push rbx
mov rax, [rdi+8]
mov r8, [rdi]
mov r10, rax
sub r10, r8
sar r10, 3
mov rdx, 0AAAAAAAAAAAAAAABh
imul r10, rdx
cmp rax, r8
jz short loc_1333
mov r11d, esi
mov r9d, 0
mov ebx, 0
mov ebp, 0
jmp sho... | long long func0(long long a1, int a2)
{
_QWORD *v2; // r8
unsigned long long v3; // r9
unsigned int v4; // ebx
unsigned long long v5; // rdx
int v6; // ecx
int v7; // eax
v2 = *(_QWORD **)a1;
if ( *(_QWORD *)(a1 + 8) == *(_QWORD *)a1 )
{
return 0;
}
else
{
v3 = 0LL;
v4 = 0;
do
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RAX,qword ptr [RDI + 0x8]
MOV R8,qword ptr [RDI]
MOV R10,RAX
SUB R10,R8
SAR R10,0x3
MOV RDX,-0x5555555555555555
IMUL R10,RDX
CMP RAX,R8
JZ 0x00101333
MOV R11D,ESI
MOV R9D,0x0
MOV EBX,0x0
MOV EBP,0x0
JMP 0x001012f5
LAB_001012e8:
ADD R9,0x1
ADD R8,0x18
CMP R9,R10
JNC 0x00101338
LAB_00... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
int [16] func0(vector param_1,int param_2)
{
long *plVar1;
long lVar2;
int iVar3;
ulong uVar4;
uint uVar5;
int4 in_register_0000003c;
long *plVar6;
ulong uVar7;
long lV... |
462 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<vector<int>> grid,int capacity){
int out=0;
for (int i=0;i<grid.size();i++)
{
int sum=0;
for (int j=0;j<grid[i].size();j++)
sum+=grid[i][j];
if (sum>0) out+=(sum-1)/capacity+1;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({{0,0,1,0}, {0,1,0,0}, {1,1,1,1}}, 1) == 6);
assert (func0({{0,0,1,1}, {0,0,0,0}, {1,1,1,1}, {0,1,1,1}}, 2) == 5);
assert (func0({{0,0,0}, {0,0,0}}, 5) == 0);
assert (func0({{1,1,1,1}, {1,1,1,1}}, 2) == 4);
assert (func0({{1,1,1,1}, {1,1,1,... | O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
movabs $0xaaaaaaaaaaaaaaab,%rdx
mov %rdi,%rax
mov (%rdi),%rdi
mov 0x8(%rax),%r8
sub %rdi,%r8
mov %r8,%rax
sar $0x3,%rax
imul %rdx,%rax
test %rax,%rax
je 1957 <_Z5f... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
mov rdx, 0AAAAAAAAAAAAAAABh
push rbx
mov rax, [rdi+8]
mov rdi, [rdi]
mov r10, rax
sub r10, rdi
sar r10, 3
imul r10, rdx
cmp rax, rdi
jz short loc_1B04
mov r11d, esi
xor r8d, r8d
xor ebx, ebx
nop dword ptr [rax+00000000... | long long func0(long long a1, int a2)
{
_QWORD *v2; // rax
_QWORD *v3; // rdi
unsigned long long v4; // r10
unsigned long long v5; // r8
unsigned int v6; // ebx
unsigned long long v7; // rdx
int v8; // eax
v2 = *(_QWORD **)(a1 + 8);
v3 = *(_QWORD **)a1;
v4 = 0xAAAAAAAAAAAAAAABLL * (v2 - v3);
if ... | func0:
ENDBR64
MOV RDX,-0x5555555555555555
PUSH RBX
MOV RAX,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RDI]
MOV R10,RAX
SUB R10,RDI
SAR R10,0x3
IMUL R10,RDX
CMP RAX,RDI
JZ 0x00101b04
MOV R11D,ESI
XOR R8D,R8D
XOR EBX,EBX
NOP dword ptr [RAX]
LAB_00101ab8:
MOV R9,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
XOR EDX,EDX
XOR... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
int func0(vector param_1,int param_2)
{
long *plVar1;
long lVar2;
int iVar3;
ulong uVar4;
int iVar5;
int4 in_register_0000003c;
long *plVar6;
ulong uVar7;
long lVar8;
... |
463 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<vector<int>> grid,int capacity){
int out=0;
for (int i=0;i<grid.size();i++)
{
int sum=0;
for (int j=0;j<grid[i].size();j++)
sum+=grid[i][j];
if (sum>0) out+=(sum-1)/capacity+1;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({{0,0,1,0}, {0,1,0,0}, {1,1,1,1}}, 1) == 6);
assert (func0({{0,0,1,1}, {0,0,0,0}, {1,1,1,1}, {0,1,1,1}}, 2) == 5);
assert (func0({{0,0,0}, {0,0,0}}, 5) == 0);
assert (func0({{1,1,1,1}, {1,1,1,1}}, 2) == 4);
assert (func0({{1,1,1,1}, {1,1,1,... | O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
movabs $0xaaaaaaaaaaaaaaab,%rdx
mov %rdi,%rax
mov (%rdi),%rdi
mov 0x8(%rax),%r8
sub %rdi,%r8
mov %r8,%rax
sar $0x3,%rax
imul %rdx,%rax
test %rax,%rax
je 1a0d <_Z5f... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
mov rax, [rdi+8]
mov rcx, [rdi]
mov rdx, 0AAAAAAAAAAAAAAABh
mov rdi, rax
sub rdi, rcx
sar rdi, 3
imul rdi, rdx
cmp rax, rcx
jz loc_1C36
push r12
mov r8d, esi
xor r9d, r9d
xor esi, esi
push rbp
mov r10d, 1
push rb... | long long func0(const __m128i ***a1, int a2)
{
const __m128i **v2; // rax
const __m128i **v3; // rcx
unsigned long long v4; // rdi
unsigned int v6; // r9d
unsigned long long v7; // rsi
const __m128i *v8; // r11
long long v9; // rax
unsigned long long v10; // rbp
unsigned long long v11; // rbx
__m12... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RDX,-0x5555555555555555
MOV RDI,RAX
SUB RDI,RCX
SAR RDI,0x3
IMUL RDI,RDX
CMP RAX,RCX
JZ 0x00101c36
PUSH R12
MOV R8D,ESI
XOR R9D,R9D
XOR ESI,ESI
PUSH RBP
MOV R10D,0x1
PUSH RBX
NOP
LAB_00101b50:
MOV RDX,qword ptr [RCX + 0x8]
MOV R11,qword ptr [RCX]
... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
int [16] func0(vector param_1,int param_2)
{
long *plVar1;
int *piVar2;
int iVar3;
int *piVar4;
int *piVar5;
int *piVar6;
ulong uVar7;
int *piVar8;
long *plVar9;
int ... |
464 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> arr){
vector<int> bin={};
int m;
for (int i=0;i<arr.size();i++)
{
int b=0,n=abs(arr[i]);
while (n>0)
{
b+=n%2;n=n/2;
}
bin.push_back(b);
}
for (int i=0;i<arr.size();i++)
for (int j=1;j<arr.size();j++)
if (... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({1,5,2,3,4}) , {1, 2, 4, 3, 5}));
assert (issame(func0({-2,-3,-4... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movq $0x0,-0x30(%rbp)
movq $0x0,-0x28(%rbp)
movq $0x0,-0x20(%rbp)
lea -0x30(%rbp),%rax
... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
pxor xmm0, xmm0
movaps [rbp+var_30], xmm0
movq [rbp+var_20], xmm0
lea rax, [rbp+var_30]
mov rdi, ... | long long func0(long long a1, long long a2)
{
int v2; // eax
unsigned long long v3; // rbx
int v4; // ebx
int v5; // ebx
int v6; // ebx
int v8; // ebx
int v9; // ebx
int v10; // ebx
int v11; // ebx
unsigned long long v12; // rbx
unsigned long long v13; // rbx
int v15; // [rsp+18h] [rbp-48h] BYR... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
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
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x30],XMM0
MOVQ qword ptr [RBP + -0x20],XMM0
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL ... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int iVar1;
int4 uVar2;
bool bVar3;
int4 uVar4;
ulong uVar5;
int *piVar6;
int4 *puVar7;
ulong uVar8;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
long in_FS_OFFSET;... |
465 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> arr){
vector<int> bin={};
int m;
for (int i=0;i<arr.size();i++)
{
int b=0,n=abs(arr[i]);
while (n>0)
{
b+=n%2;n=n/2;
}
bin.push_back(b);
}
for (int i=0;i<arr.size();i++)
for (int j=1;j<arr.size();j++)
if (... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({1,5,2,3,4}) , {1, 2, 4, 3, 5}));
assert (issame(func0({-2,-3,-4... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r12
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
mov (%rsi),%rcx
mov $0x0,%ebx... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r12, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
mov [rsp+58h+var_48], 0
mov [rsp+58h+var_40], 0
mov [rsp+58h+var_38], 0
mov rax, [rsi]
cmp [rsi+8],... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v4; // rax
unsigned long long v5; // rbp
int v6; // edx
int v7; // eax
int v8; // esi
int v9; // edx
char *v10; // rsi
_DWORD *v11; // rbp
unsigned long long v12; // r11
int v13; // r9d
int v14; // esi
unsigned long long v15; // rdi
long lo... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R12,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV RAX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RAX
JZ 0x0010140d
... | /* func0(std::vector<int, std::allocator<int> >) */
long * func0(vector param_1)
{
long lVar1;
int iVar2;
int4 uVar3;
bool bVar4;
int iVar5;
long lVar6;
long lVar7;
int *piVar8;
ulong uVar9;
long *in_RSI;
int4 in_register_0000003c;
long *plVar10;
ulong uVar11;
long in_FS_OFFSET;
int loca... |
466 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> arr){
vector<int> bin={};
int m;
for (int i=0;i<arr.size();i++)
{
int b=0,n=abs(arr[i]);
while (n>0)
{
b+=n%2;n=n/2;
}
bin.push_back(b);
}
for (int i=0;i<arr.size();i++)
for (int j=1;j<arr.size();j++)
if (... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({1,5,2,3,4}) , {1, 2, 4, 3, 5}));
assert (issame(func0({-2,-3,-4... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x38,%rsp
mov (%rsi),%rdx
mov 0x8(%rsi),%r10
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rsp)
movq $0x0,0x18... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 38h
mov r9, [rsi]
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
movaps xmmword ptr [rsp+68h+var_58], xmm0
mov [rsp+68... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
_DWORD *v4; // r9
unsigned long long v5; // r12
char *v6; // rdi
char *i; // rsi
int v8; // edx
int v9; // eax
int v10; // edx
_DWORD *v11; // rsi
_DWORD *v12; // r14
unsigned long long v13; // r10
int *v14; // r13
unsigned long long v15; // r12
int *v1... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x38
MOV R9,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
CMP qword ptr [RSI + 0x8],R9
JZ 0x001... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1)
{
uint uVar1;
int8 uVar2;
uint uVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int iVar7;
int (*in_RSI) [16];
int iVar8;
int4 in_register_0000003c;
int8 *puVar9;
int *piVar10;
ulong uVar11;
ulong uVar12;
ulong... |
467 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> arr){
vector<int> bin={};
int m;
for (int i=0;i<arr.size();i++)
{
int b=0,n=abs(arr[i]);
while (n>0)
{
b+=n%2;n=n/2;
}
bin.push_back(b);
}
for (int i=0;i<arr.size();i++)
for (int j=1;j<arr.size();j++)
if (... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({1,5,2,3,4}) , {1, 2, 4, 3, 5}));
assert (issame(func0({-2,-3,-4... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x30,%rsp
mov (%rsi),%rcx
mov 0x8(%rsi),%r10
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movaps %xmm0,0x10(%rsp)
movq $... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 38h
mov r9, [rsi+8]
mov r8, [rsi]
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
movaps xmmword ptr [rsp+68h+var_58], ... | int ** func0(int **a1, int **a2)
{
int *v4; // r9
int *v5; // r8
unsigned long long v6; // r12
int *v7; // rdi
int *i; // rsi
int v9; // edx
int v10; // eax
unsigned long long v11; // r11
int *v12; // r14
unsigned long long v13; // r13
long long j; // r12
int *v15; // rax
int *v16; // rdx
in... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x38
MOV R9,qword ptr [RSI + 0x8]
MOV R8,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
CMP R9,R... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1)
{
int8 uVar1;
uint uVar2;
int *piVar3;
int *piVar4;
uint uVar5;
int *piVar6;
int iVar7;
int (*in_RSI) [16];
int iVar8;
int4 in_register_0000003c;
int8 *puVar9;
uint *puVar10;
int *piVar11;
int *piVar12;
ulon... |
468 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string s,int n){
string vowels="aeiouAEIOU";
string current="";
vector<string> out={};
int numc=0;
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ')
{
if (numc==n) out.push_back(current);
current="";
numc=0;
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("Mary had a little lamb", 4) , {"little"} ));
assert (is... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0xd0,%rsp
mov %rdi,-0xc8(%rbp)
mov %rsi,-0xd0(%rbp)
mov %edx,-0xd4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0xa8(%... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 0C0h
mov [rbp+var_B8], rdi
mov [rbp+var_C0], rsi
mov [rbp+var_C4], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_98]
mov [rb... | long long func0(long long a1, long long a2, int a3)
{
char *v3; // rax
long long v5; // r12
long long v6; // rbx
long long v7; // rax
int v10; // [rsp+28h] [rbp-A8h]
int i; // [rsp+2Ch] [rbp-A4h]
long long v12; // [rsp+30h] [rbp-A0h] BYREF
_QWORD v13[3]; // [rsp+38h] [rbp-98h] BYREF
_BYTE v14[32]; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0xc0
MOV qword ptr [RBP + -0xb8],RDI
MOV qword ptr [RBP + -0xc0],RSI
MOV dword ptr [RBP + -0xc4],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
NOP
NOP
LEA RDX,[RBP + -0x98]
L... | /* func0(std::string, int) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,string *param_2,int param_3)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
char *pcVar4;
int4 extraout_var;
ulong uVar5;
long in_FS_OFFSET;
i... |
469 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string s,int n){
string vowels="aeiouAEIOU";
string current="";
vector<string> out={};
int numc=0;
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ')
{
if (numc==n) out.push_back(current);
current="";
numc=0;
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("Mary had a little lamb", 4) , {"little"} ));
assert (is... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,%r13
mov %rsi,%rbp
mov %edx,0xc(%rsp)
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0x10(... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0A8h
mov rbx, rdi
mov [rsp+0D8h+var_C0], rdi
mov rbp, rsi
mov [rsp+0D8h+var_C4], edx
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
xor eax,... | long long func0(long long a1, void **a2, int a3)
{
unsigned long long v4; // rbx
_BYTE *v5; // r12
_BYTE *v6; // rax
void *v7; // rcx
unsigned long long v8; // rbx
unsigned int v9; // edx
unsigned long long v10; // rax
unsigned long long v11; // rsi
_BYTE *v12; // rax
char *v13; // rcx
unsigned i... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV RBX,RDI
MOV qword ptr [RSP + 0x18],RDI
MOV RBP,RSI
MOV dword ptr [RSP + 0x14],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x30]
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x30],RAX
LEA RDX,... | /* func0(std::string, int) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,ulong *param_2,int param_3)
{
byte bVar1;
ulong *puVar2;
long *plVar3;
char *pcVar4;
byte *pbVar5;
uint uVar6;
int8 uVar7;
byte *pbVar8;
long lVar9;
uint u... |
470 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string s,int n){
string vowels="aeiouAEIOU";
string current="";
vector<string> out={};
int numc=0;
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ')
{
if (numc==n) out.push_back(current);
current="";
numc=0;
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("Mary had a little lamb", 4) , {"little"} ));
assert (is... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0xb8,%rsp
mov (%rsi),%rsi
mov %edx,0xc(%rsp)
mov 0x8(%rbp),%rdx
lea 0x60(%rsp),%r12
lea 0x... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
sub rsp, 0B8h
mov rbx, [rsi+8]
mov r14, [rsi]
mov [rsp+0E8h+var_D0], rdi
lea r13, [rsp+0E8h+var_68]
lea r12, [rsp+0E8... | long long func0(long long a1, void **a2, int a3)
{
size_t v3; // rbx
double *v4; // r14
double *v5; // rdi
size_t v6; // rdx
double v7; // rcx
long long v8; // rbx
int v9; // r15d
size_t v10; // r14
double *v11; // rdi
size_t v12; // rdx
__m128 v13; // xmm0
double v14; // rdx
char v15; // dl
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
SUB RSP,0xb8
MOV RBX,qword ptr [RSI + 0x8]
MOV R14,qword ptr [RSI]
MOV qword ptr [RSP + 0x18],RDI
LEA R13,[RSP + 0x80]
LEA R12,[RSP + 0x90]
MOV dword ptr [RSP + 0x14],EDX
LEA RSI,[RBX + 0x1]
MOV RAX,qword ptr FS:[0x28]
MOV q... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::string, int) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,ulong *param_2,int param_3)
{
char cVar1;
ulong uVar2;
long *plVar3;
int8 uVar4;
long lVar5;
char *pcVar6;
... |
471 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string s,int n){
string vowels="aeiouAEIOU";
string current="";
vector<string> out={};
int numc=0;
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ')
{
if (numc==n) out.push_back(current);
current="";
numc=0;
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("Mary had a little lamb", 4) , {"little"} ));
assert (is... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0xd8,%rsp
mov (%rsi),%r13
mov 0x8(%rsi),%r12
mov %rdi,0x18(%rsp)
lea 0x90(%rsp),%rbx
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
sub rsp, 0C8h
mov rbx, [rsi+8]
mov [rsp+0F8h+var_D8], rdi
lea r12, [rsp+0F8h+src]
mov [rsp+0F8h+var_DC], edx
mov rax,... | long long func0(long long a1, void **a2, int a3)
{
size_t v3; // rbx
double *v4; // r13
double *v5; // rdi
size_t v6; // rdx
double v7; // rcx
long long v8; // rbx
int v9; // r14d
size_t v10; // r13
void *v11; // r15
double *v12; // rdi
size_t v13; // rdx
__m128 v14; // xmm0
double v15; // rd... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
SUB RSP,0xc8
MOV RBX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x20],RDI
LEA R12,[RSP + 0xa0]
MOV dword ptr [RSP + 0x1c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x60]
MOV qw... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::string, int) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,ulong *param_2,int param_3)
{
char cVar1;
ulong uVar2;
ulong *puVar3;
long *plVar4;
ulong *__dest;
int8 uVar... |
472 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string word){
string out="";
string vowels="AEIOUaeiou";
for (int i=word.length()-2;i>=1;i-=1)
if (find(vowels.begin(),vowels.end(),word[i])!=vowels.end())
if (find(vowels.begin(),vowels.end(),word[i+1])==vowels.end())
if (find(vowels.begin(),vowels.end(),wor... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("yogurt") == "u");
assert (func0("full") == "u");
assert (func0("easy") == "");
assert (func0("eAsy") == "");
assert (func0("ali") == "");
assert (func0("bad") == "a");
assert (func0("most") =="o");
assert (func0("ab") == "");
... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x90,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x68(%rbp),%rax
mov %rax,%rdi
ca... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 90h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_78]
mov [rbp+var_70], rax
nop
nop
lea ... | long long func0(long long a1, long long a2)
{
long long v2; // r12
long long v3; // rbx
long long v4; // rax
long long v5; // r12
long long v6; // rbx
long long v7; // rax
long long v8; // r12
long long v9; // rbx
long long v10; // rax
char *v11; // rax
int i; // [rsp+1Ch] [rbp-84h]
long long v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x90
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x78]
MOV qword ptr [RBP + -0x70],RAX
NOP
NOP
LEA RDX,[RBP + -0x78]
LEA RAX,[RBP + -0x60]
LEA RCX,[0x... | /* func0(std::string) */
string * func0(string *param_1,ulong param_2)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
char *pcVar4;
int4 extraout_var;
int4 extraout_var_00;
int4 extraout_var_01;
long in_FS_OFFSET;
int local_8c;
int8 local_88;
int8 local_80;
int8 *local_78;
i... |
473 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string word){
string out="";
string vowels="AEIOUaeiou";
for (int i=word.length()-2;i>=1;i-=1)
if (find(vowels.begin(),vowels.end(),word[i])!=vowels.end())
if (find(vowels.begin(),vowels.end(),word[i+1])==vowels.end())
if (find(vowels.begin(),vowels.end(),wor... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("yogurt") == "u");
assert (func0("full") == "u");
assert (func0("easy") == "");
assert (func0("eAsy") == "");
assert (func0("ali") == "");
assert (func0("bad") == "a");
assert (func0("most") =="o");
assert (func0("ab") == "");
... | 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 $0x68,%rsp
mov %rdi,%r14
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rdi
lea 0x20(%rsp... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov [rsp+0B8h+var_A8], rdi
mov rbx, rsi
mov [rsp+0B8h+var_B0], rsi
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rdi, [... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v2; // rbp
int v3; // edx
int v4; // eax
int v5; // ebp
long long v6; // r14
void *v7; // r12
char *v8; // rbx
long long v9; // r13
char *v10; // r15
unsigned long long v11; // rbx
void *v12; // rbp
_QWORD *v13; // rdx
void *v14; // rax
i... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RSP + 0x10],RDI
MOV RBX,RSI
MOV qword ptr [RSP + 0x8],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x30]
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x30],RAX
LEA RSI,[0x103169]
MO... | /* func0(std::string) */
long * func0(long *param_1,long *param_2,int8 param_3,int8 param_4)
{
int *puVar1;
long lVar2;
int iVar3;
int iVar4;
__normal_iterator _Var5;
uint uVar6;
long lVar7;
int8 uVar8;
int4 extraout_var;
int4 extraout_var_00;
int4 extraout_var_01;
ulong uVar9;
uint uVar10;
... |
474 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string word){
string out="";
string vowels="AEIOUaeiou";
for (int i=word.length()-2;i>=1;i-=1)
if (find(vowels.begin(),vowels.end(),word[i])!=vowels.end())
if (find(vowels.begin(),vowels.end(),word[i+1])==vowels.end())
if (find(vowels.begin(),vowels.end(),wor... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("yogurt") == "u");
assert (func0("full") == "u");
assert (func0("easy") == "");
assert (func0("eAsy") == "");
assert (func0("ali") == "");
assert (func0("bad") == "a");
assert (func0("most") =="o");
assert (func0("ab") == "");
... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x50,%rsp
mov 0x8(%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rbp
lea 0x30(%rsp),%rbx
... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 68h
mov rdi, [rsi+8]
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
lea r12, [rsp+98h+var_78]
lea rbx, [rsp+98h+var_... | long long func0(long long a1, _QWORD *a2)
{
long long v3; // rdi
long long v4; // r11
long long v5; // r13
int v6; // edi
unsigned __int8 *v7; // r8
long long v8; // rdx
_QWORD *i; // rax
int v10; // r14d
char v11; // cl
_QWORD *j; // rax
long long v14; // rcx
_QWORD *k; // rax
char v16; // [... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x68
MOV RDI,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA R12,[RSP + 0x20]
LEA RBX,[RSP + 0x40]
MOV RAX,0x696561554f494541
MOV qword ptr [RSP + 0x40],RAX
LEA R11D,[RDI + -0x2]
MOV... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
char cVar1;
char cVar2;
long *plVar3;
long *plVar4;
int iVar5;
ulong uVar6;
char *pcVar7;
uint uVar8;
ulong uVar9;
long in_FS_OFFSET;
char local_89;
int *local_88;
int8... |
475 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string word){
string out="";
string vowels="AEIOUaeiou";
for (int i=word.length()-2;i>=1;i-=1)
if (find(vowels.begin(),vowels.end(),word[i])!=vowels.end())
if (find(vowels.begin(),vowels.end(),word[i+1])==vowels.end())
if (find(vowels.begin(),vowels.end(),wor... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("yogurt") == "u");
assert (func0("full") == "u");
assert (func0("easy") == "");
assert (func0("eAsy") == "");
assert (func0("ali") == "");
assert (func0("bad") == "a");
assert (func0("most") =="o");
assert (func0("ab") == "");
... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x50,%rsp
mov 0x8(%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rbp
lea 0x30(%rsp),%rbx
... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 60h
mov rcx, [rsi+8]
mov rax, fs:28h
mov [rsp+78h+var_20], rax
xor eax, eax
lea rbp, [rsp+78h+var_58]
lea r12, [rsp+78h+var_38]
mov rax, 696561554F494541h
m... | long long func0(long long a1, long long *a2)
{
long long v3; // rcx
long long v4; // r9
long long v5; // r8
long long v6; // r10
int v7; // ecx
char *v8; // rsi
int v9; // edi
char v10; // al
char v11; // dl
char v12; // dl
char v14; // [rsp+Fh] [rbp-69h] BYREF
void *v15; // [rsp+10h] [rbp-68h]... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x60
MOV RCX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x20]
LEA R12,[RSP + 0x40]
MOV RAX,0x696561554f494541
MOV qword ptr [RSP + 0x40],RAX
LEA R9D,[RCX + -0x2]
MOV EAX,0x756f
MOV qword ptr [R... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
char cVar1;
char cVar2;
int iVar3;
ulong uVar4;
char *pcVar5;
uint uVar6;
ulong uVar7;
long in_FS_OFFSET;
char local_69;
int *local_68;
int8 local_60;
int local_58;
int7 uStack_57;
long *local_48;
int8 local_40;
long ... |
476 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<string> lst){
string l1=lst[0]+lst[1];
int i,count=0;
bool can=true;
for (i=0;i<l1.length();i++)
{
if (l1[i]=='(') count+=1;
if (l1[i]==')') count-=1;
if (count<0) can=false;
}
if (count!=0) return "No";
if (can==true) retur... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({"()(", ")"}) == "Yes");
assert (func0({")", ")"}) == "No");
assert (func0({"(()(())", "())())"}) == "No");
assert (func0({")())", "(()()("}) == "Yes");
assert (func0({"(())))", "(()())(("}) == "Yes");
assert (func0({"()", "())"}) == "N... | O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %rsi,-0x80(%rbp)
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_A0]
mov esi, 1
mov rdi, rax
c... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
long long v4; // rbx
long long v5; // rax
char v7; // [rsp+16h] [rbp-8Ah] BYREF
char v8; // [rsp+17h] [rbp-89h]
int i; // [rsp+18h] [rbp-88h]
int v10; // [rsp+1Ch] [rbp-84h]
char *v11; // [rsp+20h] [rbp-80h]
cha... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0xa0]
MOV ESI,0x1
MOV RDI,RAX
CALL 0x0010395c
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0xa0]
MOV ESI,0x... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
string * func0(vector param_1)
{
int8 uVar1;
int8 uVar2;
ulong uVar3;
char *pcVar4;
ulong uVar5;
vector<std::string,std::allocator<std::string>> *in_RSI;
int4 in_register_0000003c;
string *this;
long in_FS_OFFSET;
allocator local... |
477 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<string> lst){
string l1=lst[0]+lst[1];
int i,count=0;
bool can=true;
for (i=0;i<l1.length();i++)
{
if (l1[i]=='(') count+=1;
if (l1[i]==')') count-=1;
if (count<0) can=false;
}
if (count!=0) return "No";
if (can==true) retur... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({"()(", ")"}) == "Yes");
assert (func0({")", ")"}) == "No");
assert (func0({"(()(())", "())())"}) == "No");
assert (func0({")())", "(()()("}) == "Yes");
assert (func0({"(())))", "(()())(("}) == "Yes");
assert (func0({"()", "())"}) == "N... | O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%r12
mov %rsi,%r13
mov %fs:0... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov r12, rdi
mov r13, rsi
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
mov rax, [rsi]
mov rbx, [rax+28h]
... | _QWORD * func0(_QWORD *a1, long long **a2)
{
unsigned long long v3; // rbx
long long v4; // rbp
unsigned long long v5; // r14
long long v6; // r15
_BYTE *v7; // rax
char v8; // bp
int v9; // ebx
unsigned long long v10; // r13
unsigned long long v11; // r14
long long v12; // r15
char *v13; // rax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV R12,RDI
MOV R13,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI]
MOV RBX,qword ptr [RAX + 0x28]
MOV RBP,qword ptr [RAX + 0x20]
MOV R14,qword ptr [RAX + 0x8]
MOV R15,qword ptr [RAX]
LEA... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
long * func0(vector param_1)
{
ulong uVar1;
ulong uVar2;
bool bVar3;
bool bVar4;
uint uVar5;
ulong *puVar6;
int8 uVar7;
long lVar8;
uint uVar9;
ulong uVar10;
ulong uVar11;
int iVar12;
long *in_RSI;
int4 in_register_000000... |
478 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<string> lst){
string l1=lst[0]+lst[1];
int i,count=0;
bool can=true;
for (i=0;i<l1.length();i++)
{
if (l1[i]=='(') count+=1;
if (l1[i]==')') count-=1;
if (count<0) can=false;
}
if (count!=0) return "No";
if (can==true) retur... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({"()(", ")"}) == "Yes");
assert (func0({")", ")"}) == "No");
assert (func0({"(()(())", "())())"}) == "No");
assert (func0({")())", "(()()("}) == "Yes");
assert (func0({"(())))", "(()())(("}) == "Yes");
assert (func0({"()", "())"}) == "N... | O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x58,%rsp
mov (%rsi... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
mov rax, [rsi]
lea r12, [rsp+0A8h+dest]
lea r1... | long long func0(long long a1, long long **a2)
{
long long *v4; // rax
long long v5; // rcx
unsigned long long v6; // r14
unsigned long long v7; // r13
long long v8; // rcx
unsigned __int16 *v9; // r8
char *v10; // rax
char *v11; // rsi
char v12; // cl
int v13; // r13d
size_t v14; // r14
long lo... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSI]
LEA R12,[RSP + 0x20]
LEA R15,[RSP + 0x30]
MOV RDI,R12
MOV RCX,qword ptr [RAX]
MOV R14,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
long * func0(vector param_1)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
bool bVar5;
bool bVar6;
ulong *puVar7;
int8 uVar8;
long *in_RSI;
int4 in_register_0000003c;
long *plVar9;
int iVar10;
long in_FS_OFFSET;
u... |
479 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<string> lst){
string l1=lst[0]+lst[1];
int i,count=0;
bool can=true;
for (i=0;i<l1.length();i++)
{
if (l1[i]=='(') count+=1;
if (l1[i]==')') count-=1;
if (count<0) can=false;
}
if (count!=0) return "No";
if (can==true) retur... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({"()(", ")"}) == "Yes");
assert (func0({")", ")"}) == "No");
assert (func0({"(()(())", "())())"}) == "No");
assert (func0({")())", "(()()("}) == "Yes");
assert (func0({"(())))", "(()())(("}) == "Yes");
assert (func0({"()", "())"}) == "N... | O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov (%rsi),%rbx
mov... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
mov rax, [rsi]
lea r12, [rsp+0A8h+dest]
lea r1... | long long func0(long long a1, long long **a2)
{
unsigned long long v4; // r14
unsigned long long v5; // r13
long long v6; // rcx
long long v7; // rax
unsigned __int16 *v8; // r8
char *v9; // rax
char *v10; // rsi
char v11; // cl
int v12; // r13d
long long *v13; // rax
long long v14; // rdi
size... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSI]
LEA R12,[RSP + 0x20]
LEA R15,[RSP + 0x30]
MOV RDI,R12
MOV R14,qword ptr [RAX + 0x8]
MOV R13,qword ptr [RAX + 0x28]
MOV RCX,qword pt... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
long * func0(vector param_1)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
bool bVar5;
bool bVar6;
ulong *puVar7;
int8 uVar8;
long *in_RSI;
int4 in_register_0000003c;
long *plVar9;
int iVar10;
long in_FS_OFFSET;
u... |
480 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> arr,int k){
sort(arr.begin(),arr.end());
vector<int> out(arr.end()-k,arr.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({-3, -4, 5}, 3) , {-4, -3, 5}));
assert (issame(func0({4, -4, 4}... | O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %edx,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 29e0 <_... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_44], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3e... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rbx
long long v4; // rax
long long v5; // r12
long long v6; // rax
char v9; // [rsp+27h] [rbp-29h] BYREF
_QWORD v10[5]; // [rsp+28h] [rbp-28h] BYREF
v10[2] = __readfsqword(0x28u);
v3 = std::vector<int>::end(a2);
v4 = std::vector<... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x44],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00102b26
MOV RBX,RAX
MOV RAX,qword... | /* func0(std::vector<int, std::allocator<int> >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
int in_EDX;
int4 in_register_00000034;
vector<int,std::allocator<int>> *this;
int4 in_register_0000003c;
long in_FS_OFFSET;
a... |
481 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> arr,int k){
sort(arr.begin(),arr.end());
vector<int> out(arr.end()-k,arr.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({-3, -4, 5}, 3) , {-4, -3, 5}));
assert (issame(func0({4, -4, 4}... | O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%r13
mov %edx,%ebx
mov 0x8(%rsi),%r14
mov (%rsi),%r15
cmp %r14,%r15
je 1330 <_Z5func0St6vectorIiSaIiEEi+0xb0>
mov %r14,%r12... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, rdi
mov r14, rsi
mov ebp, edx
mov r13, [rsi+8]
mov r15, [rsi]
cmp r15, r13
jz loc_1334
mov rbx, r13
sub rbx, r15
mov rdx, rbx
sar rdx, 2
mov ... | _QWORD * func0(_QWORD *a1, char **a2, int a3)
{
char *v5; // r13
char *v6; // r15
int v7; // eax
unsigned long long v8; // rax
char *v9; // rbx
int v10; // ecx
char *v11; // rax
int v12; // edx
char *v13; // rsi
signed long long v14; // rbp
char *v15; // rbx
_DWORD *v16; // rax
_DWORD *v17; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,RDI
MOV R14,RSI
MOV EBP,EDX
MOV R13,qword ptr [RSI + 0x8]
MOV R15,qword ptr [RSI]
CMP R15,R13
JZ 0x00101334
MOV RBX,R13
SUB RBX,R15
MOV RDX,RBX
SAR RDX,0x2
MOV EAX,0x40
JZ 0x001012c8
BSR RAX,RDX
XOR EAX,0x3f
LAB_001012c8:
MOV EDX,0... | /* func0(std::vector<int, std::allocator<int> >, int) */
_Vector_base<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar7;
int4 *__dest;
int8 uVar8;
_Iter_less_iter in_ECX;
int in_EDX;
_Iter_less_it... |
482 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> arr,int k){
sort(arr.begin(),arr.end());
vector<int> out(arr.end()-k,arr.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({-3, -4, 5}, 3) , {-4, -3, 5}));
assert (issame(func0({4, -4, 4}... | O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
movslq %edx,%r12
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rsi),%rbp
mov (%rsi),%r15
cmp %rbp,%r15
je 20af <_Z5func0St6vectorIiSaIiEEi+0xcf>
mov %rbp,%rbx
mov $0x3f,%ed... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
movsxd rbx, edx
sub rsp, 8
mov rbp, [rsi+8]
mov r14, [rsi]
cmp r14, rbp
jz loc_203F
mov r13, rbp
mov r15, rsi
mov rdx, 0FFFFFFFFFFFFFFFEh
sub r13, r14
mov ... | long long func0(long long a1, char **a2, int a3)
{
unsigned long long v3; // rbx
char *v4; // rbp
char *v5; // r14
long long v7; // rdx
unsigned long long v8; // rax
char *v9; // r13
int v10; // ecx
int v11; // edx
char *v12; // rax
char *v13; // rsi
char *v14; // rsi
unsigned long long v15; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOVSXD RBX,EDX
SUB RSP,0x8
MOV RBP,qword ptr [RSI + 0x8]
MOV R14,qword ptr [RSI]
CMP R14,RBP
JZ 0x0010203f
MOV R13,RBP
MOV R15,RSI
MOV RDX,-0x2
SUB R13,R14
MOV RAX,R13
SAR RAX,0x2
JZ 0x00101fbb
BSR RAX,RAX
CDQE
LEA RDX,[RAX + RAX*0x1]
LAB_... | /* func0(std::vector<int, std::allocator<int> >, int) */
int (*) [16] func0(vector param_1,int param_2)
{
ulong uVar1;
int *piVar2;
int (*pauVar3) [16];
_Iter_less_iter in_ECX;
int iVar4;
int in_EDX;
_Iter_less_iter extraout_EDX;
int iVar5;
long lVar6;
long lVar7;
int *piVar8;
int *piVar9;
i... |
483 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> arr,int k){
sort(arr.begin(),arr.end());
vector<int> out(arr.end()-k,arr.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({-3, -4, 5}, 3) , {-4, -3, 5}));
assert (issame(func0({4, -4, 4}... | O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov 0x8(%rsi),%rbp
mov (%rsi),%r12
mov %edx,0x8(%rsp)
cmp %rbp,%r12
je 2080 <_Z5func0St6vectorIiSaIiEEi+0x120>
mov %rbp,%r15
mov $0... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov r13, [rsi+8]
mov rbx, [rsi]
mov [rsp+48h+var_3C], edx
cmp rbx, r13
jz loc_2288
mov r14, r13
mov r12, rsi
lea r15, [rbx+4]
sub r14, rbx
mo... | long long func0(long long a1, char **a2, int a3)
{
char *v4; // r13
char *v5; // rbx
char *v7; // r15
unsigned long long v8; // rdx
char *v9; // r14
int v10; // r9d
char *v11; // rsi
int v12; // edx
char *i; // rax
char *v14; // r12
char *v15; // rcx
int v16; // esi
int v17; // edx
char *v1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV R13,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
MOV dword ptr [RSP + 0xc],EDX
CMP RBX,R13
JZ 0x00102288
MOV R14,R13
MOV R12,RSI
LEA R15,[RBX + 0x4]
SUB R14,RBX
MOV RAX,R14
SAR RAX,0x2
JZ 0x001021f1
BSR RDX,RAX
MOV RSI,R1... | /* func0(std::vector<int, std::allocator<int> >, int) */
int (*) [16]
func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int4 param_7,int param_8,int param_9,int param_10,
int4 param_11)
{
int iVar1;
ulong uVar2;
int *piVar3;
int (*pauVar4) [16];
_Iter_less_iter _Var... |
484 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i*2<lst.size();i++)
if (lst[i*2]%2==1) sum+=lst[i*2];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, 8, 7, 1}) == 12);
assert (func0({3, 3, 3, 3, 3}) == 9);
assert (func0({30, 13, 24, 321}) == 0);
assert (func0({5, 9}) == 5);
assert (func0({2, 4, 8}) == 0);
assert (func0({30, 13, 23, 32}) == 23);
assert (func0({3, 13, 2, 9})... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
add %eax,%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 18d0 <_ZNKSt6vectorIiSaIiEE4... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_12BE
loc_126A:
mov eax, [rbp+var_14]
add eax, eax
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
... | long long func0(long long a1)
{
unsigned int v2; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = 0;
for ( i = 0; 2 * i < (unsigned long long)std::vector<int>::size(a1); ++i )
{
if ( *(_DWORD *)std::vector<int>::operator[](a1, 2 * i) % 2 == 1 )
v2 += *(_DWORD *)std::vector<int>::operator[... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012be
LAB_0010126a:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,EAX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a06
MOV ED... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int *piVar1;
ulong uVar2;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int4 local_20;
int4 local_1c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local_20 = 0;
... |
485 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i*2<lst.size();i++)
if (lst[i*2]%2==1) sum+=lst[i*2];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, 8, 7, 1}) == 12);
assert (func0({3, 3, 3, 3, 3}) == 9);
assert (func0({30, 13, 24, 321}) == 0);
assert (func0({5, 9}) == 5);
assert (func0({2, 4, 8}) == 0);
assert (func0({30, 13, 23, 32}) == 23);
assert (func0({3, 13, 2, 9})... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rax
sub %rdx,%rax
sar $0x2,%rax
je 1259 <_Z5func0St6vectorIiSaIiEE+0x50>
mov %rdx,%rcx
lea -0x4(,%rax,4),%rax
and $0xfffffffffffffff8,%rax
lea 0x8(%rdx,%rax,1),%r8
mov $0x0,%esi
mov (%rcx),%eax
mov ... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov r8, [rdi]
mov r9, rax
sub r9, r8
sar r9, 2
cmp rax, r8
jz short loc_1252
mov esi, 0
mov ecx, 0
loc_122D:
mov eax, [r8+rcx*4]
mov edi, eax
shr edi, 1Fh
lea edx, [rax+rdi]
and edx, 1
sub edx, edi
add e... | long long func0(long long *a1)
{
long long v1; // r8
unsigned int v2; // esi
unsigned long long v3; // rcx
v1 = *a1;
if ( a1[1] == *a1 )
{
return 0;
}
else
{
v2 = 0;
v3 = 0LL;
do
{
if ( *(_DWORD *)(v1 + 4 * v3) % 2 == 1 )
v2 += *(_DWORD *)(v1 + 4 * v3);
v3 += ... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV R8,qword ptr [RDI]
MOV R9,RAX
SUB R9,R8
SAR R9,0x2
CMP RAX,R8
JZ 0x00101252
MOV ESI,0x0
MOV ECX,0x0
LAB_0010122d:
MOV EAX,dword ptr [R8 + RCX*0x4]
MOV EDI,EAX
SHR EDI,0x1f
LEA EDX,[RAX + RDI*0x1]
AND EDX,0x1
SUB EDX,EDI
ADD EAX,ESI
CMP EDX,0x1
CMOVZ ESI,EAX
ADD RCX,0x2
C... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
long lVar2;
long lVar3;
ulong uVar4;
int iVar5;
int4 in_register_0000003c;
lVar2 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
if (lVar2 == ... |
486 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i*2<lst.size();i++)
if (lst[i*2]%2==1) sum+=lst[i*2];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, 8, 7, 1}) == 12);
assert (func0({3, 3, 3, 3, 3}) == 9);
assert (func0({30, 13, 24, 321}) == 0);
assert (func0({5, 9}) == 5);
assert (func0({2, 4, 8}) == 0);
assert (func0({30, 13, 23, 32}) == 23);
assert (func0({3, 13, 2, 9})... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rax
sub %rcx,%rax
sar $0x2,%rax
je 17b0 <_Z5func0St6vectorIiSaIiEE+0x60>
lea -0x4(,%rax,4),%rax
xor %r8d,%r8d
and $0xfffffffffffffff8,%rax
lea 0x8(%rcx,%rax,1),%rdi
nopl 0x0(%rax,%rax,1)
mov (%rcx),%ea... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov r8, [rdi]
xor esi, esi
mov r9, rax
sub r9, r8
sar r9, 2
cmp rax, r8
jz short loc_1512
xor ecx, ecx
xchg ax, ax
loc_14F0:
mov eax, [r8+rcx*4]
mov edi, eax
shr edi, 1Fh
lea edx, [rax+rdi]
add eax, esi
and ... | long long func0(long long *a1)
{
long long v1; // r8
unsigned int v2; // esi
unsigned long long v3; // rcx
int v4; // eax
char v5; // dl
unsigned int v6; // eax
v1 = *a1;
v2 = 0;
if ( a1[1] != *a1 )
{
v3 = 0LL;
do
{
v4 = *(_DWORD *)(v1 + 4 * v3);
v5 = v4 + (v4 < 0);
v... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV R8,qword ptr [RDI]
XOR ESI,ESI
MOV R9,RAX
SUB R9,R8
SAR R9,0x2
CMP RAX,R8
JZ 0x00101512
XOR ECX,ECX
NOP
LAB_001014f0:
MOV EAX,dword ptr [R8 + RCX*0x4]
MOV EDI,EAX
SHR EDI,0x1f
LEA EDX,[RAX + RDI*0x1]
ADD EAX,ESI
AND EDX,0x1
SUB EDX,EDI
CMP EDX,0x1
CMOVZ ESI,EAX
ADD RCX,0... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
long lVar2;
long lVar3;
ulong uVar4;
int iVar5;
int4 in_register_0000003c;
lVar2 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
iVar5 = 0;
... |
487 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i*2<lst.size();i++)
if (lst[i*2]%2==1) sum+=lst[i*2];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, 8, 7, 1}) == 12);
assert (func0({3, 3, 3, 3, 3}) == 9);
assert (func0({30, 13, 24, 321}) == 0);
assert (func0({5, 9}) == 5);
assert (func0({2, 4, 8}) == 0);
assert (func0({30, 13, 23, 32}) == 23);
assert (func0({3, 13, 2, 9})... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rdx
sub %r8,%rdx
sar $0x2,%rdx
je 1f20 <_Z5func0St6vectorIiSaIiEE+0x140>
lea -0x1(%rdx),%rcx
cmp $0x7,%rcx
jbe 1f23 <_Z5func0St6vectorIiSaIiEE+0x143>
shr $0x3,%rcx
movdqa 0x133e(%rip),%xmm4
mov %r8,%rax
p... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rsi, [rdi]
mov rdx, rax
sub rdx, rsi
mov r8, rdx
sar r8, 2
cmp rax, rsi
jz loc_2140
lea rax, [r8-1]
mov ecx, 1
shr rax, 1
add rax, 1
test rdx, rdx
cmovz rax, rcx
cmp rdx, 20h ; ' '
jbe loc_2145
lea ... | long long func0(const __m128i **a1)
{
const __m128i *v1; // rsi
long long v2; // rdx
unsigned long long v3; // r8
unsigned long long v4; // rax
unsigned long long v5; // rcx
__m128i si128; // xmm4
__m128 v7; // xmm2
const __m128i *v8; // rax
__m128 v9; // xmm1
__m128 v10; // xmm5
__m128i v11; // ... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
MOV RDX,RAX
SUB RDX,RSI
MOV R8,RDX
SAR R8,0x2
CMP RAX,RSI
JZ 0x00102140
LEA RAX,[R8 + -0x1]
MOV ECX,0x1
SHR RAX,0x1
ADD RAX,0x1
TEST RDX,RDX
CMOVZ RAX,RCX
CMP RDX,0x20
JBE 0x00102145
LEA RCX,[RAX + -0x1]
MOVDQA XMM4,xmmword ptr [0x00103130]
PXOR XMM2,... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int8 uVar1;
int8 uVar2;
uint *puVar3;
uint uVar4;
long lVar5;
uint *puVar6;
ulong uVar7;
ulong uVar8;
uint uVar9;
int4 in_register_00... |
488 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> arr,int k){
int sum=0;
for (int i=0;i<k;i++)
if( arr[i]>=-99 and arr[i]<=99)
sum+=arr[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,-2,-3,41,57,76,87,88,99}, 3) == -4);
assert (func0({111,121,3,4000,5,6}, 2) == 0);
assert (func0({11,21,3,90,5,6,7,8,9}, 4) == 125);
assert (func0({111,21,3,4000,5,6,7,8,9}, 4) == 24);
assert (func0({1}, 1) == 1);
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jge 12ba <_Z5func0St6vectorIiSaIiEEi+0x91>
mov -0x4(%rbp),%eax
mov... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_12D2
loc_126C:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
mov rsi, rdx
mov rdi, rax
call ... | long long func0(long long a1, int a2)
{
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)std::vector<int>::operator[](a1, i) >= -99 && *(int *)std::vector<int>::operator[](a1, i) <= 99 )
v4 += *(_DWORD *)std::vector<int>::operato... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001012d2
LAB_0010126c:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010186... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
bool bVar1;
int *piVar2;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int4 local_10;
int4 local_c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
... |
489 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> arr,int k){
int sum=0;
for (int i=0;i<k;i++)
if( arr[i]>=-99 and arr[i]<=99)
sum+=arr[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,-2,-3,41,57,76,87,88,99}, 3) == -4);
assert (func0({111,121,3,4000,5,6}, 2) == 0);
assert (func0({11,21,3,90,5,6,7,8,9}, 4) == 125);
assert (func0({111,21,3,4000,5,6,7,8,9}, 4) == 24);
assert (func0({1}, 1) == 1);
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
test %esi,%esi
jle 123d <_Z5func0St6vectorIiSaIiEEi+0x34>
mov (%rdi),%rdx
lea -0x1(%rsi),%eax
lea 0x4(%rdx,%rax,4),%rdi
mov $0x0,%ecx
mov (%rdx),%eax
lea 0x63(%rax),%esi
add %ecx,%eax
cmp $0xc7,%esi
cmovb %eax,%ecx
add $0x4,%rd... | _Z5func0St6vectorIiSaIiEEi:
endbr64
test esi, esi
jle short loc_123C
mov rdx, [rdi]
movsxd rsi, esi
lea rdi, [rdx+rsi*4]
mov ecx, 0
loc_1220:
mov eax, [rdx]
lea esi, [rax+63h]
add eax, ecx
cmp esi, 0C7h
cmovb ecx, eax
add rdx, 4
cmp rdi, rdx
jnz short loc_1220
loc_1239:... | long long func0(_DWORD **a1, int a2)
{
_DWORD *v2; // rdx
long long v3; // rdi
unsigned int v4; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = *a1;
v3 = (long long)&(*a1)[a2];
v4 = 0;
do
{
if ( (unsigned int)(*v2 + 99) < 0xC7 )
v4 += *v2;
++v2;
}
wh... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010123c
MOV RDX,qword ptr [RDI]
MOVSXD RSI,ESI
LEA RDI,[RDX + RSI*0x4]
MOV ECX,0x0
LAB_00101220:
MOV EAX,dword ptr [RDX]
LEA ESI,[RAX + 0x63]
ADD EAX,ECX
CMP ESI,0xc7
CMOVC ECX,EAX
ADD RDX,0x4
CMP RDI,RDX
JNZ 0x00101220
LAB_00101239:
MOV EAX,ECX
RET
LAB_0010123c:
MOV ECX,0x0
JMP 0x001... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int4 in_register_0000003c;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar3 = *(int **)CONCAT44(in_register_0000003c,param_1);
piVar1 = piVar3 + param_2;
... |
490 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> arr,int k){
int sum=0;
for (int i=0;i<k;i++)
if( arr[i]>=-99 and arr[i]<=99)
sum+=arr[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,-2,-3,41,57,76,87,88,99}, 3) == -4);
assert (func0({111,121,3,4000,5,6}, 2) == 0);
assert (func0({11,21,3,90,5,6,7,8,9}, 4) == 125);
assert (func0({111,21,3,4000,5,6,7,8,9}, 4) == 24);
assert (func0({1}, 1) == 1);
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
test %esi,%esi
jle 15d8 <_Z5func0St6vectorIiSaIiEEi+0x48>
mov (%rdi),%rax
lea -0x1(%rsi),%ecx
xor %r8d,%r8d
lea 0x4(%rax),%rdx
lea (%rdx,%rcx,4),%rsi
jmp 15b4 <_Z5func0St6vectorIiSaIiEEi+0x24>
nopl 0x0(%rax,%rax,1)
add $0x4,%rdx
mov... | _Z5func0St6vectorIiSaIiEEi:
endbr64
test esi, esi
jle short loc_14A8
mov rdx, [rdi]
movsxd rsi, esi
xor ecx, ecx
lea rdi, [rdx+rsi*4]
nop dword ptr [rax+00h]
loc_1488:
mov eax, [rdx]
lea esi, [rax+63h]
add eax, ecx
cmp esi, 0C7h
cmovb ecx, eax
add rdx, 4
cmp rdi, rdx
jn... | long long func0(_DWORD **a1, int a2)
{
_DWORD *v2; // rdx
unsigned int v3; // ecx
long long v4; // rdi
if ( a2 <= 0 )
return 0LL;
v2 = *a1;
v3 = 0;
v4 = (long long)&(*a1)[a2];
do
{
if ( (unsigned int)(*v2 + 99) < 0xC7 )
v3 += *v2;
++v2;
}
while ( (_DWORD *)v4 != v2 );
return ... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001014a8
MOV RDX,qword ptr [RDI]
MOVSXD RSI,ESI
XOR ECX,ECX
LEA RDI,[RDX + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101488:
MOV EAX,dword ptr [RDX]
LEA ESI,[RAX + 0x63]
ADD EAX,ECX
CMP ESI,0xc7
CMOVC ECX,EAX
ADD RDX,0x4
CMP RDI,RDX
JNZ 0x00101488
MOV EAX,ECX
RET
LAB_001014a8:
XOR ECX,ECX
MOV... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int4 in_register_0000003c;
if (0 < param_2) {
piVar3 = *(int **)CONCAT44(in_register_0000003c,param_1);
iVar2 = 0;
piVar1 = piVar3 + param_2;
do {
if... |
491 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> arr,int k){
int sum=0;
for (int i=0;i<k;i++)
if( arr[i]>=-99 and arr[i]<=99)
sum+=arr[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,-2,-3,41,57,76,87,88,99}, 3) == -4);
assert (func0({111,121,3,4000,5,6}, 2) == 0);
assert (func0({11,21,3,90,5,6,7,8,9}, 4) == 125);
assert (func0({111,21,3,4000,5,6,7,8,9}, 4) == 24);
assert (func0({1}, 1) == 1);
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
test %esi,%esi
jle 1670 <_Z5func0St6vectorIiSaIiEEi+0x110>
lea -0x1(%rsi),%eax
mov (%rdi),%rcx
cmp $0x3,%eax
jbe 1679 <_Z5func0St6vectorIiSaIiEEi+0x119>
mov %esi,%edx
mov %rcx,%rax
pxor %xmm1,%xmm1
movdqa 0xbe4(%rip),%xmm3
movdqa 0xbcc... | _Z5func0St6vectorIiSaIiEEi:
endbr64
mov ecx, esi
test esi, esi
jle loc_1668
lea eax, [rcx-1]
mov rsi, [rdi]
cmp eax, 2
jbe loc_1671
mov edx, ecx
mov rax, rsi
pxor xmm1, xmm1
movdqa xmm4, cs:xmmword_2130
shr edx, 2
movdqa xmm3, cs:xmmword_2150
movdqa xmm2, cs:xmmword_2160
shl... | long long func0(const __m128i **a1, int a2)
{
const __m128i *v3; // rsi
const __m128i *v4; // rax
__m128i v5; // xmm1
__m128i si128; // xmm4
__m128i v7; // xmm3
__m128i v8; // xmm2
__m128i v9; // xmm0
signed int v10; // edx
__m128i v11; // xmm1
long long result; // rax
long long v13; // r8
__in... | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101668
LEA EAX,[RCX + -0x1]
MOV RSI,qword ptr [RDI]
CMP EAX,0x2
JBE 0x00101671
MOV EDX,ECX
MOV RAX,RSI
PXOR XMM1,XMM1
MOVDQA XMM4,xmmword ptr [0x00102130]
SHR EDX,0x2
MOVDQA XMM3,xmmword ptr [0x00102150]
MOVDQA XMM2,xmmword ptr [0x00102160]
SHL RDX,0x4
ADD RDX,RSI
NOP dwo... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint uVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
uint *pu... |
492 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(int n){
vector<int> out={1};
while (n!=1)
{
if (n%2==1) {out.push_back(n); n=n*3+1;}
else n=n/2;
}
sort(out.begin(),out.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(14) , {1, 5, 7, 11, 13, 17}));
assert (issame(func0(5) , {1, 5})... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x28,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movl $0x1,-0x2c(%rbp)
lea -0x2c(%rbp),%rax
mov %rax,%r12
mov $0x1,%r13d
lea -0x2d(%rbp),%rax
... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rcx, fs:28h
mov [rbp+var_18], rcx
xor ecx, ecx
mov [rbp+var_1C], 1
lea rcx, [rbp+var_1C]
mov rax, rcx
mov edx, 1
lea rcx, [rbp+var_29]
mov [rbp+var_28]... | long long func0(long long a1, int a2)
{
long long v2; // rbx
long long v3; // rax
int v5; // [rsp+4h] [rbp-3Ch] BYREF
long long v6; // [rsp+8h] [rbp-38h]
char v7; // [rsp+17h] [rbp-29h] BYREF
char *v8; // [rsp+18h] [rbp-28h]
int v9; // [rsp+24h] [rbp-1Ch] BYREF
unsigned long long v10; // [rsp+28h] [rbp... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RCX
XOR ECX,ECX
MOV dword ptr [RBP + -0x1c],0x1
LEA RCX,[RBP + -0x1c]
MOV RAX,RCX
MOV EDX,0x1
LEA RCX,[RBP + -0x29]
MOV qword ptr [RBP + -0x28... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
int in_ESI;
int4 in_register_0000003c;
long in_FS_OFFSET;
int local_44;
vector<int,std::allocator<int>> *local_40;
__new_allocator<int> local_31;
__new_allocator<int> *local_30;
... |
493 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(int n){
vector<int> out={1};
while (n!=1)
{
if (n%2==1) {out.push_back(n); n=n*3+1;}
else n=n/2;
}
sort(out.begin(),out.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(14) , {1, 5, 7, 11, 13, 17}));
assert (issame(func0(5) , {1, 5})... | O1 | cpp | func0(int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %esi,0xc(%rsp)
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov $0x4,%edi
callq 1100 <_Znwm@plt>
mov %rax,(%rbx)
lea 0x4(%rax),%rdx
mov %rdx,0x10(%rbx)
movl $0x1,(%rax)
mov ... | _Z5func0i:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
mov [rsp+38h+var_2C], esi
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov edi, 4; unsigned __int64
call __Znwm; operator new(ulong)
mov [rbp+0], rax
lea rdx,... | char ** func0(char **a1, int a2)
{
char *v2; // rax
int i; // ebx
char *v4; // r12
char *v5; // r13
int v6; // eax
unsigned long long v7; // rax
char *v8; // rbx
int v9; // ecx
char *v10; // rax
int v11; // edx
char *v12; // rsi
int *v13; // rsi
int v15[11]; // [rsp+Ch] [rbp-2Ch] BYREF
v15[... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
MOV dword ptr [RSP + 0xc],ESI
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV EDI,0x4
LAB_001012b4:
CALL 0x001010f0
MOV qword ptr [RBP],RAX
LEA RDX,[RAX + 0x4]
MOV qword ptr [RBP + 0x10],RDX
MOV dword pt... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int iVar1;
int *piVar2;
long lVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar7;
int iVar8;
int4 *puVar9;
_Iter_less_iter _Var10;
int8 in_RCX;
_Iter_less_iter extraout_EDX;
ulong uVar11;
int *piVar12;
int in_ES... |
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.