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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
494 | 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})... | O2 | cpp | func0(int):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov $0x4,%edi
mov %esi,0xc(%rsp)
callq 1100 <_Znwm@plt>
mov 0xc(%rsp),%edx
lea 0x4(%rax),%rbp
mov %rax,(%r12)
mov %rax,%r13
mov %rb... | _Z5func0i:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov edi, 4; unsigned __int64
mov [rsp+38h+var_2C], esi
call __Znwm; operator new(ulong)
mov ebx, [rsp+38h+var_2C]
lea ... | long long func0(long long a1, int a2)
{
int *v2; // rax
int v3; // ebx
int *v4; // r12
int *v5; // r13
long long v6; // rdx
unsigned long long v7; // rax
int *v8; // rbx
int v9; // ecx
int v10; // edx
int *v11; // rax
int *v12; // rsi
int *v14; // rsi
int v15[11]; // [rsp+4h] [rbp-2Ch] BYREF
... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV EDI,0x4
MOV dword ptr [RSP + 0xc],ESI
LAB_001018f9:
CALL 0x001010f0
MOV EBX,dword ptr [RSP + 0xc]
LEA R12,[RAX + 0x4]
MOV qword ptr [RBP],RAX
MOV R13,RAX
MOV qword ... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
uint uVar1;
uint *puVar2;
uint *puVar3;
ulong uVar4;
uint *puVar5;
_Iter_less_iter _Var6;
int8 in_RCX;
_Iter_less_iter extraout_EDX;
uint uVar7;
long lVar8;
uint in_ESI;
__normal_iterator _Var9;
int4 in_register_0000003c... |
495 | 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})... | O3 | cpp | func0(int):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov $0x4,%edi
mov %esi,0xc(%rsp)
callq 1100 <_Znwm@plt>
lea 0x4(%rax),%rbp
mov %rax,(%r12)
mov %rax,%r14
movl $0x... | _Z5func0i:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov edi, 4; unsigned __int64
mov [rsp+48h+var_3C], esi
call __Znwm; operator new(ulong)
mov ebx, [... | long long func0(long long a1, int a2)
{
int *v2; // rax
int v3; // ebx
int *v4; // r12
int *v5; // r15
int *v6; // rbx
unsigned long long v7; // rdx
int *v8; // r14
int v9; // r13d
int *v10; // rsi
int v11; // edx
int *j; // rax
int v13; // ecx
int v14; // edx
int *v15; // rax
int *v16; /... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV EDI,0x4
MOV dword ptr [RSP + 0xc],ESI
LAB_001018ed:
CALL 0x001010f0
MOV EBX,dword ptr [RSP + 0xc]
LEA R12,[RAX + 0x4]
MOV qword ptr [RBP],RAX
MOV ... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
uint uVar1;
long lVar2;
uint *puVar3;
uint *puVar4;
ulong uVar5;
_Iter_less_iter _Var6;
int8 in_RCX;
uint uVar7;
size_t sVar8;
uint *puVar9;
uint in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
... |
496 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string date){
int mm,dd,yy,i;
if (date.length()!=10) return false;
for (int i=0;i<10;i++)
if (i==2 or i==5)
{
if (date[i]!='-') return false;
}
else
if (date[i]<48 or date[i]>57) return false;
mm=atoi(date.substr(0,2).c_str());
dd=a... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("03-11-2000") == true);
assert (func0("15-01-2012") == false);
assert (func0("04-0-2040") == false);
assert (func0("06-04-2020") == true);
assert (func0("01-01-2007") == true);
assert (func0("03-32-2011") == false);
assert (func0(""... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 22e0 <_ZNKSt7__cxx1112basic_stringIcSt11char... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_48], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv;... | _BOOL8 func0(long long a1)
{
const char *v3; // rax
const char *v4; // rax
const char *v5; // rax
int i; // [rsp+10h] [rbp-40h]
int v7; // [rsp+14h] [rbp-3Ch]
int v8; // [rsp+18h] [rbp-38h]
_BYTE v9[40]; // [rsp+20h] [rbp-30h] BYREF
unsigned long long v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00101260
CMP RAX,0xa
SETNZ AL
TEST AL,AL
JZ 0x001013e9
MOV EAX,0x0
JMP 0x001015ac
LAB_001013e9:
MOV dword ptr [RBP + ... | /* func0(std::string) */
int8 func0(ulong param_1)
{
bool bVar1;
int iVar2;
int iVar3;
long lVar4;
int8 uVar5;
char *pcVar6;
long in_FS_OFFSET;
int local_48;
string local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar4 = std::string::length();
if (lVar4 == 10) {
... |
497 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string date){
int mm,dd,yy,i;
if (date.length()!=10) return false;
for (int i=0;i<10;i++)
if (i==2 or i==5)
{
if (date[i]!='-') return false;
}
else
if (date[i]<48 or date[i]>57) return false;
mm=atoi(date.substr(0,2).c_str());
dd=a... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("03-11-2000") == true);
assert (func0("15-01-2012") == false);
assert (func0("04-0-2040") == false);
assert (func0("06-04-2020") == true);
assert (func0("01-01-2007") == true);
assert (func0("03-32-2011") == false);
assert (func0(""... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
cmpq $0xa,0x8(%rdi)
jne 143d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 30h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
cmp qword ptr [rdi+8], 0Ah
jz short loc_12F5
mov ebx, 0
loc_12B8:
mov ra... | long long func0(_QWORD *a1, long long a2, long long a3, unsigned int a4)
{
long long v4; // rax
unsigned int v5; // ebx
unsigned long long v7; // r12
unsigned long long v8; // rdx
unsigned long long v9; // rdx
int v10; // r13d
unsigned long long v11; // rdx
unsigned long long v12; // rdx
int v13; // ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CMP qword ptr [RDI + 0x8],0xa
JZ 0x001012f5
MOV EBX,0x0
LAB_001012b8:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014fd
MOV EAX,EBX
ADD RSP,... | /* func0(std::string) */
ulong func0(long *param_1,int8 param_2,int8 param_3,ulong param_4)
{
uint uVar1;
int iVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
byte bVar6;
ulong uVar7;
long in_FS_OFFSET;
long *local_58 [2];
long local_48 [3];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x... |
498 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string date){
int mm,dd,yy,i;
if (date.length()!=10) return false;
for (int i=0;i<10;i++)
if (i==2 or i==5)
{
if (date[i]!='-') return false;
}
else
if (date[i]<48 or date[i]>57) return false;
mm=atoi(date.substr(0,2).c_str());
dd=a... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("03-11-2000") == true);
assert (func0("15-01-2012") == false);
assert (func0("04-0-2040") == false);
assert (func0("06-04-2020") == true);
assert (func0("01-01-2007") == true);
assert (func0("03-32-2011") == false);
assert (func0(""... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
cmpq $0xa,0x8(%rdi)
jne 1960 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traits... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 30h
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
cmp qword ptr [rdi+8], 0Ah
jnz short loc_19C9
mov rsi, [rdi]
mov rbx, rdi
mov ecx, 24h... | long long func0(long long *a1)
{
unsigned long long v1; // rax
long long v2; // rsi
long long v3; // rcx
char v4; // dl
long long result; // rax
unsigned long long v6; // r12
unsigned long long v7; // rdx
long long v8; // rax
unsigned long long v9; // rdx
int v10; // r14d
unsigned long long v11; ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CMP qword ptr [RDI + 0x8],0xa
JNZ 0x001019c9
MOV RSI,qword ptr [RDI]
MOV RBX,RDI
MOV ECX,0x24
JMP 0x001019b7
LAB_001019a8:
CMP DL,0x2d
JNZ 0x001019c9
LAB_001019ad:
ADD RAX,0x1
... | /* WARNING: Control flow encountered bad instruction data */
/* func0(std::string) */
uint func0(long *param_1)
{
char *pcVar1;
uint uVar2;
int iVar3;
uint uVar4;
ulong uVar5;
ulong uVar6;
int8 extraout_RDX;
int8 extraout_RDX_00;
int8 uVar7;
ulong extraout_RDX_01;
long in_FS_OFFSET;
long *loca... |
499 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string date){
int mm,dd,yy,i;
if (date.length()!=10) return false;
for (int i=0;i<10;i++)
if (i==2 or i==5)
{
if (date[i]!='-') return false;
}
else
if (date[i]<48 or date[i]>57) return false;
mm=atoi(date.substr(0,2).c_str());
dd=a... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("03-11-2000") == true);
assert (func0("15-01-2012") == false);
assert (func0("04-0-2040") == false);
assert (func0("06-04-2020") == true);
assert (func0("01-01-2007") == true);
assert (func0("03-32-2011") == false);
assert (func0(""... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
cmpq $0xa,0x8(%rdi)
jne 1b90 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
cmp qword ptr [rdi+8], 0Ah
jz short loc_1970
loc_1965:
xor eax, eax
jmp loc_1B36
loc_1970:
mov ra... | long long func0(long long a1)
{
long long result; // rax
_BYTE *v2; // rax
__int16 v3; // ax
unsigned long long v4; // r12
unsigned long long v5; // rcx
unsigned long long v6; // rcx
long long v7; // rax
_BYTE *v8; // rdx
int v9; // r13d
unsigned long long v10; // rcx
unsigned long long v11; // r... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CMP qword ptr [RDI + 0x8],0xa
JZ 0x00101970
LAB_00101965:
XOR EAX,EAX
JMP 0x00101b36
LAB_00101970:
MOV RAX,qword ptr [RDI]
MOV RBX,RDI
MOVZX ESI,byte ptr [RAX]
LEA EDX,[RSI + -0x30]
CMP... | /* WARNING: Control flow encountered bad instruction data */
/* WARNING: Removing unreachable block (ram,0x00101a87) */
/* WARNING: Removing unreachable block (ram,0x00101a1b) */
/* WARNING: Removing unreachable block (ram,0x00101af0) */
/* func0(std::string) */
uint func0(long *param_1)
{
int2 uVar1;
char *pcVar... |
500 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string txt){
int i;
string current="";
vector<string> out={};
if (find(txt.begin(),txt.end(),' ')!=txt.end())
{
txt=txt+' ';
for (i=0;i<txt.length();i++)
if (txt[i]==' ')
{
if (current.length()>0)out.push_back(current);
... | #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("Hello world!") , {"Hello","world!"}));
assert (issame(fun... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x108,%rsp
mov %rdi,-0x118(%rbp)
mov %rsi,-0x120(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
lea -0xf0(%rbp),%rax
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov [rbp+var_D8], rdi
mov [rbp+var_E0], rsi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea rax, [rbp+var_A0]
mo... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
char *v4; // rax
unsigned long long v5; // rbx
long long v6; // rbx
long long v7; // rax
char *v8; // rax
unsigned long long v9; // rbx
unsigned long long v11; // rbx
_BYTE *j; // rbx
char v14; // [rsp+27h] [r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RBP + -0xd8],RDI
MOV qword ptr [RBP + -0xe0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xa0]
MOV qword ptr [RBP + -0xb0],RAX
NOP
NOP
LEA RDX,[RBP + -0xa0]
LEA RA... | /* 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;
__normal_iterator _Var2;
__normal_iterator _Var3;
int4 extraout_var;
char *pcVar4;
long lVar5;
ulong uVar6;
int4 extraout_var_00;
b... |
501 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string txt){
int i;
string current="";
vector<string> out={};
if (find(txt.begin(),txt.end(),' ')!=txt.end())
{
txt=txt+' ';
for (i=0;i<txt.length();i++)
if (txt[i]==' ')
{
if (current.length()>0)out.push_back(current);
... | #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("Hello world!") , {"Hello","world!"}));
assert (issame(fun... | 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 $0xe0,%rsp
mov %rdi,%r12
mov %rsi,%rbx
mov %fs:0x28,%rax
mov %rax,0xd8(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%rdi
lea 0x40(%rsp),%rax
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 168h
mov r12, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+198h+var_40], rax
xor eax, eax
lea rdi, [rsp+198h+var_158]
lea rax, [rsp+198h+var... | _QWORD * func0(_QWORD *a1, void **a2)
{
_BYTE *v4; // rbp
unsigned long long v5; // r13
unsigned long long v6; // r14
_BYTE *v7; // rax
void *v8; // rcx
long long v9; // rbp
unsigned int v10; // edx
unsigned long long v11; // rax
unsigned long long v12; // rsi
_BYTE *v13; // rax
char *v14; // rcx
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x168
MOV R12,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x158],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x40]
LEA RAX,[RSP + 0x50]
MOV qword ptr [RSP + 0x40],RAX
LEA RSI,[0x10427c]
MOV RDX,RSI
LAB_0010146d:
CALL 0x00102ebe
MOV qwo... | /* func0(std::string) */
int8 *
func0(int8 *param_1,long *param_2,int8 param_3,random_access_iterator_tag param_4)
{
byte *pbVar1;
ulong *puVar2;
__normal_iterator _Var3;
uint uVar4;
int4 extraout_var;
int8 uVar5;
long lVar6;
int4 extraout_var_00;
byte *pbVar7;
long *plVar8;
uint uVar9;
ulong ... |
502 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string txt){
int i;
string current="";
vector<string> out={};
if (find(txt.begin(),txt.end(),' ')!=txt.end())
{
txt=txt+' ';
for (i=0;i<txt.length();i++)
if (txt[i]==' ')
{
if (current.length()>0)out.push_back(current);
... | #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("Hello world!") , {"Hello","world!"}));
assert (issame(fun... | O2 | 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
mov %rsi,%rbx
sub $0xe8,%rsp
mov 0x8(%rbx),%rcx
mov (%rsi),%rsi
mov %rdi,0x8(%rsp)
mov %rcx,%rdi
lea (%rsi,%rcx,1),%r9
mov %rcx,... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rsi
sub rsp, 178h
mov r14, [rsi+8]
mov rbp, [rsi]
mov [rsp+1A8h+var_198], rdi
mov rdi, r14
lea rsi, [rbp+r14+0]
sar rd... | __m128i * func0(__m128i *a1, long long a2, long long a3, long long a4)
{
signed long long v5; // r14
double *v6; // rbp
double *v7; // rsi
long long v8; // rdi
double *v9; // rax
double *v10; // rdx
double *v11; // rdi
__int8 *v12; // rcx
size_t v13; // rdx
unsigned long long v14; // rbp
unsigned ... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x178
MOV R14,qword ptr [RSI + 0x8]
MOV RBP,qword ptr [RSI]
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,R14
LEA RSI,[RBP + R14*0x1]
SAR RDI,0x2
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x168],RAX
XOR EAX,EAX
LEA R... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2)
{
uint uVar1;
byte *pbVar2;
byte *pbVar3;
long *plVar4;
vector<std::st... |
503 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string txt){
int i;
string current="";
vector<string> out={};
if (find(txt.begin(),txt.end(),' ')!=txt.end())
{
txt=txt+' ';
for (i=0;i<txt.length();i++)
if (txt[i]==' ')
{
if (current.length()>0)out.push_back(current);
... | #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("Hello world!") , {"Hello","world!"}));
assert (issame(fun... | O3 | cpp | func0(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
mov %rsi,%rbp
push %rbx
sub $0x108,%rsp
mov 0x8(%rsi),%r12
mov (%rsi),%r13
mov %rdi,0x18(%rsp)
mov %r12,%rcx
lea 0x0(%r13,... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rsi
sub rsp, 188h
mov rbp, [rsi+8]
mov r12, [rsi]
mov [rsp+1B8h+var_1B0], rdi
mov rsi, rbp
lea rdi, [r12+rbp]
sar rsi,... | long long func0(
long long a1,
void **a2,
double a3,
__m128i a4,
__m128i a5,
__m128i a6,
__m128i a7,
long long a8,
long long a9)
{
__m128i v9; // xmm0
size_t v11; // rbp
double *v12; // r12
double *v13; // rdi
long long v14; // rsi
dou... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x188
MOV RBP,qword ptr [RSI + 0x8]
MOV R12,qword ptr [RSI]
MOV qword ptr [RSP + 0x8],RDI
MOV RSI,RBP
LEA RDI,[R12 + RBP*0x1]
SAR RSI,0x2
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x178],RAX
XOR EAX,EAX
LEA RA... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::string) */
int (*) [16] func0(int (*param_1) [16],long *param_2)
{
uint uVar1;
byte *pbVar2;
byte *pbVar3;
byte *pbVar4;
byte *pbVar5;
byte *pbVar6;
byte *pbVar7;
byte *pbVar8;
byte *pbVar9;
byte *pb... |
504 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(vector<int> lst){
for (int i=1;i<lst.size();i++)
{
if (lst[i]<lst[i-1]) return false;
if (i>=2 and lst[i]==lst[i-1] and lst[i]==lst[i-2]) return false;
}
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5}) == true);
assert (func0({1, 2, 3, 4, 5}) == true);
assert (func0({1, 3, 2, 4, 5}) == false);
assert (func0({1, 2, 3, 4, 5, 6}) == true);
assert (func0({1, 2, 3, 4, 5, 6, 7}) == true);
assert (func0({1, 3, 2, 4, 5, 6, 7}) == false);... | 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 $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1f26 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,%rbx
setb %al
test ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_14], 1
jmp loc_1335
loc_1266:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<i... | long long func0(long long a1)
{
int v1; // ebx
int v3; // ebx
int v4; // ebx
int i; // [rsp+1Ch] [rbp-14h]
for ( i = 1; i < (unsigned long long)std::vector<int>::size(a1); ++i )
{
v1 = *(_DWORD *)std::vector<int>::operator[](a1, i);
if ( v1 < *(_DWORD *)std::vector<int>::operator[](a1, i - 1) )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x14],0x1
JMP 0x00101335
LAB_00101266:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001020b4
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int iVar1;
bool bVar2;
int *piVar3;
ulong uVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int local_1c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local... |
505 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(vector<int> lst){
for (int i=1;i<lst.size();i++)
{
if (lst[i]<lst[i-1]) return false;
if (i>=2 and lst[i]==lst[i-1] and lst[i]==lst[i-2]) return false;
}
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5}) == true);
assert (func0({1, 2, 3, 4, 5}) == true);
assert (func0({1, 3, 2, 4, 5}) == false);
assert (func0({1, 2, 3, 4, 5, 6}) == true);
assert (func0({1, 2, 3, 4, 5, 6, 7}) == true);
assert (func0({1, 3, 2, 4, 5, 6, 7}) == false);... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%rax
sub %rsi,%rax
sar $0x2,%rax
mov %rax,%rdi
cmp $0x1,%rax
jbe 1258 <_Z5func0St6vectorIiSaIiEE+0x4f>
mov $0x1,%eax
jmp 1234 <_Z5func0St6vectorIiSaIiEE+0x2b>
add $0x1,%rax
cmp %rdi,%rax
je 1252 <_Z... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rsi, [rdi]
mov rax, [rdi+8]
sub rax, rsi
mov rdi, rax
sar rdi, 2
cmp rax, 4
jbe short loc_1258
mov eax, 1
jmp short loc_1234
loc_122B:
add rax, 1
cmp rax, rdi
jnb short loc_1252
loc_1234:
mov edx, [rsi+rax*4]
mov ecx, [rsi+ra... | long long func0(long long *a1)
{
long long v1; // rsi
long long v2; // rax
unsigned long long v3; // rdi
long long v4; // rax
int v5; // edx
int v6; // ecx
v1 = *a1;
v2 = a1[1] - *a1;
v3 = v2 >> 2;
if ( (unsigned long long)v2 <= 4 )
return 1LL;
v4 = 1LL;
while ( 1 )
{
v5 = *(_DWORD *... | func0:
ENDBR64
MOV RSI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RSI
MOV RDI,RAX
SAR RDI,0x2
CMP RAX,0x4
JBE 0x00101258
MOV EAX,0x1
JMP 0x00101234
LAB_0010122b:
ADD RAX,0x1
CMP RAX,RDI
JNC 0x00101252
LAB_00101234:
MOV EDX,dword ptr [RSI + RAX*0x4]
MOV ECX,dword ptr [RSI + RAX*0x4 + -0x4]
CMP EDX,ECX
JL 0x00... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int iVar1;
int iVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
int4 in_register_0000003c;
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar4 = ((long *)CONCAT44(in_register_0000003c,param_1))[1] - lVar3;
if ... |
506 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(vector<int> lst){
for (int i=1;i<lst.size();i++)
{
if (lst[i]<lst[i-1]) return false;
if (i>=2 and lst[i]==lst[i-1] and lst[i]==lst[i-2]) return false;
}
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5}) == true);
assert (func0({1, 2, 3, 4, 5}) == true);
assert (func0({1, 3, 2, 4, 5}) == false);
assert (func0({1, 2, 3, 4, 5, 6}) == true);
assert (func0({1, 2, 3, 4, 5, 6, 7}) == true);
assert (func0({1, 3, 2, 4, 5, 6, 7}) == false);... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rax
sub %rdx,%rax
mov %rax,%rsi
sar $0x2,%rsi
cmp $0x7,%rax
jbe 1870 <_Z5func0St6vectorIiSaIiEE+0x50>
mov $0x1,%eax
jmp 1851 <_Z5func0St6vectorIiSaIiEE+0x31>
nopw 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rdx, [rdi]
mov rax, [rdi+8]
sub rax, rdx
mov rsi, rax
sar rsi, 2
cmp rax, 4
jbe short loc_1720
mov eax, 1
jmp short loc_1701
loc_16F8:
add rax, 1
cmp rax, rsi
jnb short loc_1720
loc_1701:
mov ecx, [rdx+rax*4]
cmp ecx, [rdx+ra... | long long func0(long long *a1)
{
long long v1; // rdx
long long v2; // rax
int v3; // ecx
v1 = *a1;
if ( (unsigned long long)(a1[1] - *a1) <= 4 )
return 1LL;
v2 = 1LL;
while ( 1 )
{
v3 = *(_DWORD *)(v1 + 4 * v2);
if ( v3 < *(_DWORD *)(v1 + 4 * v2 - 4)
|| v3 == *(_DWORD *)(v1 + 4 * v2... | func0:
ENDBR64
MOV RDX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RDX
MOV RSI,RAX
SAR RSI,0x2
CMP RAX,0x4
JBE 0x00101720
MOV EAX,0x1
JMP 0x00101701
LAB_001016f8:
ADD RAX,0x1
CMP RAX,RSI
JNC 0x00101720
LAB_00101701:
MOV ECX,dword ptr [RDX + RAX*0x4]
CMP ECX,dword ptr [RDX + RAX*0x4 + -0x4]
JL 0x00101717
JNZ 0... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int iVar1;
int iVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
int4 in_register_0000003c;
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar4 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8) - lVar3;
i... |
507 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(vector<int> lst){
for (int i=1;i<lst.size();i++)
{
if (lst[i]<lst[i-1]) return false;
if (i>=2 and lst[i]==lst[i-1] and lst[i]==lst[i-2]) return false;
}
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5}) == true);
assert (func0({1, 2, 3, 4, 5}) == true);
assert (func0({1, 3, 2, 4, 5}) == false);
assert (func0({1, 2, 3, 4, 5, 6}) == true);
assert (func0({1, 2, 3, 4, 5, 6, 7}) == true);
assert (func0({1, 3, 2, 4, 5, 6, 7}) == false);... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rax
sub %rdx,%rax
mov %rax,%rsi
sar $0x2,%rsi
cmp $0x7,%rax
jbe 1850 <_Z5func0St6vectorIiSaIiEE+0x50>
mov $0x1,%eax
jmp 1831 <_Z5func0St6vectorIiSaIiEE+0x31>
nopw 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rdx, [rdi]
mov rax, [rdi+8]
sub rax, rdx
mov rsi, rax
sar rsi, 2
cmp rax, 4
jbe short loc_17B0
mov eax, 1
jmp short loc_1791
loc_1788:
add rax, 1
cmp rax, rsi
jnb short loc_17B0
loc_1791:
mov ecx, [rdx+rax*4]
cmp ecx, [rdx+ra... | long long func0(long long *a1)
{
long long v1; // rdx
long long v2; // rax
int v3; // ecx
v1 = *a1;
if ( (unsigned long long)(a1[1] - *a1) <= 4 )
return 1LL;
v2 = 1LL;
while ( 1 )
{
v3 = *(_DWORD *)(v1 + 4 * v2);
if ( v3 < *(_DWORD *)(v1 + 4 * v2 - 4)
|| v3 == *(_DWORD *)(v1 + 4 * v2... | func0:
ENDBR64
MOV RDX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RDX
MOV RSI,RAX
SAR RSI,0x2
CMP RAX,0x4
JBE 0x001017b0
MOV EAX,0x1
JMP 0x00101791
LAB_00101788:
ADD RAX,0x1
CMP RAX,RSI
JNC 0x001017b0
LAB_00101791:
MOV ECX,dword ptr [RDX + RAX*0x4]
CMP ECX,dword ptr [RDX + RAX*0x4 + -0x4]
JL 0x001017a7
JNZ 0... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int iVar1;
int iVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
int4 in_register_0000003c;
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar4 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8) - lVar3;
i... |
508 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0( vector<int> interval1,vector<int> interval2){
int inter1,inter2,l,i;
inter1=max(interval1[0],interval2[0]);
inter2=min(interval1[1],interval2[1]);
l=inter2-inter1;
if (l<2) return "NO";
for (i=2;i*i<=l;i++)
if (l%i==0) return "NO";
return "YES";
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2}, {2, 3}) == "NO");
assert (func0({-1, 1}, {0, 4}) == "NO");
assert (func0({-3, -1}, {-5, 5}) == "YES");
assert (func0({-2, 2}, {-4, 0}) == "YES");
assert (func0({-11, 2}, {-1, -1}) == "NO");
assert (func0({1, 2}, {3, 5}) == "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
mov -0x48(%rbp),%r... | _Z5func0B5cxx11St6vectorIiSaIiEES1_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_68]
mov esi, 0
mov rdi, rax
call _ZNSt6vect... | long long func0[abi:cxx11](long long a1, long long a2, long long a3)
{
long long v3; // rbx
long long v4; // rax
long long v5; // rbx
long long v6; // rax
char v9; // [rsp+2Fh] [rbp-41h] BYREF
int i; // [rsp+30h] [rbp-40h]
int v11; // [rsp+34h] [rbp-3Ch]
int v12; // [rsp+38h] [rbp-38h]
int v13; // [r... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00103846
MOV RBX,RAX... | /* 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)
{
int *piVar1;
int *piVar2;
vector<int,std::allocator<int>> *in_RDX;
int4 in_register_00000034;
int4 in_register_0000003c;
string *this;
lon... |
509 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0( vector<int> interval1,vector<int> interval2){
int inter1,inter2,l,i;
inter1=max(interval1[0],interval2[0]);
inter2=min(interval1[1],interval2[1]);
l=inter2-inter1;
if (l<2) return "NO";
for (i=2;i*i<=l;i++)
if (l%i==0) return "NO";
return "YES";
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2}, {2, 3}) == "NO");
assert (func0({-1, 1}, {0, 4}) == "NO");
assert (func0({-3, -1}, {-5, 5}) == "YES");
assert (func0({-2, 2}, {-4, 0}) == "YES");
assert (func0({-11, 2}, {-1, -1}) == "NO");
assert (func0({1, 2}, {3, 5}) == "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 (%rdx),%rax
mov (%rsi),%rdx
mov (%rdx),%edi
cmp %edi,(%rax)
mov %rax,%rcx
cmovle %rdx,%rcx
mov (%rcx),%edi
lea 0x4(%rax),%rcx
mov 0x4(%rax),%eax
cmp %eax,... | _Z5func0B5cxx11St6vectorIiSaIiEES1_:
endbr64
push rbx
mov rbx, rdi
mov rax, [rdx]
mov rdx, [rsi]
mov edi, [rax]
cmp [rdx], edi
mov rcx, rdx
cmovl rcx, rax
mov edi, [rcx]
lea rcx, [rax+4]
mov esi, [rdx+4]
cmp [rax+4], esi
jl short loc_12B4
lea rcx, [rdx+4]
loc_12B4:
... | _QWORD * func0[abi:cxx11](_QWORD *a1, int **a2, int **a3)
{
int *v4; // rax
int *v5; // rdx
int *v6; // rcx
int v7; // edi
_DWORD *v8; // rcx
int v9; // esi
int v10; // ecx
v4 = *a3;
v5 = *a2;
v6 = *a2;
if ( **a2 < *v4 )
v6 = v4;
v7 = *v6;
v8 = v4 + 1;
if ( v4[1] >= v5[1] )
v8 = v5 ... | func0[abi:cxx11]:
ENDBR64
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDX]
MOV RDX,qword ptr [RSI]
MOV EDI,dword ptr [RAX]
CMP dword ptr [RDX],EDI
MOV RCX,RDX
CMOVL RCX,RAX
MOV EDI,dword ptr [RCX]
LEA RCX,[RAX + 0x4]
MOV ESI,dword ptr [RDX + 0x4]
CMP dword ptr [RAX + 0x4],ESI
JL 0x001012b4
LEA RCX,[RDX + 0x4]
LAB_001012b4:... | /* 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)
{
int *piVar1;
int *piVar2;
int iVar3;
int *piVar4;
int8 *in_RDX;
uint uVar5;
int4 in_register_00000034;
int4 in_register_0000003c;
long *... |
510 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0( vector<int> interval1,vector<int> interval2){
int inter1,inter2,l,i;
inter1=max(interval1[0],interval2[0]);
inter2=min(interval1[1],interval2[1]);
l=inter2-inter1;
if (l<2) return "NO";
for (i=2;i*i<=l;i++)
if (l%i==0) return "NO";
return "YES";
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2}, {2, 3}) == "NO");
assert (func0({-1, 1}, {0, 4}) == "NO");
assert (func0({-3, -1}, {-5, 5}) == "YES");
assert (func0({-2, 2}, {-4, 0}) == "YES");
assert (func0({-11, 2}, {-1, -1}) == "NO");
assert (func0({1, 2}, {3, 5}) == "NO")... | O2 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
mov (%rdx),%rdx
mov (%rsi),%rax
mov %rdi,%r8
lea 0x10(%rdi),%rdi
mov 0x4(%rax),%esi
mov (%rax),%eax
cmp %esi,0x4(%rdx)
cmovle 0x4(%rdx),%esi
cmp %eax,(%rdx)
cmovge (%rdx),%eax
sub %eax,%e... | _Z5func0B5cxx11St6vectorIiSaIiEES1_:
endbr64
push rbx
mov rax, [rsi]
mov rbx, rdi
mov rdx, [rdx]
mov ecx, [rax+4]
mov eax, [rax]
mov esi, [rdx+4]
mov edx, [rdx]
cmp esi, ecx
cmovg esi, ecx
cmp eax, edx
cmovl eax, edx
sub esi, eax
cmp esi, 1
jle short loc_1A48
cmp ... | _QWORD * func0[abi:cxx11](_QWORD *a1, int **a2, int **a3)
{
int *v3; // rdx
int v4; // ecx
int v5; // eax
int v6; // esi
int v7; // edx
int v8; // esi
int v9; // ecx
v3 = *a3;
v4 = (*a2)[1];
v5 = **a2;
v6 = v3[1];
v7 = *v3;
if ( v6 > v4 )
v6 = v4;
if ( v5 < v7 )
v5 = v7;
v8 = v6 -... | func0[abi:cxx11]:
ENDBR64
PUSH RBX
MOV RAX,qword ptr [RSI]
MOV RBX,RDI
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RAX + 0x4]
MOV EAX,dword ptr [RAX]
MOV ESI,dword ptr [RDX + 0x4]
MOV EDX,dword ptr [RDX]
CMP ESI,ECX
CMOVG ESI,ECX
CMP EAX,EDX
CMOVL EAX,EDX
SUB ESI,EAX
CMP ESI,0x1
JLE 0x00101a48
CMP ESI,0x3
JLE 0x00101a25... | /* 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)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int8 *in_RDX;
uint uVar5;
int4 in_register_00000034;
int4 in_register_0000003c;
long *plVar6... |
511 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0( vector<int> interval1,vector<int> interval2){
int inter1,inter2,l,i;
inter1=max(interval1[0],interval2[0]);
inter2=min(interval1[1],interval2[1]);
l=inter2-inter1;
if (l<2) return "NO";
for (i=2;i*i<=l;i++)
if (l%i==0) return "NO";
return "YES";
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2}, {2, 3}) == "NO");
assert (func0({-1, 1}, {0, 4}) == "NO");
assert (func0({-3, -1}, {-5, 5}) == "YES");
assert (func0({-2, 2}, {-4, 0}) == "YES");
assert (func0({-11, 2}, {-1, -1}) == "NO");
assert (func0({1, 2}, {3, 5}) == "NO")... | O3 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
mov (%rdx),%rdx
mov (%rsi),%rax
mov %rdi,%r8
lea 0x10(%rdi),%rdi
mov 0x4(%rax),%esi
mov (%rax),%eax
cmp %esi,0x4(%rdx)
cmovle 0x4(%rdx),%esi
cmp %eax,(%rdx)
cmovge (%rdx),%eax
sub %eax,%e... | _Z5func0B5cxx11St6vectorIiSaIiEES1_:
endbr64
mov rax, [rsi]
mov rdx, [rdx]
mov ecx, [rax+4]
mov esi, [rdx+4]
mov eax, [rax]
mov edx, [rdx]
cmp esi, ecx
cmovg esi, ecx
cmp eax, edx
cmovl eax, edx
sub esi, eax
cmp esi, 1
jle short loc_1920
cmp esi, 3
jle short loc_1... | long long func0[abi:cxx11](long long a1, int **a2, int **a3)
{
int *v3; // rax
int *v4; // rdx
int v5; // ecx
int v6; // esi
int v7; // eax
int v8; // edx
int v9; // esi
int v10; // ecx
long long result; // rax
v3 = *a2;
v4 = *a3;
v5 = (*a2)[1];
v6 = v4[1];
v7 = *v3;
v8 = *v4;
if ( v6 ... | func0[abi:cxx11]:
ENDBR64
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RDX]
MOV ECX,dword ptr [RAX + 0x4]
MOV ESI,dword ptr [RDX + 0x4]
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RDX]
CMP ESI,ECX
CMOVG ESI,ECX
CMP EAX,EDX
CMOVL EAX,EDX
SUB ESI,EAX
CMP ESI,0x1
JLE 0x00101920
CMP ESI,0x3
JLE 0x001018f5
TEST SIL,0x1
JZ 0x00... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >)
*/
int8 func0_abi_cxx11_(vector param_1,vector param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int8 *in_RDX;
uint uVar5;
int4 in_register_00000034;
int4 in_register_0000003c;
iVar4 = (*(... |
512 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> arr){
if (arr.size()==0) return -32768;
int i,sum=0,prods=1;
for (i=0;i<arr.size();i++)
{
sum+=abs(arr[i]);
if (arr[i]==0) prods=0;
if (arr[i]<0) prods=-prods;
}
return sum*prods;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 2, -4}) == -9);
assert (func0({0, 1}) == 0);
assert (func0({1, 1, 1, 2, 3, -1, 1}) == -10);
assert (func0({}) == -32768);
assert (func0({2, 4,1, 2, -1, -1, 9}) == 20);
assert (func0({-1, 1, -1, 1}) == 4);
assert (func0({-1, 1... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1a58 <_ZNKSt6vectorIiSaIiEE4sizeEv>
test %rax,%rax
sete %al
test %al,%al
je 125a <_Z5func0St6vectorIiSaIiEE+0x31>
mov $0x... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
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_127A
mov eax, 0FFFF8000h
j... | long long func0(long long a1)
{
int v2; // eax
int i; // [rsp+14h] [rbp-1Ch]
int v4; // [rsp+18h] [rbp-18h]
int v5; // [rsp+1Ch] [rbp-14h]
if ( !std::vector<int>::size(a1) )
return 4294934528LL;
v4 = 0;
v5 = 1;
for ( i = 0; i < (unsigned long long)std::vector<int>::size(a1); ++i )
{
v2 = *(_... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101b1c
TEST RAX,RAX
SETZ AL
TEST AL,AL
JZ 0x0010127a
MOV EAX,0xffff8000
JMP 0x00101325
LAB_0010127a:
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x1
MOV dword pt... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
long lVar2;
int *piVar3;
ulong uVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int4 local_24;
int4 local_20;
int4 local_1c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_r... |
513 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> arr){
if (arr.size()==0) return -32768;
int i,sum=0,prods=1;
for (i=0;i<arr.size();i++)
{
sum+=abs(arr[i]);
if (arr[i]==0) prods=0;
if (arr[i]<0) prods=-prods;
}
return sum*prods;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 2, -4}) == -9);
assert (func0({0, 1}) == 0);
assert (func0({1, 1, 1, 2, 3, -1, 1}) == -10);
assert (func0({}) == -32768);
assert (func0({2, 4,1, 2, -1, -1, 9}) == 20);
assert (func0({-1, 1, -1, 1}) == 4);
assert (func0({-1, 1... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov 0x8(%rdi),%rax
mov (%rdi),%r9
mov %rax,%rdx
sub %r9,%rdx
mov %rdx,%rcx
sar $0x2,%rcx
cmp %rax,%r9
je 127a <_Z5func0St6vectorIiSaIiEE+0x71>
test %rcx,%rcx
je 126a <_Z5func0St6vectorIiSaIiEE+0x61>
mov %r9,%rcx
add %rdx,%r9
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_125F
mov ecx, 0
mov eax, 1
mov edi, 0
jmp short loc_123F
loc_1234:
mov eax, edx
loc_1236:
add rcx, 1
cmp rcx, r9
jnb short loc_125B
loc... | long long func0(long long *a1)
{
long long v1; // r8
unsigned long long v2; // r9
unsigned long long v3; // rcx
int v4; // eax
int v5; // edi
int v6; // edx
int v7; // esi
v1 = *a1;
v2 = (a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 4294934528LL;
v3 = 0LL;
v4 = 1;
v5 = 0;
do
{
v... | 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 0x0010125f
MOV ECX,0x0
MOV EAX,0x1
MOV EDI,0x0
JMP 0x0010123f
LAB_00101234:
MOV EAX,EDX
LAB_00101236:
ADD RCX,0x1
CMP RCX,R9
JNC 0x0010125b
LAB_0010123f:
MOV EDX,dword ptr [R8 + RCX*0x4]
MOV ESI,EDX
NEG ESI... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
long lVar2;
long lVar3;
int iVar4;
ulong uVar5;
int iVar6;
int iVar7;
int4 in_register_0000003c;
lVar2 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar3 = *(long *)CONCAT44(in_register_0000003c... |
514 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> arr){
if (arr.size()==0) return -32768;
int i,sum=0,prods=1;
for (i=0;i<arr.size();i++)
{
sum+=abs(arr[i]);
if (arr[i]==0) prods=0;
if (arr[i]<0) prods=-prods;
}
return sum*prods;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 2, -4}) == -9);
assert (func0({0, 1}) == 0);
assert (func0({1, 1, 1, 2, 3, -1, 1}) == -10);
assert (func0({}) == -32768);
assert (func0({2, 4,1, 2, -1, -1, 9}) == 20);
assert (func0({-1, 1, -1, 1}) == 4);
assert (func0({-1, 1... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov 0x8(%rdi),%rax
mov (%rdi),%rdx
mov %rax,%r9
sub %rdx,%r9
mov %r9,%rcx
sar $0x2,%rcx
cmp %rax,%rdx
je 1633 <_Z5func0St6vectorIiSaIiEE+0x73>
test %rcx,%rcx
je 1630 <_Z5func0St6vectorIiSaIiEE+0x70>
add %rdx,%r9
mov $0x1,%eax
xo... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov r8, [rdi]
mov r9, rax
sub r9, r8
sar r9, 2
cmp rax, r8
jz short loc_157A
xor ecx, ecx
mov edi, 1
xor eax, eax
jmp short loc_155A
loc_1548:
mov esi, edi
neg esi
test edx, edx
cmovs edi, esi
add rcx, 1
cm... | long long func0(long long *a1)
{
long long v1; // r8
unsigned long long v2; // r9
unsigned long long v3; // rcx
int v4; // edi
int v5; // eax
int v6; // edx
int v7; // esi
v1 = *a1;
v2 = (a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 4294934528LL;
v3 = 0LL;
v4 = 1;
v5 = 0;
do
{
w... | 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 0x0010157a
XOR ECX,ECX
MOV EDI,0x1
XOR EAX,EAX
JMP 0x0010155a
LAB_00101548:
MOV ESI,EDI
NEG ESI
TEST EDX,EDX
CMOVS EDI,ESI
ADD RCX,0x1
CMP RCX,R9
JNC 0x00101576
LAB_0010155a:
MOV EDX,dword ptr [R8 + RCX*0x4... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
int iVar5;
int iVar6;
int iVar7;
int4 in_register_0000003c;
ulong uVar8;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_re... |
515 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> arr){
if (arr.size()==0) return -32768;
int i,sum=0,prods=1;
for (i=0;i<arr.size();i++)
{
sum+=abs(arr[i]);
if (arr[i]==0) prods=0;
if (arr[i]<0) prods=-prods;
}
return sum*prods;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 2, -4}) == -9);
assert (func0({0, 1}) == 0);
assert (func0({1, 1, 1, 2, 3, -1, 1}) == -10);
assert (func0({}) == -32768);
assert (func0({2, 4,1, 2, -1, -1, 9}) == 20);
assert (func0({-1, 1, -1, 1}) == 4);
assert (func0({-1, 1... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov 0x8(%rdi),%rax
mov (%rdi),%rdx
mov %rax,%r9
sub %rdx,%r9
mov %r9,%rcx
sar $0x2,%rcx
cmp %rax,%rdx
je 15d3 <_Z5func0St6vectorIiSaIiEE+0x73>
test %rcx,%rcx
je 15d0 <_Z5func0St6vectorIiSaIiEE+0x70>
add %rdx,%r9
mov $0x1,%eax
xo... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov r8, [rdi]
mov r9, rax
sub r9, r8
sar r9, 2
cmp rax, r8
jz short loc_157A
xor ecx, ecx
mov edi, 1
xor eax, eax
jmp short loc_155A
loc_1548:
mov esi, edi
neg esi
test edx, edx
cmovs edi, esi
add rcx, 1
cm... | long long func0(long long *a1)
{
long long v1; // r8
unsigned long long v2; // r9
unsigned long long v3; // rcx
int v4; // edi
int v5; // eax
int v6; // edx
int v7; // esi
v1 = *a1;
v2 = (a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 4294934528LL;
v3 = 0LL;
v4 = 1;
v5 = 0;
do
{
w... | 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 0x0010157a
XOR ECX,ECX
MOV EDI,0x1
XOR EAX,EAX
JMP 0x0010155a
LAB_00101548:
MOV ESI,EDI
NEG ESI
TEST EDX,EDX
CMOVS EDI,ESI
ADD RCX,0x1
CMP RCX,R9
JNC 0x00101576
LAB_0010155a:
MOV EDX,dword ptr [R8 + RCX*0x4... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
int iVar5;
int iVar6;
int iVar7;
int4 in_register_0000003c;
ulong uVar8;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_re... |
516 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<vector<int>> grid, int k){
int i,j,x,y,min;
for (i=0;i<grid.size();i++)
for (j=0;j<grid[i].size();j++)
if (grid[i][j]==1) {
x=i;y=j;
}
min=grid.size()*grid.size();
if (x>0 and grid[x-1][y]<min) min=grid[x-1][y];
if (x<grid.size... | #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, 2, 3}, {4, 5, 6}, {7, 8, 9}}, 3) , {1, 2, 1}));
assert (iss... | 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 $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %edx,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
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 [rbp+var_28], 0
jmp short loc_1357
loc_12D9:
mov [rbp+var_... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
long long v4; // rax
int v5; // ebx
long long v6; // rax
long long v8; // rax
long long v9; // rax
long long v11; // rax
long long v12; // rax
long long v14; // rax
long long v15; // rax
long long v17; // rax
int v20; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x44],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x28],0x0
JMP 0x00101357
LAB_001012d9:
MOV dword ptr [RBP + -0x24],0x0
J... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
bool bVar1;
int iVar2;
ulong uVar3;
vector<int,std::allocator<int>> *pvVar4;
int *piVar5;
long lVar6;
i... |
517 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<vector<int>> grid, int k){
int i,j,x,y,min;
for (i=0;i<grid.size();i++)
for (j=0;j<grid[i].size();j++)
if (grid[i][j]==1) {
x=i;y=j;
}
min=grid.size()*grid.size();
if (x>0 and grid[x-1][y]<min) min=grid[x-1][y];
if (x<grid.size... | #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, 2, 3}, {4, 5, 6}, {7, 8, 9}}, 3) , {1, 2, 1}));
assert (iss... | O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %edx,%ebp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rsi),%r9
mov 0x8(... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov ebp, edx
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov rax, [rsi+8]
mov r10, [rsi]
mov r13, rax
sub r13, r10
sar r13, 3
mov rdx, 0AAAA... | long long func0(long long a1, _QWORD *a2, int a3, int a4, int a5)
{
_QWORD *v6; // r10
unsigned long long v7; // r13
_QWORD *v8; // r11
unsigned long long v9; // r9
unsigned long long v10; // rax
unsigned long long v11; // r13
int i; // r12d
_DWORD *v13; // rsi
_DWORD *v14; // rsi
int v16; // [rsp+... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV EBP,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI + 0x8]
MOV R10,qword ptr [RSI]
MOV R13,RAX
SUB R13,R10
SAR R13,0x3
MOV RDX,-0x5555555555555555
IMUL R13,RDX
CMP RAX,R10
JZ 0x00101396
MOV R... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
int iVar1;
long *plVar2;
long lVar3;
int *piVar4;
int4 *puVar5;
ulong uVar6;
int in_ECX;
uint in_EDX;... |
518 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<vector<int>> grid, int k){
int i,j,x,y,min;
for (i=0;i<grid.size();i++)
for (j=0;j<grid[i].size();j++)
if (grid[i][j]==1) {
x=i;y=j;
}
min=grid.size()*grid.size();
if (x>0 and grid[x-1][y]<min) min=grid[x-1][y];
if (x<grid.size... | #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, 2, 3}, {4, 5, 6}, {7, 8, 9}}, 3) , {1, 2, 1}));
assert (iss... | O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
movabs $0xaaaaaaaaaaaaaaab,%rax
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %edx,%ebp
push %rbx
sub $0x28,%rsp
mov (%rsi),%r9
mov 0x8(%rsi... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r13
push r12
push rbp
mov ebp, edx
mov rdx, 0AAAAAAAAAAAAAAABh
push rbx
mov rbx, rdi
sub rsp, 18h
mov r10, [rsi]
mov rax, fs:28h
mov [rsp+38h+var_30], rax
mov rax, [rsi+8]
mov r13, rax
sub r13, r10
sar r13, 3
imu... | long long func0(long long a1, _QWORD *a2, int a3, int a4, int a5)
{
_QWORD *v6; // r10
unsigned long long v7; // r13
_QWORD *v8; // r11
unsigned long long v9; // r9
unsigned long long v10; // rax
unsigned long long v11; // r13
_DWORD *v12; // rsi
_DWORD *v13; // rax
int v14; // r12d
_DWORD *v15; //... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDX
MOV RDX,-0x5555555555555555
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV R10,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV R13,RAX
SUB R13,R10
SAR R13,0x3
IMUL R13,RDX
CMP R10,RAX
JZ 0x00102a51
MOV R11,R10
XOR R... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
int iVar1;
long *plVar2;
long lVar3;
ulong uVar4;
int *piVar5;
int in_ECX;
int in_EDX;
int4 in_regist... |
519 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<vector<int>> grid, int k){
int i,j,x,y,min;
for (i=0;i<grid.size();i++)
for (j=0;j<grid[i].size();j++)
if (grid[i][j]==1) {
x=i;y=j;
}
min=grid.size()*grid.size();
if (x>0 and grid[x-1][y]<min) min=grid[x-1][y];
if (x<grid.size... | #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, 2, 3}, {4, 5, 6}, {7, 8, 9}}, 3) , {1, 2, 1}));
assert (iss... | O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
movabs $0xaaaaaaaaaaaaaaab,%rax
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %edx,%ebp
push %rbx
sub $0x28,%rsp
mov (%rsi),%r11
mov 0x8(%rs... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
mov r8, 0AAAAAAAAAAAAAAABh
push r15
push r14
push r13
push r12
mov r12d, edx
push rbp
push rbx
mov rbx, rdi
sub rsp, 38h
mov rdi, [rsi+8]
mov rsi, [rsi]
mov rdx, fs:28h
mov [rsp+68h+var_40], rdx
xor edx, edx
mov rdx... | long long func0(long long a1, const __m128i ***a2, int a3, int a4)
{
signed int v4; // eax
int v5; // r12d
const __m128i **v7; // rdi
const __m128i **v8; // rsi
unsigned long long v9; // r15
const __m128i **v10; // rbp
unsigned long long v11; // r11
__m128i si128; // xmm7
__m128i v13; // xmm9
const... | func0:
ENDBR64
MOV R8,-0x5555555555555555
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,EDX
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x38
MOV RDI,qword ptr [RSI + 0x8]
MOV RSI,qword ptr [RSI]
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RDX
XOR EDX,EDX
MOV RDX,RDI
SUB RDX,RSI
SAR RDX,0x3
IMUL RDX,R8
MOV R15,RDX
C... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
int iVar1;
long *plVar2;
i... |
520 | 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,3};
if (n==0) return {1};
for (int i=2;i<=n;i++)
{
if (i%2==0) out.push_back(1+i/2);
else out.push_back(out[i-1]+out[i-2]+1+(i+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) , {1, 3, 2, 8}));
assert (issame(func0(4) , {1, 3, 2, 8, 3}))... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x58,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movl $0x1,-0x40(%rbp)
movl $0x3,-0x3c(%rbp)
lea -0x40(%rbp),%rax
mov %rax... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 68h
mov [rbp+var_78], rdi
mov [rbp+var_7C], esi
mov rcx, fs:28h
mov [rbp+var_28], rcx
xor ecx, ecx
mov [rbp+var_30], 1
mov [rbp+var_2C], 3
lea rcx, [rbp+var_30]
mov rax, rcx
mov edx, ... | long long func0(long long a1, int a2)
{
int v2; // ebx
_DWORD *v3; // rax
int v5; // [rsp+18h] [rbp-68h] BYREF
int i; // [rsp+1Ch] [rbp-64h]
int *v7; // [rsp+20h] [rbp-60h]
int *v8; // [rsp+28h] [rbp-58h]
_BYTE v9[32]; // [rsp+30h] [rbp-50h] BYREF
_DWORD v10[2]; // [rsp+50h] [rbp-30h] BYREF
unsigned ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x78],RDI
MOV dword ptr [RBP + -0x7c],ESI
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RCX
XOR ECX,ECX
MOV dword ptr [RBP + -0x30],0x1
MOV dword ptr [RBP + -0x2c],0x3
LEA RCX,[RBP + -0x30]
MOV RAX,RCX
MOV EDX,0x... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int iVar1;
int *piVar2;
int in_ESI;
int4 in_register_0000003c;
long in_FS_OFFSET;
int local_70;
uint local_6c;
int *local_68;
int *local_60;
vector<int,std::allocator<int>> local_58 [32];
int4 local_38;
int4 local_34;
lo... |
521 | 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,3};
if (n==0) return {1};
for (int i=2;i<=n;i++)
{
if (i%2==0) out.push_back(1+i/2);
else out.push_back(out[i-1]+out[i-2]+1+(i+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) , {1, 3, 2, 8}));
assert (issame(func0(4) , {1, 3, 2, 8, 3}))... | O1 | cpp | func0(int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov %rdi,%r13
mov %esi,%r12d
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
mov $0x8,%edi
callq 1100 <_Znwm@plt>
mov %rax,0x10... | _Z5func0i:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 30h
mov r13, rdi
mov r12d, esi
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 edi, 8; unsigned __int64
call ... | _QWORD * func0(_QWORD *a1, int a2)
{
_QWORD *v2; // rbx
long long v3; // rbp
int v4; // ebx
_DWORD *v6; // rax
int v7; // [rsp+Ch] [rbp-4Ch] BYREF
_QWORD *v8; // [rsp+10h] [rbp-48h] BYREF
_QWORD *v9; // [rsp+18h] [rbp-40h]
_QWORD *v10; // [rsp+20h] [rbp-38h]
unsigned long long v11; // [rsp+28h] [rbp-3... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV R13,RDI
MOV R12D,ESI
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 EDI,0x8
LAB_001012c9:
CALL 0x001010f0
MOV RBX,RAX
MOV ... | /* func0(int) */
int8 * func0(int param_1)
{
int8 *puVar1;
int4 *puVar2;
uint uVar3;
long lVar4;
int in_ESI;
int4 in_register_0000003c;
int8 *puVar5;
long in_FS_OFFSET;
int local_4c;
int8 *local_48;
int8 *local_40;
int8 *local_38;
long local_30;
puVar5 = (int8 *)CONCAT44(in_register_000... |
522 | 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,3};
if (n==0) return {1};
for (int i=2;i<=n;i++)
{
if (i%2==0) out.push_back(1+i/2);
else out.push_back(out[i-1]+out[i-2]+1+(i+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) , {1, 3, 2, 8}));
assert (issame(func0(4) , {1, 3, 2, 8, 3}))... | O2 | cpp | func0(int):
endbr64
push %r15
push %r14
push %r13
mov %esi,%r13d
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,0x8(%rsp)
mov $0x8,%edi
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
movq $0x0,0x30(%rsp)
callq 1100 <_Znwm@plt>... | _Z5func0i:
endbr64
push r15
pxor xmm0, xmm0
push r14
mov r14, rdi
mov edi, 8; unsigned __int64
push r13
mov r13d, esi
push r12
push rbp
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
movaps [rsp+68h+var_58], xmm0
mov [rsp+68h+var_48], 0... | long long func0(long long a1, int a2)
{
int *v3; // rax
int *v4; // rsi
int *v5; // r12
int *v6; // rcx
long long v7; // rbp
int v8; // ebx
int v9; // r12d
int v10; // eax
_DWORD *v12; // rax
int v13; // [rsp+4h] [rbp-5Ch] BYREF
int *v14; // [rsp+8h] [rbp-58h] BYREF
int *v15; // [rsp+10h] [rbp-... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
MOV R14,RDI
MOV EDI,0x8
PUSH R13
MOV R13D,ESI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
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
LAB_0010192f:
CALL 0x001010f0
LEA RSI,[RAX + 0x... | /* func0(int) */
int (*) [16] func0(int param_1)
{
bool bVar1;
int8 *puVar2;
int4 *puVar3;
int *piVar4;
uint uVar5;
long lVar6;
int in_ESI;
int4 in_register_0000003c;
int (*pauVar7) [16];
long in_FS_OFFSET;
int local_5c;
int local_58 [16];
int *local_48;
long local_40;
pauVar7 = (int ... |
523 | 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,3};
if (n==0) return {1};
for (int i=2;i<=n;i++)
{
if (i%2==0) out.push_back(1+i/2);
else out.push_back(out[i-1]+out[i-2]+1+(i+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) , {1, 3, 2, 8}));
assert (issame(func0(4) , {1, 3, 2, 8, 3}))... | O3 | cpp | func0(int):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
mov %rdi,%r13
mov $0x8,%edi
push %r12
mov %esi,%r12d
push %rbp
push %rbx
sub $0x30,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movaps %xmm0,0x10(%rsp)
movq $0x0,0x20(%rsp)
callq 1100 <_Znwm@plt>
lea 0x8(%rax),%r... | _Z5func0i:
endbr64
push r15
push r14
mov r14, rdi
mov edi, 8; unsigned __int64
push r13
mov r13d, esi
push r12
push rbp
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
call __Znwm; operator new(ulong)
lea rsi, [rax+8]
mov r12, rax
mov... | long long func0(long long a1, int a2)
{
int *v3; // rax
int *v4; // rsi
int *v5; // r12
int *v6; // rcx
long long v7; // rbp
int v8; // ebx
int v9; // r12d
int v10; // eax
_DWORD *v12; // rax
int v13; // [rsp+Ch] [rbp-5Ch] BYREF
int *v14; // [rsp+10h] [rbp-58h] BYREF
int *v15; // [rsp+18h] [rbp... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
MOV EDI,0x8
PUSH R13
MOV R13D,ESI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
LAB_00101add:
CALL 0x001010f0
LEA RSI,[RAX + 0x8]
MOV R12,RAX
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,0x300000001
MOV qword ptr [RS... | /* func0(int) */
int (*) [16] func0(int param_1)
{
bool bVar1;
int8 *puVar2;
int4 *puVar3;
int *piVar4;
uint uVar5;
long lVar6;
int in_ESI;
int4 in_register_0000003c;
int (*pauVar7) [16];
long in_FS_OFFSET;
int local_5c;
int8 *local_58;
int *local_50;
int *local_48;
long local_40;
p... |
524 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(int n){
int prod=1,has=0;
string s=to_string(n);
for (int i=0;i<s.length();i++)
if (s[i]%2==1)
{
has=1;
prod=prod*(s[i]-48);
}
if (has==0) return 0;
return prod;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 5);
assert (func0(54) == 5);
assert (func0(120) ==1);
assert (func0(5014) == 5);
assert (func0(98765) == 315);
assert (func0(5576543) == 2625);
assert (func0(2468) == 0);
assert (func0(1) == 1);
assert (func0(4) == 0);... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %edi,-0x54(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x1,-0x4c(%rbp)
movl $0x0,-0x48(%rbp)
lea -0x40(%rbp),%rax
mov -0x54(%rbp),%edx
mov %edx,%esi
mov %rax,%rdi
callq 26e4 <_ZNSt7__cxx1... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_54], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_4C], 1
mov [rbp+var_48], 0
lea rax, [rbp+var_40]
mov edx, [rbp+var_54]
mov esi, edx; int
mov rdi, rax; this
call _... | long long func0(int a1)
{
unsigned int v1; // ebx
int v3; // [rsp+14h] [rbp-4Ch]
int v4; // [rsp+18h] [rbp-48h]
int i; // [rsp+1Ch] [rbp-44h]
_BYTE v6[40]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v7; // [rsp+48h] [rbp-18h]
v7 = __readfsqword(0x28u);
v3 = 1;
v4 = 0;
std::to_string((std::__c... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RBP + -0x54],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x4c],0x1
MOV dword ptr [RBP + -0x48],0x0
LEA RAX,[RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x54]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x001015b1
... | /* func0(int) */
int func0(int param_1)
{
bool bVar1;
char *pcVar2;
ulong uVar3;
long in_FS_OFFSET;
int local_54;
int local_4c;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_54 = 1;
bVar1 = false;
std::to_string((int)local_48);
for (local_4c = 0; uV... |
525 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(int n){
int prod=1,has=0;
string s=to_string(n);
for (int i=0;i<s.length();i++)
if (s[i]%2==1)
{
has=1;
prod=prod*(s[i]-48);
}
if (has==0) return 0;
return prod;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 5);
assert (func0(54) == 5);
assert (func0(120) ==1);
assert (func0(5014) == 5);
assert (func0(98765) == 315);
assert (func0(5576543) == 2625);
assert (func0(2468) == 0);
assert (func0(1) == 1);
assert (func0(4) == 0);... | O1 | cpp | func0(int):
endbr64
push %rbx
sub $0x30,%rsp
mov %edi,%r8d
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %rsp,%rdi
lea 0xe15(%rip),%rcx
mov $0x10,%edx
mov 0x2ddd(%rip),%rsi
callq 1496 <_ZN9__gnu_cxx12__to_xstringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcEET_PFiPT0_mPK... | _Z5func0i:
endbr64
push r12
push rbp
push rbx
sub rsp, 100h
mov rax, fs:28h
mov [rsp+118h+var_20], rax
xor eax, eax
mov r12d, edi
shr r12d, 1Fh
mov ebp, edi
neg ebp
cmovs ebp, edi
cmp ebp, 9
jbe loc_1721
cmp ebp, 63h ; 'c'
jbe short loc_1248
cmp ebp, 3E7h
j... | long long func0(int a1)
{
unsigned int v1; // r12d
unsigned int v2; // ebp
unsigned int v3; // eax
unsigned int v4; // ebx
unsigned int v5; // edx
char *v6; // r12
int v7; // ebp
char v8; // bp
char *v9; // rcx
int v10; // r8d
unsigned int v11; // ebx
unsigned int v12; // eax
unsigned int v13... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x100
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
MOV R12D,EDI
SHR R12D,0x1f
MOV EBP,EDI
NEG EBP
CMOVS EBP,EDI
CMP EBP,0x9
JBE 0x00101721
CMP EBP,0x63
JBE 0x00101248
CMP EBP,0x3e7
JBE 0x0010146e
CMP EBP,0x270f
JBE 0x001016a0
MOV EAX,EBP
MOV EB... | /* func0(int) */
int func0(int param_1)
{
uint uVar1;
long *plVar2;
uint uVar3;
ulong uVar4;
uint uVar5;
int iVar6;
char cVar7;
ulong uVar8;
bool bVar9;
uint uVar10;
char *pcVar11;
long in_FS_OFFSET;
long *local_118;
long local_110;
long local_108 [2];
char local_f8 [216];
long local... |
526 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(int n){
int prod=1,has=0;
string s=to_string(n);
for (int i=0;i<s.length();i++)
if (s[i]%2==1)
{
has=1;
prod=prod*(s[i]-48);
}
if (has==0) return 0;
return prod;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 5);
assert (func0(54) == 5);
assert (func0(120) ==1);
assert (func0(5014) == 5);
assert (func0(98765) == 315);
assert (func0(5576543) == 2625);
assert (func0(2468) == 0);
assert (func0(1) == 1);
assert (func0(4) == 0);... | O2 | cpp | func0(int):
endbr64
push %r12
mov %edi,%r8d
mov $0x10,%edx
lea 0xc1f(%rip),%rcx
sub $0x30,%rsp
mov 0x2be8(%rip),%rsi
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %rsp,%rdi
callq 14a0 <_ZN9__gnu_cxx12__to_xstringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcEET_PFiPT0_mPK... | _Z5func0i:
endbr64
push r14
mov ecx, edi
push r13
shr ecx, 1Fh
push r12
movzx r14d, cl
push rbp
mov ebp, edi
push rbx
sub rsp, 100h
mov rax, fs:28h
mov [rsp+128h+var_30], rax
xor eax, eax
neg ebp
cmovs ebp, edi
mov edi, ecx
cmp ebp, 9
jbe loc_178E
cmp e... | long long func0(int a1)
{
unsigned int v1; // ecx
_BOOL8 v2; // r14
unsigned int v3; // ebp
unsigned int v4; // ebx
int v5; // esi
unsigned int v6; // r12d
long long v7; // rsi
__int8 *v8; // rcx
unsigned int v9; // eax
unsigned int v10; // esi
long long v11; // rax
long long v12; // rdi
long... | func0:
ENDBR64
PUSH R14
MOV ECX,EDI
PUSH R13
SHR ECX,0x1f
PUSH R12
MOVZX R14D,CL
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x100
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
NEG EBP
CMOVS EBP,EDI
MOV EDI,ECX
CMP EBP,0x9
JBE 0x0010178e
CMP EBP,0x63
JBE 0x0010163a
CMP EBP,0x3e7
JBE 0x001017c5
CMP EB... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
uint uVar1;
ulong uVar2;
bool bVar3;
uint uVar4;
char *pcVar5;
long *plVar6;
uint uVar7;
int iVar8;
char cVar9;
ulong uVar10;
char cVar11;
uint uVar12;
long in_FS_OF... |
527 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(int n){
int prod=1,has=0;
string s=to_string(n);
for (int i=0;i<s.length();i++)
if (s[i]%2==1)
{
has=1;
prod=prod*(s[i]-48);
}
if (has==0) return 0;
return prod;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 5);
assert (func0(54) == 5);
assert (func0(120) ==1);
assert (func0(5014) == 5);
assert (func0(98765) == 315);
assert (func0(5576543) == 2625);
assert (func0(2468) == 0);
assert (func0(1) == 1);
assert (func0(4) == 0);... | O3 | cpp | func0(int):
endbr64
push %r12
mov %edi,%r8d
mov $0x10,%edx
lea 0xa7f(%rip),%rcx
sub $0x30,%rsp
mov 0x2a48(%rip),%rsi
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %rsp,%rdi
callq 13b0 <_ZN9__gnu_cxx12__to_xstringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcEET_PFiPT0_mPK... | _Z5func0i:
endbr64
push r14
mov ecx, edi
push r13
shr ecx, 1Fh
push r12
movzx r14d, cl
push rbp
mov ebp, edi
push rbx
sub rsp, 100h
mov rax, fs:28h
mov [rsp+128h+var_30], rax
xor eax, eax
neg ebp
cmovs ebp, edi
mov edi, ecx
cmp ebp, 9
jbe loc_178E
cmp e... | long long func0(int a1)
{
unsigned int v1; // ecx
_BOOL8 v2; // r14
unsigned int v3; // ebp
unsigned int v4; // ebx
int v5; // esi
unsigned int v6; // r12d
long long v7; // rsi
__int8 *v8; // rcx
unsigned int v9; // eax
unsigned int v10; // esi
long long v11; // rax
long long v12; // rdi
long... | func0:
ENDBR64
PUSH R14
MOV ECX,EDI
PUSH R13
SHR ECX,0x1f
PUSH R12
MOVZX R14D,CL
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x100
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
NEG EBP
CMOVS EBP,EDI
MOV EDI,ECX
CMP EBP,0x9
JBE 0x0010178e
CMP EBP,0x63
JBE 0x0010163a
CMP EBP,0x3e7
JBE 0x001017c5
CMP EB... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
uint uVar1;
ulong uVar2;
bool bVar3;
uint uVar4;
char *pcVar5;
long *plVar6;
uint uVar7;
int iVar8;
char cVar9;
ulong uVar10;
char cVar11;
uint uVar12;
long in_FS_OF... |
528 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string str){
int count=0,maxcount=0;
for (int i=0;i<str.length();i++)
{
if (str[i]=='[') count+=1;
if (str[i]==']') count-=1;
if (count<0) count=0;
if (count>maxcount) maxcount=count;
if (count<=maxcount-2) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("[[]]") == true);
assert (func0("[]]]]]]][[[[[]") == false);
assert (func0("[][]") == false);
assert (func0(("[]")) == false);
assert (func0("[[[[]]]]") == true);
assert (func0("[]]]]]]]]]]") == false);
assert (func0("[][][[]]") == ... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_13EC
loc_1371:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+... | long long func0(long long a1)
{
int v2; // [rsp+14h] [rbp-1Ch]
int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = 0;
v3 = 0;
for ( i = 0; i < (unsigned long long)std::string::length(a1); ++i )
{
if ( *(_BYTE *)std::string::operator[](a1, i) == 91 )
++v2;
if ( *(_BYTE *)std::... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001013ec
LAB_00101371:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CA... | /* func0(std::string) */
int8 func0(ulong param_1)
{
char *pcVar1;
ulong uVar2;
int local_24;
int local_20;
int local_1c;
local_24 = 0;
local_20 = 0;
local_1c = 0;
while( true ) {
uVar2 = std::string::length();
if (uVar2 <= (ulong)(long)local_1c) {
return 0;
}
pcVar1 = (char... |
529 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string str){
int count=0,maxcount=0;
for (int i=0;i<str.length();i++)
{
if (str[i]=='[') count+=1;
if (str[i]==']') count-=1;
if (count<0) count=0;
if (count>maxcount) maxcount=count;
if (count<=maxcount-2) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("[[]]") == true);
assert (func0("[]]]]]]][[[[[]") == false);
assert (func0("[][]") == false);
assert (func0(("[]")) == false);
assert (func0("[[[[]]]]") == true);
assert (func0("[]]]]]]]]]]") == false);
assert (func0("[][][[]]") == ... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov %rdi,%rax
mov 0x8(%rdi),%rdi
test %rdi,%rdi
je 124e <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x65>
mov (%rax),%rcx
add %rcx,%rdi
mov $0x0,%edx
mov $0x0,%eax
mov $0x0,%r8d
j... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
test rax, rax
jz short loc_126A
mov rcx, [rdi]
lea rdi, [rcx+rax]
mov edx, 0
mov eax, 0
jmp short loc_124B
loc_1229:
add eax, 1
loc_122C:
test eax, eax
mov esi, 0
cmovs eax, esi
cmp ed... | long long func0(long long a1)
{
long long v1; // rax
_BYTE *v2; // rcx
_BYTE *v3; // rdi
int v4; // edx
int v5; // eax
v1 = *(_QWORD *)(a1 + 8);
if ( !v1 )
return 0LL;
v2 = *(_BYTE **)a1;
v3 = (_BYTE *)(*(_QWORD *)a1 + v1);
v4 = 0;
v5 = 0;
while ( 1 )
{
if ( *v2 == 91 )
++v5;
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x0010126a
MOV RCX,qword ptr [RDI]
LEA RDI,[RCX + RAX*0x1]
MOV EDX,0x0
MOV EAX,0x0
JMP 0x0010124b
LAB_00101229:
ADD EAX,0x1
LAB_0010122c:
TEST EAX,EAX
MOV ESI,0x0
CMOVS EAX,ESI
CMP EDX,EAX
CMOVL EDX,EAX
LEA ESI,[RDX + -0x1]
CMP ESI,EAX
JG 0x00101270
ADD RCX,0... | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
int iVar2;
char *pcVar3;
int iVar4;
if (param_1[1] == 0) {
return 0;
}
pcVar3 = (char *)*param_1;
pcVar1 = pcVar3 + param_1[1];
iVar4 = 0;
iVar2 = 0;
while( true ) {
if (*pcVar3 == '[') {
iVar2 = iVar2 + 1;
}... |
530 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string str){
int count=0,maxcount=0;
for (int i=0;i<str.length();i++)
{
if (str[i]=='[') count+=1;
if (str[i]==']') count-=1;
if (count<0) count=0;
if (count>maxcount) maxcount=count;
if (count<=maxcount-2) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("[[]]") == true);
assert (func0("[]]]]]]][[[[[]") == false);
assert (func0("[][]") == false);
assert (func0(("[]")) == false);
assert (func0("[[[[]]]]") == true);
assert (func0("[]]]]]]]]]]") == false);
assert (func0("[][][[]]") == ... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov %rdi,%rax
mov 0x8(%rdi),%rdi
test %rdi,%rdi
je 1cc0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x60>
mov (%rax),%rcx
xor %edx,%edx
xor %eax,%eax
xor %r8d,%r8d
add %rcx,%rdi
j... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
test rax, rax
jz short loc_1708
mov rcx, [rdi]
xor edx, edx
xor r8d, r8d
lea rdi, [rcx+rax]
xor eax, eax
jmp short loc_16E5
loc_16C0:
cmp sil, 5Dh ; ']'
jnz short loc_16D0
sub eax, 1
cm... | long long func0(long long a1)
{
long long v1; // rax
_BYTE *v2; // rcx
int v3; // edx
_BYTE *v4; // rdi
int v5; // eax
v1 = *(_QWORD *)(a1 + 8);
if ( v1 )
{
v2 = *(_BYTE **)a1;
v3 = 0;
v4 = (_BYTE *)(*(_QWORD *)a1 + v1);
v5 = 0;
do
{
if ( *v2 == 91 )
{
if ( ... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x00101708
MOV RCX,qword ptr [RDI]
XOR EDX,EDX
XOR R8D,R8D
LEA RDI,[RCX + RAX*0x1]
XOR EAX,EAX
JMP 0x001016e5
LAB_001016c0:
CMP SIL,0x5d
JNZ 0x001016d0
SUB EAX,0x1
CMP EAX,-0x1
CMOVZ EAX,R8D
LAB_001016d0:
CMP EDX,EAX
CMOVL EDX,EAX
LEA ESI,[RDX + -0x1]
CMP ESI... | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
int iVar2;
char *pcVar3;
int iVar4;
if (param_1[1] != 0) {
pcVar3 = (char *)*param_1;
iVar4 = 0;
pcVar1 = pcVar3 + param_1[1];
iVar2 = 0;
do {
if (*pcVar3 == '[') {
iVar2 = iVar2 + 1;
if (iVar4 < ... |
531 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string str){
int count=0,maxcount=0;
for (int i=0;i<str.length();i++)
{
if (str[i]=='[') count+=1;
if (str[i]==']') count-=1;
if (count<0) count=0;
if (count>maxcount) maxcount=count;
if (count<=maxcount-2) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("[[]]") == true);
assert (func0("[]]]]]]][[[[[]") == false);
assert (func0("[][]") == false);
assert (func0(("[]")) == false);
assert (func0("[[[[]]]]") == true);
assert (func0("[]]]]]]]]]]") == false);
assert (func0("[][][[]]") == ... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov %rdi,%rax
mov 0x8(%rdi),%rdi
test %rdi,%rdi
je 1cc0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x60>
mov (%rax),%rcx
xor %edx,%edx
xor %eax,%eax
xor %r8d,%r8d
add %rcx,%rdi
j... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
test rax, rax
jz short loc_1798
mov rcx, [rdi]
xor edx, edx
xor r8d, r8d
lea rdi, [rcx+rax]
xor eax, eax
jmp short loc_1775
loc_1750:
cmp sil, 5Dh ; ']'
jnz short loc_1760
sub eax, 1
cm... | long long func0(long long a1)
{
long long v1; // rax
_BYTE *v2; // rcx
int v3; // edx
_BYTE *v4; // rdi
int v5; // eax
v1 = *(_QWORD *)(a1 + 8);
if ( v1 )
{
v2 = *(_BYTE **)a1;
v3 = 0;
v4 = (_BYTE *)(*(_QWORD *)a1 + v1);
v5 = 0;
do
{
if ( *v2 == 91 )
{
if ( ... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x00101798
MOV RCX,qword ptr [RDI]
XOR EDX,EDX
XOR R8D,R8D
LEA RDI,[RCX + RAX*0x1]
XOR EAX,EAX
JMP 0x00101775
LAB_00101750:
CMP SIL,0x5d
JNZ 0x00101760
SUB EAX,0x1
CMP EAX,-0x1
CMOVZ EAX,R8D
LAB_00101760:
CMP EDX,EAX
CMOVL EDX,EAX
LEA ESI,[RDX + -0x1]
CMP ESI... | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
int iVar2;
char *pcVar3;
int iVar4;
if (param_1[1] != 0) {
pcVar3 = (char *)*param_1;
iVar4 = 0;
pcVar1 = pcVar3 + param_1[1];
iVar2 = 0;
do {
if (*pcVar3 == '[') {
iVar2 = iVar2 + 1;
if (iVar4 < ... |
532 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<float> lst){
int sum=0;
for (int i=0;i<lst.size();i++)
sum+=ceil(lst[i])*ceil(lst[i]);
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3})==14);
assert (func0({1.0,2,3})==14);
assert (func0({1,3,5,7})==84);
assert (func0({1.4,4.2,0})==29);
assert (func0({-2.4,1,1})==6);
assert (func0({100,1,15,2})==10230);
assert (func0({10000,10000})==200000000);
assert (... | O0 | cpp | func0(std::vector<float, std::allocator<float> >):
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
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1ea8 <_ZNKSt6vectorIfSaIfEE4sizeEv>
cmp ... | _Z5func0St6vectorIfSaIfEE:
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_12D0
loc_126A:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vec... | long long func0(long long a1)
{
float v1; // xmm0_4
float v2; // xmm0_4
float v4; // [rsp+4h] [rbp-2Ch]
int v5; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v5 = 0;
for ( i = 0; i < (unsigned long long)std::vector<float>::size(a1); ++i )
{
v1 = *(float *)std::vector<float>::operator[](a1, ... | 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 0x001012d0
LAB_0010126a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001020f2
MOV EAX,dword ptr ... | /* func0(std::vector<float, std::allocator<float> >) */
int func0(vector param_1)
{
float *pfVar1;
ulong uVar2;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
float fVar3;
float fVar4;
int4 local_20;
int4 local_1c;
this = (vector<float,std::allocator<float>> *)CONCAT44(in_r... |
533 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<float> lst){
int sum=0;
for (int i=0;i<lst.size();i++)
sum+=ceil(lst[i])*ceil(lst[i]);
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3})==14);
assert (func0({1.0,2,3})==14);
assert (func0({1,3,5,7})==84);
assert (func0({1.4,4.2,0})==29);
assert (func0({-2.4,1,1})==6);
assert (func0({100,1,15,2})==10230);
assert (func0({10000,10000})==200000000);
assert (... | O1 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rsi
sub %rax,%rsi
mov %rsi,%rdi
shr $0x2,%rdi
je 1298 <_Z5func0St6vectorIfSaIfEE+0x8f>
mov %rax,%rcx
add %rax,%rsi
mov $0x0,%eax
movss 0xf81(%rip),%xmm4
movss 0xf85(%rip),%xmm3
movss 0xf75(%rip),%xmm... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rax, [rdi+8]
mov rcx, [rdi]
mov rsi, rax
sub rsi, rcx
sar rsi, 2
cmp rax, rcx
jz short loc_129A
mov eax, 0
mov edx, 0
movss xmm4, cs:dword_2004
movss xmm3, cs:dword_200C
movss xmm5, cs:dword_2008
jmp short loc_1264
loc_1247:
pxor x... | long long func0(long long *a1)
{
long long v1; // rcx
unsigned long long v2; // rax
int v3; // edx
__m128 v4; // xmm2
float v5; // xmm0_4
__m128 v6; // xmm1
v1 = *a1;
if ( a1[1] == *a1 )
{
return 0;
}
else
{
v2 = 0LL;
v3 = 0;
do
{
v4 = (__m128)*(unsigned int *)(v1 + 4... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RSI,RAX
SUB RSI,RCX
SAR RSI,0x2
CMP RAX,RCX
JZ 0x0010129a
MOV EAX,0x0
MOV EDX,0x0
MOVSS XMM4,dword ptr [0x00102004]
MOVSS XMM3,dword ptr [0x0010200c]
MOVSS XMM5,dword ptr [0x00102008]
JMP 0x00101264
LAB_00101247:
PXOR XMM1,XMM1
CVTSI2SS XMM1,EDX
M... | /* func0(std::vector<float, std::allocator<float> >) */
int func0(vector param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
int iVar4;
int4 in_register_0000003c;
float fVar5;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
if (l... |
534 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<float> lst){
int sum=0;
for (int i=0;i<lst.size();i++)
sum+=ceil(lst[i])*ceil(lst[i]);
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3})==14);
assert (func0({1.0,2,3})==14);
assert (func0({1,3,5,7})==84);
assert (func0({1.4,4.2,0})==29);
assert (func0({-2.4,1,1})==6);
assert (func0({100,1,15,2})==10230);
assert (func0({10000,10000})==200000000);
assert (... | O2 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rsi
sub %rcx,%rsi
mov %rsi,%rax
shr $0x2,%rax
je 1840 <_Z5func0St6vectorIfSaIfEE+0x90>
movss 0x9e5(%rip),%xmm4
movss 0x9e9(%rip),%xmm3
add %rcx,%rsi
xor %eax,%eax
movss 0x9d4(%rip),%xmm5
nopl 0x0(%rax... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rax, [rdi+8]
mov rcx, [rdi]
mov rsi, rax
sub rsi, rcx
sar rsi, 2
cmp rax, rcx
jz loc_17A0
movss xmm4, cs:dword_2004
movss xmm3, cs:dword_2008
xor eax, eax
xor edx, edx
movss xmm5, dword ptr cs:xmmword_21E0
nop word ptr [rax+rax+00h]
l... | long long func0(long long *a1)
{
long long v1; // rcx
unsigned long long v2; // rax
int v3; // edx
__m128 v4; // xmm0
__m128 v5; // xmm1
v1 = *a1;
if ( a1[1] == *a1 )
return 0LL;
v2 = 0LL;
v3 = 0;
do
{
v4 = (__m128)*(unsigned int *)(v1 + 4 * v2);
if ( fabs(*(float *)(v1 + 4 * v2)) < ... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RSI,RAX
SUB RSI,RCX
SAR RSI,0x2
CMP RAX,RCX
JZ 0x001017a0
MOVSS XMM4,dword ptr [0x00102004]
MOVSS XMM3,dword ptr [0x00102008]
XOR EAX,EAX
XOR EDX,EDX
MOVSS XMM5,dword ptr [0x001021e0]
NOP word ptr [RAX + RAX*0x1]
LAB_00101740:
MOVSS XMM0,dword ptr... | /* func0(std::vector<float, std::allocator<float> >) */
int func0(vector param_1)
{
float fVar1;
long lVar2;
long lVar3;
ulong uVar4;
int iVar5;
int4 in_register_0000003c;
lVar2 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
if (l... |
535 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<float> lst){
int sum=0;
for (int i=0;i<lst.size();i++)
sum+=ceil(lst[i])*ceil(lst[i]);
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3})==14);
assert (func0({1.0,2,3})==14);
assert (func0({1,3,5,7})==84);
assert (func0({1.4,4.2,0})==29);
assert (func0({-2.4,1,1})==6);
assert (func0({100,1,15,2})==10230);
assert (func0({10000,10000})==200000000);
assert (... | O3 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rsi
sub %rcx,%rsi
mov %rsi,%rax
shr $0x2,%rax
je 1880 <_Z5func0St6vectorIfSaIfEE+0x90>
movss 0x9a9(%rip),%xmm4
movss 0x9a9(%rip),%xmm3
add %rcx,%rsi
xor %eax,%eax
movss 0x998(%rip),%xmm5
nopl 0x0(%rax... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rax, [rdi+8]
mov rcx, [rdi]
mov rsi, rax
sub rsi, rcx
sar rsi, 2
cmp rax, rcx
jz loc_1840
movss xmm4, cs:dword_2004
movss xmm3, cs:dword_2008
xor eax, eax
xor edx, edx
movss xmm5, dword ptr cs:xmmword_21E0
nop word ptr [rax+rax+00h]
l... | long long func0(long long *a1)
{
long long v1; // rcx
unsigned long long v2; // rax
int v3; // edx
__m128 v4; // xmm0
__m128 v5; // xmm1
v1 = *a1;
if ( a1[1] == *a1 )
return 0LL;
v2 = 0LL;
v3 = 0;
do
{
v4 = (__m128)*(unsigned int *)(v1 + 4 * v2);
if ( fabs(*(float *)(v1 + 4 * v2)) < ... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RSI,RAX
SUB RSI,RCX
SAR RSI,0x2
CMP RAX,RCX
JZ 0x00101840
MOVSS XMM4,dword ptr [0x00102004]
MOVSS XMM3,dword ptr [0x00102008]
XOR EAX,EAX
XOR EDX,EDX
MOVSS XMM5,dword ptr [0x001021e0]
NOP word ptr [RAX + RAX*0x1]
LAB_001017e0:
MOVSS XMM0,dword ptr... | /* func0(std::vector<float, std::allocator<float> >) */
int func0(vector param_1)
{
float fVar1;
long lVar2;
long lVar3;
ulong uVar4;
int iVar5;
int4 in_register_0000003c;
lVar2 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
if (l... |
536 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string txt){
if (txt.length()==0) return false;
char chr=txt[txt.length()-1];
if (chr<65 or (chr>90 and chr<97) or chr>122) return false;
if (txt.length()==1) return true;
chr=txt[txt.length()-2];
if ((chr>=65 and chr<=90) or (chr>=97 and chr<=122)) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("apple") == false);
assert (func0("apple pi e") == true);
assert (func0("eeeee") == false);
assert (func0("A") == true);
assert (func0("Pumpkin pie ") == false);
assert (func0("Pumpkin pie 1") == false);
assert (func0("") == false);... | 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 1290 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv@plt>
test %rax,%rax
sete %al
te... | _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_traitsIcESaIcEE6lengthEv; std::string::length(void)
test rax, rax
setz al
test ... | _BOOL8 func0(long long a1)
{
long long v2; // rax
long long v3; // rax
char v4; // [rsp+1Fh] [rbp-1h]
char v5; // [rsp+1Fh] [rbp-1h]
if ( !std::string::length(a1) )
return 0LL;
v2 = std::string::length(a1);
v4 = *(_BYTE *)std::string::operator[](a1, v2 - 1);
if ( v4 <= 64 || v4 > 90 && v4 <= 96 ||... | 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 0x00101210
TEST RAX,RAX
SETZ AL
TEST AL,AL
JZ 0x00101379
MOV EAX,0x0
JMP 0x00101424
LAB_00101379:
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101210
LEA RDX,[RAX + -0x1]
MOV RAX,qwo... | /* func0(std::string) */
int8 func0(ulong param_1)
{
char cVar1;
long lVar2;
int8 uVar3;
char *pcVar4;
lVar2 = std::string::length();
if (lVar2 == 0) {
uVar3 = 0;
}
else {
std::string::length();
pcVar4 = (char *)std::string::operator[](param_1);
cVar1 = *pcVar4;
if ((cVar1 < 'A'... |
537 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string txt){
if (txt.length()==0) return false;
char chr=txt[txt.length()-1];
if (chr<65 or (chr>90 and chr<97) or chr>122) return false;
if (txt.length()==1) return true;
chr=txt[txt.length()-2];
if ((chr>=65 and chr<=90) or (chr>=97 and chr<=122)) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("apple") == false);
assert (func0("apple pi e") == true);
assert (func0("eeeee") == false);
assert (func0("A") == true);
assert (func0("Pumpkin pie ") == false);
assert (func0("Pumpkin pie 1") == false);
assert (func0("") == false);... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
mov $0x0,%edx
test %rax,%rax
je 1236 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4d>
mov (%rdi),%rcx
movzbl -0x1(%rcx,%rax,1),%edx
lea -0x5b(%rdx),%esi
cmp $0x5,%si... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
mov edx, 0
test rax, rax
jz short loc_1256
mov rcx, [rdi]
movzx edx, byte ptr [rcx+rax-1]
lea esi, [rdx-5Bh]
cmp sil, 5
jbe short loc_1251
sub edx, 41h ; 'A'
cmp dl, 39h ; '9'
ja short l... | long long func0(_QWORD *a1)
{
long long v1; // rax
unsigned int v2; // edx
char v3; // dl
v1 = a1[1];
v2 = 0;
if ( v1 )
{
v3 = *(_BYTE *)(*a1 + v1 - 1);
if ( (unsigned __int8)(v3 - 91) <= 5u || (unsigned __int8)(v3 - 65) > 0x39u )
{
return 0;
}
else
{
v2 = 1;
if... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV EDX,0x0
TEST RAX,RAX
JZ 0x00101256
MOV RCX,qword ptr [RDI]
MOVZX EDX,byte ptr [RCX + RAX*0x1 + -0x1]
LEA ESI,[RDX + -0x5b]
CMP SIL,0x5
JBE 0x00101251
SUB EDX,0x41
CMP DL,0x39
JA 0x00101251
MOV EDX,0x1
CMP RAX,0x1
JZ 0x00101256
MOVZX EAX,byte ptr [RCX + RAX*0x1 + -0x2]
AN... | /* func0(std::string) */
bool func0(long *param_1)
{
char cVar1;
long lVar2;
bool bVar3;
lVar2 = param_1[1];
bVar3 = false;
if (lVar2 != 0) {
cVar1 = *(char *)(*param_1 + -1 + lVar2);
if (((byte)(cVar1 + 0xa5U) < 6) || (0x39 < (byte)(cVar1 + 0xbfU))) {
bVar3 = false;
}
else {
... |
538 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string txt){
if (txt.length()==0) return false;
char chr=txt[txt.length()-1];
if (chr<65 or (chr>90 and chr<97) or chr>122) return false;
if (txt.length()==1) return true;
chr=txt[txt.length()-2];
if ((chr>=65 and chr<=90) or (chr>=97 and chr<=122)) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("apple") == false);
assert (func0("apple pi e") == true);
assert (func0("eeeee") == false);
assert (func0("A") == true);
assert (func0("Pumpkin pie ") == false);
assert (func0("Pumpkin pie 1") == false);
assert (func0("") == false);... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
xor %r8d,%r8d
test %rax,%rax
je 15c6 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x46>
mov (%rdi),%rcx
movzbl -0x1(%rcx,%rax,1),%edx
lea -0x5b(%rdx),%esi
cmp $0x5,%si... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
xor edx, edx
test rax, rax
jz short loc_1553
mov rcx, [rdi]
movzx edx, byte ptr [rcx+rax-1]
lea esi, [rdx-5Bh]
cmp sil, 5
jbe short loc_1560
sub edx, 41h ; 'A'
cmp dl, 39h ; '9'
ja short... | long long func0(_QWORD *a1)
{
long long v1; // rax
unsigned int v2; // edx
char v3; // dl
v1 = a1[1];
v2 = 0;
if ( !v1 )
return v2;
v3 = *(_BYTE *)(*a1 + v1 - 1);
if ( (unsigned __int8)(v3 - 91) > 5u && (unsigned __int8)(v3 - 65) <= 0x39u )
{
v2 = 1;
if ( v1 != 1 )
LOBYTE(v2) = (un... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
XOR EDX,EDX
TEST RAX,RAX
JZ 0x00101553
MOV RCX,qword ptr [RDI]
MOVZX EDX,byte ptr [RCX + RAX*0x1 + -0x1]
LEA ESI,[RDX + -0x5b]
CMP SIL,0x5
JBE 0x00101560
SUB EDX,0x41
CMP DL,0x39
JA 0x00101560
MOV EDX,0x1
CMP RAX,0x1
JZ 0x00101553
MOVZX EAX,byte ptr [RCX + RAX*0x1 + -0x2]
AN... | /* func0(std::string) */
bool func0(long *param_1)
{
char cVar1;
long lVar2;
bool bVar3;
lVar2 = param_1[1];
bVar3 = false;
if (lVar2 != 0) {
cVar1 = *(char *)(*param_1 + -1 + lVar2);
if (((byte)(cVar1 + 0xa5U) < 6) || (0x39 < (byte)(cVar1 + 0xbfU))) {
return false;
}
bVar3 = true... |
539 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string txt){
if (txt.length()==0) return false;
char chr=txt[txt.length()-1];
if (chr<65 or (chr>90 and chr<97) or chr>122) return false;
if (txt.length()==1) return true;
chr=txt[txt.length()-2];
if ((chr>=65 and chr<=90) or (chr>=97 and chr<=122)) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("apple") == false);
assert (func0("apple pi e") == true);
assert (func0("eeeee") == false);
assert (func0("A") == true);
assert (func0("Pumpkin pie ") == false);
assert (func0("Pumpkin pie 1") == false);
assert (func0("") == false);... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
xor %r8d,%r8d
test %rax,%rax
je 1656 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x46>
mov (%rdi),%rcx
movzbl -0x1(%rcx,%rax,1),%edx
lea -0x5b(%rdx),%esi
cmp $0x5,%si... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
xor edx, edx
test rax, rax
jz short loc_1603
mov rcx, [rdi]
movzx edx, byte ptr [rcx+rax-1]
lea esi, [rdx-5Bh]
cmp sil, 5
jbe short loc_1610
sub edx, 41h ; 'A'
cmp dl, 39h ; '9'
ja short... | long long func0(_QWORD *a1)
{
long long v1; // rax
unsigned int v2; // edx
char v3; // dl
v1 = a1[1];
v2 = 0;
if ( !v1 )
return v2;
v3 = *(_BYTE *)(*a1 + v1 - 1);
if ( (unsigned __int8)(v3 - 91) > 5u && (unsigned __int8)(v3 - 65) <= 0x39u )
{
v2 = 1;
if ( v1 != 1 )
LOBYTE(v2) = (un... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
XOR EDX,EDX
TEST RAX,RAX
JZ 0x00101603
MOV RCX,qword ptr [RDI]
MOVZX EDX,byte ptr [RCX + RAX*0x1 + -0x1]
LEA ESI,[RDX + -0x5b]
CMP SIL,0x5
JBE 0x00101610
SUB EDX,0x41
CMP DL,0x39
JA 0x00101610
MOV EDX,0x1
CMP RAX,0x1
JZ 0x00101603
MOVZX EAX,byte ptr [RCX + RAX*0x1 + -0x2]
AN... | /* func0(std::string) */
bool func0(long *param_1)
{
char cVar1;
long lVar2;
bool bVar3;
lVar2 = param_1[1];
bVar3 = false;
if (lVar2 != 0) {
cVar1 = *(char *)(*param_1 + -1 + lVar2);
if (((byte)(cVar1 + 0xa5U) < 6) || (0x39 < (byte)(cVar1 + 0xbfU))) {
return false;
}
bVar3 = true... |
540 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> arr){
int max=-1;
for (int i=0;i<arr.size();i++)
if (arr[i]<=i) max=i;
return max;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,4,3,5})==3);
assert (func0({1,2,4,5})==-1);
assert (func0({1,4,2,5,6,7,8,9,10})==2);
assert (func0({4,8,5,7,3})==4);
assert (func0({})==-1);
assert (func0({1,2,3})==-1);
}
| 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 $0xffffffff,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 183e <_ZNKSt6vectorIiSaIiEE4sizeEv>
cm... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_18], 0FFFFFFFFh
mov [rbp+var_14], 0
jmp short loc_1295
loc_126A:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call ... | long long func0(long long a1)
{
unsigned int v2; // [rsp+18h] [rbp-18h]
signed int i; // [rsp+1Ch] [rbp-14h]
v2 = -1;
for ( i = 0; i < (unsigned long long)std::vector<int>::size(a1); ++i )
{
if ( i >= *(_DWORD *)std::vector<int>::operator[](a1, i) )
v2 = i;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0xffffffff
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101295
LAB_0010126a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018dc
MOV EAX,dwo... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int *piVar1;
ulong uVar2;
int4 in_register_0000003c;
int4 local_20;
int4 local_1c;
local_20 = -1;
local_1c = 0;
while( true ) {
uVar2 = std::vector<int,std::allocator<int>>::size
((vector<int,s... |
541 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> arr){
int max=-1;
for (int i=0;i<arr.size();i++)
if (arr[i]<=i) max=i;
return max;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,4,3,5})==3);
assert (func0({1,2,4,5})==-1);
assert (func0({1,4,2,5,6,7,8,9,10})==2);
assert (func0({4,8,5,7,3})==4);
assert (func0({})==-1);
assert (func0({1,2,3})==-1);
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rax
sub %rcx,%rax
sar $0x2,%rax
mov %rax,%rsi
je 123c <_Z5func0St6vectorIiSaIiEE+0x33>
mov $0x0,%eax
mov $0xffffffff,%edx
cmp %eax,(%rcx,%rax,4)
cmovle %eax,%edx
add $0x1,%rax
cmp %rsi,%rax
jne 122... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rcx, [rdi]
mov rsi, rax
sub rsi, rcx
sar rsi, 2
cmp rax, rcx
jz short loc_123F
mov eax, 0
mov edx, 0FFFFFFFFh
loc_122D:
cmp [rcx+rax*4], eax
cmovle edx, eax
add rax, 1
cmp rax, rsi
jb short loc_122D
loc_123C:
... | long long func0(_QWORD *a1)
{
unsigned long long v1; // rax
unsigned int v2; // edx
if ( a1[1] == *a1 )
{
return (unsigned int)-1;
}
else
{
v1 = 0LL;
v2 = -1;
do
{
if ( *(_DWORD *)(*a1 + 4 * v1) <= (int)v1 )
v2 = v1;
++v1;
}
while ( v1 < (long long)(a1[1] ... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RSI,RAX
SUB RSI,RCX
SAR RSI,0x2
CMP RAX,RCX
JZ 0x0010123f
MOV EAX,0x0
MOV EDX,0xffffffff
LAB_0010122d:
CMP dword ptr [RCX + RAX*0x4],EAX
CMOVLE EDX,EAX
ADD RAX,0x1
CMP RAX,RSI
JC 0x0010122d
LAB_0010123c:
MOV EAX,EDX
RET
LAB_0010123f:
MOV EDX,0xfff... | /* func0(std::vector<int, std::allocator<int> >) */
ulong func0(vector param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int4 in_register_0000003c;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
if (lVar1 == lVar2) ... |
542 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> arr){
int max=-1;
for (int i=0;i<arr.size();i++)
if (arr[i]<=i) max=i;
return max;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,4,3,5})==3);
assert (func0({1,2,4,5})==-1);
assert (func0({1,4,2,5,6,7,8,9,10})==2);
assert (func0({4,8,5,7,3})==4);
assert (func0({})==-1);
assert (func0({1,2,3})==-1);
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
je 15a8 <_Z5func0St6vectorIiSaIiEE+0x38>
xor %eax,%eax
mov $0xffffffff,%r8d
nopl 0x0(%rax)
cmp %eax,(%rcx,%rax,4)
cmovle %eax,%r8d
add $0x1,%rax
cmp %rdx,%rax
jne 159... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rcx, [rdi]
mov rsi, rax
sub rsi, rcx
sar rsi, 2
cmp rax, rcx
jz short loc_14B0
xor eax, eax
mov edx, 0FFFFFFFFh
nop dword ptr [rax+00000000h]
loc_1498:
cmp [rcx+rax*4], eax
cmovle edx, eax
add rax, 1
cmp rax, r... | long long func0(_QWORD *a1)
{
unsigned long long v1; // rax
unsigned int v2; // edx
if ( a1[1] == *a1 )
return 0xFFFFFFFFLL;
v1 = 0LL;
v2 = -1;
do
{
if ( *(_DWORD *)(*a1 + 4 * v1) <= (int)v1 )
v2 = v1;
++v1;
}
while ( v1 < (long long)(a1[1] - *a1) >> 2 );
return v2;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RSI,RAX
SUB RSI,RCX
SAR RSI,0x2
CMP RAX,RCX
JZ 0x001014b0
XOR EAX,EAX
MOV EDX,0xffffffff
NOP dword ptr [RAX]
LAB_00101498:
CMP dword ptr [RCX + RAX*0x4],EAX
CMOVLE EDX,EAX
ADD RAX,0x1
CMP RAX,RSI
JC 0x00101498
MOV EAX,EDX
RET
LAB_001014b0:
MOV EDX... | /* func0(std::vector<int, std::allocator<int> >) */
ulong func0(vector param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int4 in_register_0000003c;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
if (lVar1 != lVar2) ... |
543 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> arr){
int max=-1;
for (int i=0;i<arr.size();i++)
if (arr[i]<=i) max=i;
return max;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,4,3,5})==3);
assert (func0({1,2,4,5})==-1);
assert (func0({1,4,2,5,6,7,8,9,10})==2);
assert (func0({4,8,5,7,3})==4);
assert (func0({})==-1);
assert (func0({1,2,3})==-1);
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%rdx
sub %rsi,%rdx
sar $0x2,%rdx
je 1a88 <_Z5func0St6vectorIiSaIiEE+0x108>
lea -0x1(%rdx),%rax
cmp $0x3,%rax
jbe 1a95 <_Z5func0St6vectorIiSaIiEE+0x115>
mov %rdx,%rcx
movdqa 0x74f(%rip),%xmm2
mov %rsi,%rax... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rdx, [rdi+8]
mov rcx, [rdi]
mov rax, rdx
sub rax, rcx
mov rdi, rax
sar rdi, 2
cmp rdx, rcx
jz loc_1AD0
test rax, rax
mov esi, 1
cmovnz rsi, rdi
cmp rax, 0Ch
jbe loc_1AE1
mov rdx, rsi
movdqa xmm2, cs:xmmword_20F0
pcmpeqd xmm1, x... | long long func0(const __m128i **a1)
{
const __m128i *v1; // rdx
const __m128i *v2; // rcx
long long v3; // rax
unsigned long long v4; // rdi
unsigned long long v5; // rsi
__m128i si128; // xmm2
__m128i v7; // xmm1
const __m128i *v8; // rax
__m128i v9; // xmm4
__m128i v10; // xmm0
__m128i v11; // ... | func0:
ENDBR64
MOV RDX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RAX,RDX
SUB RAX,RCX
MOV RDI,RAX
SAR RDI,0x2
CMP RDX,RCX
JZ 0x00101ad0
TEST RAX,RAX
MOV ESI,0x1
CMOVNZ RSI,RDI
CMP RAX,0xc
JBE 0x00101ae1
MOV RDX,RSI
MOVDQA XMM2,xmmword ptr [0x001020f0]
PCMPEQD XMM1,XMM1
MOV RAX,RCX
SHR RDX,0x2
MOVDQA XMM4,xmmword... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >) */
uint func0(vector param_1)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
ulong uVar6;
int *piVar7;
uint uVar8;
uint uVar9;
int4 in_register_00... |
544 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> lst){
int maxneg=0,minpos=0;
for (int i=0;i<lst.size();i++)
{
if (lst[i]<0 and (maxneg==0 or lst[i]>maxneg)) maxneg=lst[i];
if (lst[i]>0 and (minpos==0 or lst[i]<minpos)) minpos=lst[i];
}
return {maxneg,minpos};
}
| #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({2, 4, 1, 3, 5, 7}) , {0, 1}));
assert (issame(func0({2, 4, 1, 3... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movl $0x0,-0x3c(%rbp)
movl $0x0,-0x38(%rbp)
movl $0x0,-0x34(%rbp)
... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov [rbp+var_44], 0
mov [rbp+var_40], 0
mov [rbp+var_3C], 0
jmp loc_135D... | long long func0(long long a1, long long a2)
{
char v5; // [rsp+1Bh] [rbp-45h] BYREF
int v6; // [rsp+1Ch] [rbp-44h]
int v7; // [rsp+20h] [rbp-40h]
int i; // [rsp+24h] [rbp-3Ch]
char *v9; // [rsp+28h] [rbp-38h]
_DWORD v10[2]; // [rsp+30h] [rbp-30h] BYREF
unsigned long long v11; // [rsp+38h] [rbp-28h]
v1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x44],0x0
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x001013... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
bool bVar1;
int *piVar2;
ulong uVar3;
ulong uVar4;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
long in_FS_OFFSET;
__new_allocator<int> local_4d;
int local_4c;
int local_48;
int local_44;
__... |
545 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> lst){
int maxneg=0,minpos=0;
for (int i=0;i<lst.size();i++)
{
if (lst[i]<0 and (maxneg==0 or lst[i]>maxneg)) maxneg=lst[i];
if (lst[i]>0 and (minpos==0 or lst[i]<minpos)) minpos=lst[i];
}
return {maxneg,minpos};
}
| #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({2, 4, 1, 3, 5, 7}) , {0, 1}));
assert (issame(func0({2, 4, 1, 3... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rsi),%rax
mov 0x8(%rsi),%rdi
sub %rax,%rdi
mov %rdi,%rcx
shr $0x2,%rcx
je 1276 <_Z5func0St6vectorIiSaIiEE+0x6d>
mov %r... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov rax, [rsi+8]
mov rdi, [rsi]
mov r8, rax
sub r8, rdi
sar r8, 2
cmp rdi, rax
jz short loc_12CF
mov edx, 0
mov ecx, 0
mov esi, 0
jmp short loc_12C4
loc_1297:
cmp esi, eax
mov ... | long long ** func0(long long **a1, long long *a2)
{
long long v3; // rdi
unsigned long long v4; // r8
unsigned long long v5; // rdx
long long v6; // rcx
int v7; // esi
int v8; // r9d
int v9; // eax
int v10; // r9d
long long v11; // rbp
long long *v12; // rax
v3 = *a2;
v4 = (a2[1] - *a2) >> 2;
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x8]
MOV RDI,qword ptr [RSI]
MOV R8,RAX
SUB R8,RDI
SAR R8,0x2
CMP RDI,RAX
JZ 0x001012cf
MOV EDX,0x0
MOV ECX,0x0
MOV ESI,0x0
JMP 0x001012c4
LAB_00101297:
CMP ESI,EAX
MOV R9D,EAX
CMOVGE R9D,ESI
TEST ESI,ESI
CMOVNZ EAX,R9D
MOV ESI,EAX
JMP 0x... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1)
{
int iVar1;
long lVar2;
int8 *puVar3;
int iVar4;
ulong uVar5;
int iVar6;
long *in_RSI;
int4 in_register_0000003c;
int8 *puVar7;
int iVar8;
bool bVar9;
puVar7 = (int8 *)CONCAT44(in_register_0000003c,param_1);
... |
546 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> lst){
int maxneg=0,minpos=0;
for (int i=0;i<lst.size();i++)
{
if (lst[i]<0 and (maxneg==0 or lst[i]>maxneg)) maxneg=lst[i];
if (lst[i]>0 and (minpos==0 or lst[i]<minpos)) minpos=lst[i];
}
return {maxneg,minpos};
}
| #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({2, 4, 1, 3, 5, 7}) , {0, 1}));
assert (issame(func0({2, 4, 1, 3... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov 0x8(%rsi),%rdi
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rsi),%rax
sub %rax,%rdi
mov %rdi,%rbx
shr $0x2,%rbx
je 2020 <_Z5func0St6vectorIiSaIiEE+0xf... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
mov rax, [rsi+8]
mov rdi, [rsi]
mov r8, rax
sub r8, rdi
sar r8, 2
cmp rdi, rax
jz loc_1C90
xor edx, edx
xor ecx, ecx
xor esi, esi
jmp short loc_1C2C
loc_1C10:
jz short loc_1C23
cm... | long long func0(long long a1, long long *a2)
{
long long v3; // rdi
unsigned long long v4; // r8
unsigned long long v5; // rdx
long long v6; // rcx
int v7; // esi
int v8; // r9d
int v9; // eax
int v10; // r9d
long long v11; // rbp
long long *v12; // rax
_QWORD *v13; // rdx
long long result; // ... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV RAX,qword ptr [RSI + 0x8]
MOV RDI,qword ptr [RSI]
MOV R8,RAX
SUB R8,RDI
SAR R8,0x2
CMP RDI,RAX
JZ 0x00101c90
XOR EDX,EDX
XOR ECX,ECX
XOR ESI,ESI
JMP 0x00101c2c
LAB_00101c10:
JZ 0x00101c23
CMP ECX,EAX
MOV R9D,EAX
CMOVLE R9D,ECX
TEST ECX,ECX
CMOVNZ EAX,R9D
MOV ... | /* func0(std::vector<int, std::allocator<int> >) */
int (*) [16] func0(vector param_1)
{
int iVar1;
long lVar2;
int8 *puVar3;
int iVar4;
ulong uVar5;
int iVar6;
long *in_RSI;
int4 in_register_0000003c;
int (*pauVar7) [16];
ulong uVar8;
int iVar9;
bool bVar10;
pauVar7 = (int (*) [16])CONCA... |
547 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> lst){
int maxneg=0,minpos=0;
for (int i=0;i<lst.size();i++)
{
if (lst[i]<0 and (maxneg==0 or lst[i]>maxneg)) maxneg=lst[i];
if (lst[i]>0 and (minpos==0 or lst[i]<minpos)) minpos=lst[i];
}
return {maxneg,minpos};
}
| #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({2, 4, 1, 3, 5, 7}) , {0, 1}));
assert (issame(func0({2, 4, 1, 3... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov 0x8(%rsi),%rdi
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rsi),%rax
sub %rax,%rdi
mov %rdi,%rbx
shr $0x2,%rbx
je 1f70 <_Z5func0St6vectorIiSaIiEE+0xf... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
mov rax, [rsi+8]
mov rdi, [rsi]
mov r8, rax
sub r8, rdi
sar r8, 2
cmp rdi, rax
jz loc_1E80
xor edx, edx
xor ecx, ecx
xor esi, esi
jmp short loc_1E1C
loc_1E00:
jz short loc_1E13
cm... | long long func0(long long a1, long long *a2)
{
long long v3; // rdi
unsigned long long v4; // r8
unsigned long long v5; // rdx
long long v6; // rcx
int v7; // esi
int v8; // r9d
int v9; // eax
int v10; // r9d
long long v11; // rbp
long long *v12; // rax
_QWORD *v13; // rdx
long long result; // ... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV RAX,qword ptr [RSI + 0x8]
MOV RDI,qword ptr [RSI]
MOV R8,RAX
SUB R8,RDI
SAR R8,0x2
CMP RDI,RAX
JZ 0x00101e80
XOR EDX,EDX
XOR ECX,ECX
XOR ESI,ESI
JMP 0x00101e1c
LAB_00101e00:
JZ 0x00101e13
CMP ECX,EAX
MOV R9D,EAX
CMOVLE R9D,ECX
TEST ECX,ECX
CMOVNZ EAX,R9D
MOV ... | /* func0(std::vector<int, std::allocator<int> >) */
int (*) [16] func0(vector param_1)
{
int iVar1;
long lVar2;
int8 *puVar3;
int iVar4;
ulong uVar5;
int iVar6;
long *in_RSI;
int4 in_register_0000003c;
int (*pauVar7) [16];
ulong uVar8;
int iVar9;
bool bVar10;
pauVar7 = (int (*) [16])CONCA... |
548 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
#include<boost/any.hpp>
using namespace std;
#include<stdlib.h>
| boost::any func0(boost::any a,boost::any b){
double numa,numb;
boost::any out;
if (a.type()==typeid(string))
{
string s;
s=boost::any_cast<string>(a);
if (find(s.begin(),s.end(),',')!=s.end())
for (int i=0;i<s.length();i++)
if (s[i]==',') s=s.subs... | #undef NDEBUG
#include<assert.h>
int main(){
assert (boost::any_cast<int>(func0(1, 2)) == 2);
assert (boost::any_cast<double>(func0(1, 2.5))== 2.5);
assert (boost::any_cast<int>(func0(2, 3)) == 3);
assert (boost::any_cast<int>(func0(5, 6)) == 6);
assert (boost::any_cast<string>(func0(1, string("2,3... | O0 | cpp | func0(boost::any, boost::any):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x118,%rsp
mov %rdi,-0x108(%rbp)
mov %rsi,-0x110(%rbp)
mov %rdx,-0x118(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movq $0x0,-0xf0(%rbp)
mov -0x110(%rbp),%rax
mov %rax,%rdi
callq 4f16 <_ZNK5... | _Z5func0N5boost3anyES0_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 118h
mov [rbp+var_108], rdi
mov [rbp+var_110], rsi
mov [rbp+var_118], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_F0], 0
mov rax, [rbp+var_110]
mov rdi, rax; this
call _Z... | long long func0(long long a1, boost::any *a2, boost::any *a3)
{
long long v3; // rax
long long v4; // rbx
long long v5; // rax
unsigned long long v6; // rbx
const char *v7; // rax
long long v8; // rax
long long v9; // rax
long long v10; // rax
long long v11; // rbx
long long v12; // rax
unsigned ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x118
MOV qword ptr [RBP + -0x108],RDI
MOV qword ptr [RBP + -0x110],RSI
MOV qword ptr [RBP + -0x118],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV qword ptr [RBP + -0xf0],0x0
MOV RAX,qword ptr [RBP + -0x110]
MOV RDI,RAX
CALL 0x001042... | /* func0(boost::any, boost::any) */
any * func0(any param_1,any param_2)
{
code *pcVar1;
char cVar2;
bool bVar3;
__normal_iterator _Var4;
__normal_iterator _Var5;
int iVar6;
type_info *ptVar7;
int4 extraout_var;
ulong uVar8;
char *pcVar9;
int4 extraout_var_00;
any *in_RDX;
ulong uVar10;
in... |
549 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
#include<boost/any.hpp>
using namespace std;
#include<stdlib.h>
| boost::any func0(boost::any a,boost::any b){
double numa,numb;
boost::any out;
if (a.type()==typeid(string))
{
string s;
s=boost::any_cast<string>(a);
if (find(s.begin(),s.end(),',')!=s.end())
for (int i=0;i<s.length();i++)
if (s[i]==',') s=s.subs... | #undef NDEBUG
#include<assert.h>
int main(){
assert (boost::any_cast<int>(func0(1, 2)) == 2);
assert (boost::any_cast<double>(func0(1, 2.5))== 2.5);
assert (boost::any_cast<int>(func0(2, 3)) == 3);
assert (boost::any_cast<int>(func0(5, 6)) == 6);
assert (boost::any_cast<string>(func0(1, string("2,3... | O1 | cpp | func0(boost::any, boost::any):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xd0,%rsp
mov %rdi,%r13
mov %rsi,%rbp
mov %rdx,%r12
mov %fs:0x28,%rax
mov %rax,0xc8(%rsp)
xor %eax,%eax
mov (%rsi),%rdi
lea 0x578e(%rip),%rax
test %rdi,%rdi
je 23ed <_Z5func0N5boost3a... | _Z5func0N5boost3anyES0_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0D8h
mov r14, rdi
mov r12, rsi
mov r13, rdx
mov rax, fs:28h
mov [rsp+108h+var_40], rax
xor eax, eax
mov rdi, [rsi]
lea rax, _ZTIv@CXXABI_1_3
test rdi, rdi
jz shor... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
void *v6; // rax
const char *v7; // rdi
unsigned long long v8; // rbp
char *v9; // rbx
unsigned long long v10; // rbx
unsigned int v11; // edx
unsigned int v12; // eax
unsigned long long v13; // rdx
long long v14; // rax
long long v15; // rcx
lo... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xd8
MOV R14,RDI
MOV R12,RSI
MOV R13,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc8],RAX
XOR EAX,EAX
MOV RDI,qword ptr [RSI]
LEA RAX,[0x106b80]
TEST RDI,RDI
JZ 0x0010242f
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
LAB_00102... | /* func0(boost::any, boost::any) */
int8 * func0(any param_1,any param_2)
{
long *plVar1;
int *puVar2;
ushort uVar3;
char *pcVar4;
char ***pppcVar5;
char ***pppcVar6;
int iVar7;
__normal_iterator _Var8;
int1 *puVar9;
int4 extraout_var;
long *plVar10;
int4 extraout_var_00;
int8 uVar11;
long... |
550 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
#include<boost/any.hpp>
using namespace std;
#include<stdlib.h>
| boost::any func0(boost::any a,boost::any b){
double numa,numb;
boost::any out;
if (a.type()==typeid(string))
{
string s;
s=boost::any_cast<string>(a);
if (find(s.begin(),s.end(),',')!=s.end())
for (int i=0;i<s.length();i++)
if (s[i]==',') s=s.subs... | #undef NDEBUG
#include<assert.h>
int main(){
assert (boost::any_cast<int>(func0(1, 2)) == 2);
assert (boost::any_cast<double>(func0(1, 2.5))== 2.5);
assert (boost::any_cast<int>(func0(2, 3)) == 3);
assert (boost::any_cast<int>(func0(5, 6)) == 6);
assert (boost::any_cast<string>(func0(1, string("2,3... | O2 | cpp | func0(boost::any, boost::any):
endbr64
push %r15
mov %rsi,%r15
push %r14
push %r13
mov %rdx,%r13
push %r12
push %rbp
push %rbx
sub $0xf8,%rsp
mov %rdi,0x10(%rsp)
mov (%rsi),%rdi
mov %fs:0x28,%rax
mov %rax,0xe8(%rsp)
xor %eax,%eax
lea 0x5ab3(%rip),%rax
test %rdi,%rdi
je 30c8 ... | _Z5func0N5boost3anyES0_:
endbr64
push r15
push r14
mov r14, rdx
push r13
push r12
push rbp
push rbx
sub rsp, 0F8h
mov [rsp+128h+var_120], rdi
mov rdi, [rsi]
mov [rsp+128h+var_128], rsi
mov rax, fs:28h
mov [rsp+128h+var_40], rax
xor eax, eax
lea rax, _ZTIv@CXXABI_1_3... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
long long v4; // rdi
void *v5; // rax
const char *v6; // rdi
size_t v7; // rdx
unsigned long long v8; // rcx
const char *v9; // rdi
char *v10; // rsi
unsigned long long v11; // rdx
char *v12; // rax
unsigned long long v13; // rbx
char v14; // al... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDX
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xf8
MOV qword ptr [RSP + 0x8],RDI
MOV RDI,qword ptr [RSI]
MOV qword ptr [RSP],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xe8],RAX
XOR EAX,EAX
LEA RAX,[0x106b80]
TEST RDI,RDI
JZ 0x00102f59
MOV RAX,qword ptr [RDI]
CALL qw... | /* WARNING: Removing unreachable block (ram,0x00102feb) */
/* WARNING: Removing unreachable block (ram,0x00103003) */
/* WARNING: Removing unreachable block (ram,0x00103437) */
/* WARNING: Removing unreachable block (ram,0x0010344f) */
/* func0(boost::any, boost::any) */
int8 * func0(any param_1,any param_2)
{
ulon... |
551 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
#include<boost/any.hpp>
using namespace std;
#include<stdlib.h>
| boost::any func0(boost::any a,boost::any b){
double numa,numb;
boost::any out;
if (a.type()==typeid(string))
{
string s;
s=boost::any_cast<string>(a);
if (find(s.begin(),s.end(),',')!=s.end())
for (int i=0;i<s.length();i++)
if (s[i]==',') s=s.subs... | #undef NDEBUG
#include<assert.h>
int main(){
assert (boost::any_cast<int>(func0(1, 2)) == 2);
assert (boost::any_cast<double>(func0(1, 2.5))== 2.5);
assert (boost::any_cast<int>(func0(2, 3)) == 3);
assert (boost::any_cast<int>(func0(5, 6)) == 6);
assert (boost::any_cast<string>(func0(1, string("2,3... | O3 | cpp | func0(boost::any, boost::any):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x118,%rsp
mov %rdi,0x28(%rsp)
mov (%rsi),%rdi
mov %rsi,0x20(%rsp)
mov %rdx,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x108(%rsp)
xor %eax,%eax
lea 0x598f(%rip),%rax
test %rdi,%rdi... | _Z5func0N5boost3anyES0_:
endbr64
push r15
mov r15, rdx
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 118h
mov [rsp+148h+var_138], rdi
mov rdi, [rsi]
mov [rsp+148h+var_140], rsi
mov rax, fs:28h
mov [rsp+148h+var_40], rax
xor eax, eax
lea rax, _ZTIv@CXXABI_1_3... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
long long v4; // rdi
void *v5; // rax
const char *v6; // rdi
double *v7; // rdi
size_t v8; // rdx
__m128 v9; // xmm0
double v10; // rdx
size_t v11; // rbp
char *v12; // rdi
char *v13; // rcx
size_t v14; // rdx
char *v15; // rax
size_t v16; /... | func0:
ENDBR64
PUSH R15
MOV R15,RDX
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x118
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSI]
MOV qword ptr [RSP + 0x8],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x108],RAX
XOR EAX,EAX
LEA RAX,[0x107b60]
TEST RDI,RDI
JZ 0x0010310a
MOV RAX,qword ptr [RDI... | /* func0(boost::any, boost::any) */
int8 * func0(any param_1,any param_2)
{
ulong *puVar1;
char *pcVar2;
int iVar3;
int1 *puVar4;
ulong *puVar5;
long *plVar6;
int8 *puVar7;
ulong uVar8;
ulong *puVar9;
int8 uVar10;
uint uVar11;
long lVar12;
uint uVar13;
any *in_RDX;
size_t sVar14;
ulong... |
552 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(int n){
if (n%2==0 and n>=8) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(4) == false);
assert (func0(6) == false);
assert (func0(8) == true);
assert (func0(10) == true);
assert (func0(11) == false);
assert (func0(12) == true);
assert (func0(13) == false);
assert (func0(16) == true);
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 116b <_Z5func0i+0x22>
cmpl $0x7,-0x4(%rbp)
jle 116b <_Z5func0i+0x22>
mov $0x1,%eax
jmp 1170 <_Z5func0i+0x27>
mov $0x0,%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
and eax, 1
test eax, eax
jnz short loc_116B
cmp [rbp+var_4], 7
jle short loc_116B
mov eax, 1
jmp short loc_1170
loc_116B:
mov eax, 0
loc_1170:
pop rbp
retn | _BOOL8 func0(int a1)
{
return (a1 & 1) == 0 && a1 > 7;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x0010116b
CMP dword ptr [RBP + -0x4],0x7
JLE 0x0010116b
MOV EAX,0x1
JMP 0x00101170
LAB_0010116b:
MOV EAX,0x0
LAB_00101170:
POP RBP
RET | /* func0(int) */
int8 func0(int param_1)
{
int8 uVar1;
if (((param_1 & 1U) == 0) && (7 < param_1)) {
uVar1 = 1;
}
else {
uVar1 = 0;
}
return uVar1;
} |
553 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(int n){
if (n%2==0 and n>=8) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(4) == false);
assert (func0(6) == false);
assert (func0(8) == true);
assert (func0(10) == true);
assert (func0(11) == false);
assert (func0(12) == true);
assert (func0(13) == false);
assert (func0(16) == true);
}
| O1 | cpp | func0(int):
endbr64
mov %edi,%edx
xor $0x1,%edx
cmp $0x7,%edi
setg %al
and %edx,%eax
retq
| _Z5func0i:
endbr64
mov edx, edi
xor edx, 1
cmp edi, 7
setnle al
and eax, edx
retn | long long func0(int a1)
{
unsigned int v1; // eax
LOBYTE(v1) = a1 > 7;
return (a1 ^ 1) & v1;
} | func0:
ENDBR64
MOV EDX,EDI
XOR EDX,0x1
CMP EDI,0x7
SETG AL
AND EAX,EDX
RET | /* func0(int) */
uint func0(int param_1)
{
int8 in_RAX;
return (uint)CONCAT71((int7)((ulong)in_RAX >> 8),7 < param_1) & (param_1 ^ 1U);
} |
554 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(int n){
if (n%2==0 and n>=8) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(4) == false);
assert (func0(6) == false);
assert (func0(8) == true);
assert (func0(10) == true);
assert (func0(11) == false);
assert (func0(12) == true);
assert (func0(13) == false);
assert (func0(16) == true);
}
| O2 | cpp | func0(int):
endbr64
cmp $0x7,%edi
not %edi
setg %al
and %edi,%eax
retq
| _Z5func0i:
endbr64
cmp edi, 7
not edi
setnle al
and eax, edi
retn | long long func0(int a1)
{
unsigned int v1; // eax
LOBYTE(v1) = a1 > 7;
return ~a1 & v1;
} | func0:
ENDBR64
CMP EDI,0x7
NOT EDI
SETG AL
AND EAX,EDI
RET | /* func0(int) */
uint func0(int param_1)
{
int8 in_RAX;
return (uint)CONCAT71((int7)((ulong)in_RAX >> 8),7 < param_1) & ~param_1;
} |
555 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(int n){
if (n%2==0 and n>=8) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(4) == false);
assert (func0(6) == false);
assert (func0(8) == true);
assert (func0(10) == true);
assert (func0(11) == false);
assert (func0(12) == true);
assert (func0(13) == false);
assert (func0(16) == true);
}
| O3 | cpp | func0(int):
endbr64
cmp $0x7,%edi
not %edi
setg %al
and %edi,%eax
retq
| _Z5func0i:
endbr64
cmp edi, 7
not edi
setnle al
and eax, edi
retn | long long func0(int a1)
{
unsigned int v1; // eax
LOBYTE(v1) = a1 > 7;
return ~a1 & v1;
} | func0:
ENDBR64
CMP EDI,0x7
NOT EDI
SETG AL
AND EAX,EDI
RET | /* func0(int) */
uint func0(int param_1)
{
int8 in_RAX;
return (uint)CONCAT71((int7)((ulong)in_RAX >> 8),7 < param_1) & ~param_1;
} |
556 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| long long func0(int n){
long long fact=1,bfact=1;
for (int i=1;i<=n;i++)
{
fact=fact*i;
bfact=bfact*fact;
}
return bfact;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(4) == 288);
assert (func0(5) == 34560);
assert (func0(7) == 125411328000);
assert (func0(1) == 1);
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
movq $0x1,-0x10(%rbp)
movq $0x1,-0x8(%rbp)
movl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x24(%rbp),%eax
jg 1197 <_Z5func0i+0x4e>
mov -0x14(%rbp),%eax
cltq
mov -0x10(%rbp),%rdx
imul %rdx,%rax
mov %rax,-0x10(%rbp)
mov ... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov [rbp+var_10], 1
mov [rbp+var_8], 1
mov [rbp+var_14], 1
jmp short loc_118F
loc_116D:
mov eax, [rbp+var_14]
cdqe
mov rdx, [rbp+var_10]
imul rax, rdx
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
imul rax, [rbp... | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-14h]
long long v3; // [rsp+14h] [rbp-10h]
long long v4; // [rsp+1Ch] [rbp-8h]
v3 = 1LL;
v4 = 1LL;
for ( i = 1; i <= a1; ++i )
{
v3 *= i;
v4 *= v3;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV qword ptr [RBP + -0x10],0x1
MOV qword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x14],0x1
JMP 0x0010118f
LAB_0010116d:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV RDX,qword ptr [RBP + -0x10]
IMUL RAX,RDX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ... | /* func0(int) */
long func0(int param_1)
{
int4 local_1c;
int8 local_18;
int8 local_10;
local_18 = 1;
local_10 = 1;
for (local_1c = 1; local_1c <= param_1; local_1c = local_1c + 1) {
local_18 = local_1c * local_18;
local_10 = local_10 * local_18;
}
return local_10;
} |
557 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| long long func0(int n){
long long fact=1,bfact=1;
for (int i=1;i<=n;i++)
{
fact=fact*i;
bfact=bfact*fact;
}
return bfact;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(4) == 288);
assert (func0(5) == 34560);
assert (func0(7) == 125411328000);
assert (func0(1) == 1);
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
jle 117c <_Z5func0i+0x33>
lea -0x1(%rdi),%esi
add $0x2,%rsi
mov $0x1,%eax
mov $0x1,%ecx
mov $0x1,%edx
imul %rax,%rdx
imul %rdx,%rcx
add $0x1,%rax
cmp %rsi,%rax
jne 1167 <_Z5func0i+0x1e>
mov %rcx,%rax
retq
mov $0x1,%ecx
jmp 1178 <_Z5func0i+0x2f... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1178
lea esi, [rdi+1]
mov eax, 1
mov ecx, 1
mov edx, 1
loc_1163:
imul rdx, rax
imul rcx, rdx
add rax, 1
cmp rax, rsi
jnz short loc_1163
loc_1174:
mov rax, rcx
retn
loc_1178:
mov ecx, 1
jmp short loc_1174 | long long func0(int a1)
{
long long v1; // rax
long long v2; // rcx
long long v3; // rdx
if ( a1 <= 0 )
return 1LL;
v1 = 1LL;
v2 = 1LL;
v3 = 1LL;
do
{
v3 *= v1;
v2 *= v3;
++v1;
}
while ( v1 != a1 + 1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101178
LEA ESI,[RDI + 0x1]
MOV EAX,0x1
MOV ECX,0x1
MOV EDX,0x1
LAB_00101163:
IMUL RDX,RAX
IMUL RCX,RDX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101163
LAB_00101174:
MOV RAX,RCX
RET
LAB_00101178:
MOV ECX,0x1
JMP 0x00101174 | /* func0(int) */
long func0(int param_1)
{
ulong uVar1;
long lVar2;
long lVar3;
if (param_1 < 1) {
lVar2 = 1;
}
else {
uVar1 = 1;
lVar2 = 1;
lVar3 = 1;
do {
lVar3 = lVar3 * uVar1;
lVar2 = lVar2 * lVar3;
uVar1 = uVar1 + 1;
} while (uVar1 != param_1 + 1);
}
r... |
558 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| long long func0(int n){
long long fact=1,bfact=1;
for (int i=1;i<=n;i++)
{
fact=fact*i;
bfact=bfact*fact;
}
return bfact;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(4) == 288);
assert (func0(5) == 34560);
assert (func0(7) == 125411328000);
assert (func0(1) == 1);
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11e8 <_Z5func0i+0x38>
lea -0x1(%rdi),%ecx
mov $0x1,%eax
mov $0x1,%r8d
mov $0x1,%edx
add $0x2,%rcx
imul %rax,%rdx
add $0x1,%rax
imul %rdx,%r8
cmp %rcx,%rax
jne 11d0 <_Z5func0i+0x20>
mov %r8,%rax
retq
nopl (%rax)
mov $0x1,%r8d
mov %r8,%rax... | _Z5func0i:
endbr64
test edi, edi
jle short loc_11E8
lea esi, [rdi+1]
mov eax, 1
mov ecx, 1
mov edx, 1
nop word ptr [rax+rax+00h]
loc_11D0:
imul rdx, rax
add rax, 1
imul rcx, rdx
cmp rax, rsi
jnz short loc_11D0
mov rax, rcx
retn
loc_11E8:
mov ecx, 1
mov rax, rcx
r... | long long func0(int a1)
{
long long v1; // rax
long long v2; // rcx
long long v3; // rdx
if ( a1 <= 0 )
return 1LL;
v1 = 1LL;
v2 = 1LL;
v3 = 1LL;
do
{
v3 *= v1++;
v2 *= v3;
}
while ( v1 != a1 + 1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001011e8
LEA ESI,[RDI + 0x1]
MOV EAX,0x1
MOV ECX,0x1
MOV EDX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_001011d0:
IMUL RDX,RAX
ADD RAX,0x1
IMUL RCX,RDX
CMP RAX,RSI
JNZ 0x001011d0
MOV RAX,RCX
RET
LAB_001011e8:
MOV ECX,0x1
MOV RAX,RCX
RET | /* func0(int) */
long func0(int param_1)
{
ulong uVar1;
long lVar2;
long lVar3;
if (0 < param_1) {
uVar1 = 1;
lVar2 = 1;
lVar3 = 1;
do {
lVar3 = lVar3 * uVar1;
uVar1 = uVar1 + 1;
lVar2 = lVar2 * lVar3;
} while (uVar1 != param_1 + 1);
return lVar2;
}
return 1;
} |
559 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| long long func0(int n){
long long fact=1,bfact=1;
for (int i=1;i<=n;i++)
{
fact=fact*i;
bfact=bfact*fact;
}
return bfact;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(4) == 288);
assert (func0(5) == 34560);
assert (func0(7) == 125411328000);
assert (func0(1) == 1);
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
jle 1178 <_Z5func0i+0x38>
lea -0x1(%rdi),%ecx
mov $0x1,%eax
mov $0x1,%r8d
mov $0x1,%edx
add $0x2,%rcx
imul %rax,%rdx
add $0x1,%rax
imul %rdx,%r8
cmp %rcx,%rax
jne 1160 <_Z5func0i+0x20>
mov %r8,%rax
retq
nopl (%rax)
mov $0x1,%r8d
mov %r8,%rax... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1178
lea esi, [rdi+1]
mov eax, 1
mov ecx, 1
mov edx, 1
nop word ptr [rax+rax+00h]
loc_1160:
imul rdx, rax
add rax, 1
imul rcx, rdx
cmp rax, rsi
jnz short loc_1160
mov rax, rcx
retn
loc_1178:
mov ecx, 1
mov rax, rcx
r... | long long func0(int a1)
{
long long v1; // rax
long long v2; // rcx
long long v3; // rdx
if ( a1 <= 0 )
return 1LL;
v1 = 1LL;
v2 = 1LL;
v3 = 1LL;
do
{
v3 *= v1++;
v2 *= v3;
}
while ( v1 != a1 + 1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101178
LEA ESI,[RDI + 0x1]
MOV EAX,0x1
MOV ECX,0x1
MOV EDX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
IMUL RDX,RAX
ADD RAX,0x1
IMUL RCX,RDX
CMP RAX,RSI
JNZ 0x00101160
MOV RAX,RCX
RET
LAB_00101178:
MOV ECX,0x1
MOV RAX,RCX
RET | /* func0(int) */
long func0(int param_1)
{
ulong uVar1;
long lVar2;
long lVar3;
if (0 < param_1) {
uVar1 = 1;
lVar2 = 1;
lVar3 = 1;
do {
lVar3 = lVar3 * uVar1;
uVar1 = uVar1 + 1;
lVar2 = lVar2 * lVar3;
} while (uVar1 != param_1 + 1);
return lVar2;
}
return 1;
} |
560 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string text){
string out="";
int spacelen=0;
for (int i=0;i<text.length();i++)
if (text[i]==' ') spacelen+=1;
else
{
if (spacelen==1) out=out+'_';
if (spacelen==2) out=out+"__";
if (spacelen>2) out=out+'-';
spacelen=0;
out=out+text[i];
}
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Example") == "Example");
assert (func0("Mudasir Hanif ") == "Mudasir_Hanif_");
assert (func0("Yellow Yellow Dirty Fellow") == "Yellow_Yellow__Dirty__Fellow");
assert (func0("Exa mple") == "Exa-mple");
assert (func0(" Exa 1 2 2 mple")... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x118,%rsp
mov %rdi,-0x118(%rbp)
mov %rsi,-0x120(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x109(%rbp),%rax
mov %rax,%rdi
callq 235... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_51]
mov [rbp+var_48], rax
nop
nop
lea rdx, [rbp... | long long func0(long long a1, long long a2)
{
char *v2; // rax
unsigned long long v3; // rbx
char v5; // [rsp+1Fh] [rbp-51h] BYREF
int v6; // [rsp+20h] [rbp-50h]
int i; // [rsp+24h] [rbp-4Ch]
char *v8; // [rsp+28h] [rbp-48h]
_BYTE v9[40]; // [rsp+30h] [rbp-40h] BYREF
unsigned long long v10; // [rsp+58h... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x51]
MOV qword ptr [RBP + -0x48],RAX
NOP
NOP
LEA RDX,[RBP + -0x51]
MOV RAX,qword ptr [RBP + -0x68]
LEA RCX,[0... | /* func0(std::string) */
string * func0(string *param_1,ulong param_2)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
long in_FS_OFFSET;
allocator local_59;
int local_58;
int local_54;
allocator *local_50;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_50 =... |
561 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string text){
string out="";
int spacelen=0;
for (int i=0;i<text.length();i++)
if (text[i]==' ') spacelen+=1;
else
{
if (spacelen==1) out=out+'_';
if (spacelen==2) out=out+"__";
if (spacelen>2) out=out+'-';
spacelen=0;
out=out+text[i];
}
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Example") == "Example");
assert (func0("Mudasir Hanif ") == "Mudasir_Hanif_");
assert (func0("Yellow Yellow Dirty Fellow") == "Yellow_Yellow__Dirty__Fellow");
assert (func0("Exa mple") == "Exa-mple");
assert (func0(" Exa 1 2 2 mple")... | 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 $0xf8,%rsp
mov %rdi,%rbx
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,0xe8(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%r13
mov %r13,(%rd... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rsp+98h+var_88], rax
mov ... | void ** func0(void **a1, _QWORD *a2)
{
unsigned long long v4; // rbp
int v5; // eax
unsigned long long v6; // rax
_BYTE *v7; // rax
void *v8; // rcx
void *v9; // rdi
long long v10; // rdx
unsigned long long v11; // rdi
_BYTE *v12; // rax
char *v13; // rsi
unsigned int v14; // ecx
unsigned int v1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RDI],RAX
LEA RSI,[0x103205]
MOV RDX,RSI
LAB_00101307:
CALL 0x0010298a
CMP qw... | /* func0(std::string) */
ulong * func0(ulong *param_1,long *param_2)
{
ulong *puVar1;
ulong *puVar2;
ulong uVar3;
int iVar4;
uint uVar5;
int8 uVar6;
long lVar7;
ulong uVar8;
uint uVar9;
ulong uVar10;
long in_FS_OFFSET;
int local_6d;
int local_6c;
int local_6b;
int local_6a;
int local_6... |
562 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string text){
string out="";
int spacelen=0;
for (int i=0;i<text.length();i++)
if (text[i]==' ') spacelen+=1;
else
{
if (spacelen==1) out=out+'_';
if (spacelen==2) out=out+"__";
if (spacelen>2) out=out+'-';
spacelen=0;
out=out+text[i];
}
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Example") == "Example");
assert (func0("Mudasir Hanif ") == "Mudasir_Hanif_");
assert (func0("Yellow Yellow Dirty Fellow") == "Yellow_Yellow__Dirty__Fellow");
assert (func0("Exa mple") == "Exa-mple");
assert (func0(" Exa 1 2 2 mple")... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x108,%rsp
mov %fs:0x28,%rax
mov %rax,0xf8(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
cmpq $0x0,0x8(%rsi)
movb $0x... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
lea rcx, [rsp+98h+src]
lea rax, [rdi+10h]
mov byte ptr [rdi+10h],... | long long func0(long long a1, _QWORD *a2)
{
bool v3; // zf
unsigned long long v4; // r13
int v5; // eax
char v6; // dl
size_t v7; // rbp
double *v8; // rdi
size_t v9; // rdx
double v10; // rcx
double *v11; // rdi
size_t v12; // rdx
double v13; // rcx
size_t v14; // rbp
double *v15; // r13
d... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RCX,[RSP + 0x40]
LEA RAX,[RDI + 0x10]
MOV byte ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x8],0x0
CMP qword ptr [RSI + 0x8],0x0
MOV qword ptr [RSP + 0x... | /* func0(std::string) */
ulong * func0(ulong *param_1,long *param_2)
{
long lVar1;
int iVar2;
ulong *puVar3;
char cVar4;
ulong uVar5;
ulong *puVar6;
ulong uVar7;
long in_FS_OFFSET;
ulong local_90;
int local_6d;
int local_6c;
char local_6b [3];
ulong *local_68;
ulong local_60;
ulong local... |
563 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string text){
string out="";
int spacelen=0;
for (int i=0;i<text.length();i++)
if (text[i]==' ') spacelen+=1;
else
{
if (spacelen==1) out=out+'_';
if (spacelen==2) out=out+"__";
if (spacelen>2) out=out+'-';
spacelen=0;
out=out+text[i];
}
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Example") == "Example");
assert (func0("Mudasir Hanif ") == "Mudasir_Hanif_");
assert (func0("Yellow Yellow Dirty Fellow") == "Yellow_Yellow__Dirty__Fellow");
assert (func0("Exa mple") == "Exa-mple");
assert (func0(" Exa 1 2 2 mple")... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
mov %rsi,%r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x128,%rsp
mov 0x8(%rsi),%rsi
mov %fs:0x28,%rax
mov %rax,0x118(%rsp)
xor %eax,%eax
lea 0x10(%rd... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
mov byte ptr [rdi+10h], 0
lea rax, [rdi+10h]
lea rdx, [rsp+98h+sr... | void ** func0(void **a1, _QWORD *a2)
{
unsigned long long v3; // rcx
unsigned long long v4; // r12
int v5; // eax
size_t v6; // r14
double *v7; // rdi
size_t v8; // rdx
double v9; // rcx
char v10; // dl
double *v11; // rdi
size_t v12; // rdx
double v13; // rcx
size_t v14; // r12
double *v15; /... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV byte ptr [RDI + 0x10],0x0
LEA RAX,[RDI + 0x10]
LEA RDX,[RSP + 0x40]
MOV qword ptr [RDI + 0x8],0x0
MOV RCX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x... | /* func0(std::string) */
ulong * func0(ulong *param_1,long *param_2)
{
ulong uVar1;
int iVar2;
ulong *puVar3;
ulong uVar4;
char cVar5;
ulong *puVar6;
ulong uVar7;
long in_FS_OFFSET;
ulong local_90;
int local_6d;
int local_6c;
char local_6b [3];
ulong *local_68;
size_t local_60;
ulong loc... |
564 | func0 | #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| string func0(string file_name){
int numdigit=0,numdot=0;
if (file_name.length()<5) return "No";
char w=file_name[0];
if (w<65 or (w>90 and w<97) or w>122) return "No";
string last=file_name.substr(file_name.length()-4,4);
if (last!=".txt" and last!=".exe" and last!=".dll") return "No";
for (... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("example.txt") == "Yes");
assert (func0("1example.dll") == "No");
assert (func0("s1sdf3.asd") == "No");
assert (func0("K.dll") == "Yes");
assert (func0("MY16FILE3.exe") == "Yes");
assert (func0("His12FILE94.exe") == "No");
assert (f... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x4c(%rbp)
movl $0x0,-0x48(%rbp)
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_88], rdi
mov [rbp+var_90], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_74], 0
mov [rbp+var_70], 0
mov rax, [rbp+var_90]
mov... | long long func0(long long a1, long long a2)
{
long long v2; // rax
char v6; // [rsp+1Ah] [rbp-76h] BYREF
char v7; // [rsp+1Bh] [rbp-75h]
int v8; // [rsp+1Ch] [rbp-74h]
int v9; // [rsp+20h] [rbp-70h]
int i; // [rsp+24h] [rbp-6Ch]
char *v11; // [rsp+28h] [rbp-68h]
char *v12; // [rsp+30h] [rbp-60h]
char... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x88],RDI
MOV qword ptr [RBP + -0x90],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x74],0x0
MOV dword ptr [RBP + -0x70],0x0
MOV RAX,qword ptr [RBP + -0x90]
MOV RDI,RAX
CALL 0x00101290
CM... | /* func0(std::string) */
string * func0(string *param_1,ulong param_2)
{
bool bVar1;
ulong uVar2;
char *pcVar3;
ulong uVar4;
long in_FS_OFFSET;
allocator local_7e;
char local_7d;
int local_7c;
int local_78;
int local_74;
allocator *local_70;
allocator *local_68;
allocator *local_60;
alloca... |
565 | func0 | #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| string func0(string file_name){
int numdigit=0,numdot=0;
if (file_name.length()<5) return "No";
char w=file_name[0];
if (w<65 or (w>90 and w<97) or w>122) return "No";
string last=file_name.substr(file_name.length()-4,4);
if (last!=".txt" and last!=".exe" and last!=".dll") return "No";
for (... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("example.txt") == "Yes");
assert (func0("1example.dll") == "No");
assert (func0("s1sdf3.asd") == "No");
assert (func0("K.dll") == "Yes");
assert (func0("MY16FILE3.exe") == "Yes");
assert (func0("His12FILE94.exe") == "No");
assert (f... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov 0x8(%rsi),%rdx
cmp $0x4,%rdx
jbe 12a5 <_Z5func0NSt7__cxx1112basic_stringIcSt11c... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r12
push rbp
push rbx
sub rsp, 30h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+48h+var_20], rax
xor eax, eax
mov rdx, [rsi+8]
cmp rdx, 4
jbe short loc_12E5
mov rbp, rsi
mov rcx, [rsi]
movzx eax, byte ... | _QWORD * func0(_QWORD *a1, char **a2)
{
unsigned long long v3; // rdx
char *v4; // rcx
char v5; // al
const void *v7; // r12
char *v8; // rdi
char *v9; // rax
char *v10; // rdi
int v11; // esi
int v12; // r8d
void *s1[2]; // [rsp+0h] [rbp-48h] BYREF
_QWORD v14[7]; // [rsp+10h] [rbp-38h] BYREF
v... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RSI + 0x8]
CMP RDX,0x4
JBE 0x001012e5
MOV RBP,RSI
MOV RCX,qword ptr [RSI]
MOVZX EAX,byte ptr [RCX]
LEA ESI,[RAX + -0x5b]
CMP SIL,0x5
JBE 0x001012ab
SUB EAX,0x41
CM... | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
ulong uVar1;
long *__s1;
int iVar2;
char *pcVar3;
char *pcVar4;
int iVar5;
long in_FS_OFFSET;
long *local_48;
long local_40;
long local_38 [3];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uVar1 = param_2[1]... |
566 | func0 | #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| string func0(string file_name){
int numdigit=0,numdot=0;
if (file_name.length()<5) return "No";
char w=file_name[0];
if (w<65 or (w>90 and w<97) or w>122) return "No";
string last=file_name.substr(file_name.length()-4,4);
if (last!=".txt" and last!=".exe" and last!=".dll") return "No";
for (... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("example.txt") == "Yes");
assert (func0("1example.dll") == "No");
assert (func0("s1sdf3.asd") == "No");
assert (func0("K.dll") == "Yes");
assert (func0("MY16FILE3.exe") == "Yes");
assert (func0("His12FILE94.exe") == "No");
assert (f... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
lea 0x10(%rdi),%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x30,%rsp
mov 0x8(%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
cmp $0x4,%rdx
jbe ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
sub rsp, 38h
mov rcx, [rsi+8]
mov rax, rdi
mov rdx, fs:28h
mov [rsp+38h+var_10], rdx
xor edx, edx
cmp rcx, 4
jbe short loc_1CED
mov rdx, [rsi]
movzx esi, byte ptr [rdx]
lea edi, [rsi-5Bh]
cmp dil, 5
jbe ... | long long func0(long long a1, char **a2)
{
unsigned long long v2; // rcx
long long result; // rax
char *v4; // rdx
char v5; // si
int v6; // esi
char *v7; // rcx
int v8; // r8d
int v9; // edi
char v10; // si
v2 = (unsigned long long)a2[1];
result = a1;
if ( v2 > 4
&& (v4 = *a2, v5 = **a2, ... | func0:
ENDBR64
SUB RSP,0x38
MOV RCX,qword ptr [RSI + 0x8]
MOV RAX,RDI
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RDX
XOR EDX,EDX
CMP RCX,0x4
JBE 0x00101ced
MOV RDX,qword ptr [RSI]
MOVZX ESI,byte ptr [RDX]
LEA EDI,[RSI + -0x5b]
CMP DIL,0x5
JBE 0x00101ced
SUB ESI,0x41
CMP SIL,0x39
JBE 0x00101d28
LAB_00101ced:... | /* func0(std::string) */
void func0(long *param_1,int8 *param_2)
{
char cVar1;
ulong uVar2;
long lVar3;
char *pcVar4;
char *pcVar5;
int iVar6;
int iVar7;
long in_FS_OFFSET;
uVar2 = param_2[1];
lVar3 = *(long *)(in_FS_OFFSET + 0x28);
if (4 < uVar2) {
pcVar5 = (char *)*param_2;
if (((5 ... |
567 | func0 | #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| string func0(string file_name){
int numdigit=0,numdot=0;
if (file_name.length()<5) return "No";
char w=file_name[0];
if (w<65 or (w>90 and w<97) or w>122) return "No";
string last=file_name.substr(file_name.length()-4,4);
if (last!=".txt" and last!=".exe" and last!=".dll") return "No";
for (... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("example.txt") == "Yes");
assert (func0("1example.dll") == "No");
assert (func0("s1sdf3.asd") == "No");
assert (func0("K.dll") == "Yes");
assert (func0("MY16FILE3.exe") == "Yes");
assert (func0("His12FILE94.exe") == "No");
assert (f... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
lea 0x10(%rdi),%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x30,%rsp
mov 0x8(%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
cmp $0x4,%rdx
jbe ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
sub rsp, 38h
mov rax, rdi
mov rdx, fs:28h
mov [rsp+38h+var_10], rdx
mov rdx, [rsi+8]
cmp rdx, 4
jbe short loc_1CEA
mov rsi, [rsi]
movzx ecx, byte ptr [rsi]
lea edi, [rcx-5Bh]
cmp dil, 5
jbe short loc_1CEA... | long long func0(long long a1, long long a2)
{
long long result; // rax
unsigned long long v3; // rdx
const __m128i *v4; // rsi
int v5; // ecx
__m128 v6; // xmm10
const __m128i *v7; // rcx
unsigned long long v8; // rdi
__m128i si128; // xmm7
__m128i v10; // xmm9
__m128i v11; // xmm8
__m128i v12; /... | func0:
ENDBR64
SUB RSP,0x38
MOV RAX,RDI
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RSI + 0x8]
CMP RDX,0x4
JBE 0x00101cea
MOV RSI,qword ptr [RSI]
MOVZX ECX,byte ptr [RSI]
LEA EDI,[RCX + -0x5b]
CMP DIL,0x5
JBE 0x00101cea
SUB ECX,0x41
CMP CL,0x39
JBE 0x00101d20
LAB_00101cea:
LEA RDX,[RAX... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::string) */
void func0(long *param_1,int8 *param_2)
{
long lVar1;
ulong uVar2;
char *pcVar3;
int auVar4 [15];
int auVar5 [15];
int auVar6 [15];
int auVar7 [14];
int auVar8 [14];
int auVar9 [15];
int a... |
568 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i<lst.size();i++)
if (i%3==0) sum+=lst[i]*lst[i];
else if (i%4==0) sum+=lst[i]*lst[i]*lst[i];
else sum+=lst[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3}) == 6);
assert (func0({1,4,9}) == 14);
assert (func0({}) == 0);
assert (func0({1,1,1,1,1,1,1,1,1}) == 9);
assert (func0({-1,-1,-1,-1,-1,-1,-1,-1,-1}) == -3);
assert (func0({0}) == 0);
assert (func0({-1,-5,2,-1,-5}) == -126);... | 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
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1f24 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %r... | _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 loc_1344
loc_126D:
mov ecx, [rbp+var_14]
movsxd rax, ecx
imul rax, 55555556h
shr rax, 20h
mov rdx, rax
mov eax, ecx
sar e... | long long func0(long long a1)
{
int v1; // ebx
int v2; // ebx
int v3; // ebx
unsigned int v5; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v5 = 0;
for ( i = 0; i < (unsigned long long)std::vector<int>::size(a1); ++i )
{
if ( i % 3 )
{
if ( (i & 3) != 0 )
{
v5 += *(_... | 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 0x00101344
LAB_0010126d:
MOV ECX,dword ptr [RBP + -0x14]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
MOV RDX,RAX
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV ... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
int iVar2;
int *piVar3;
ulong uVar4;
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,p... |
569 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i<lst.size();i++)
if (i%3==0) sum+=lst[i]*lst[i];
else if (i%4==0) sum+=lst[i]*lst[i]*lst[i];
else sum+=lst[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3}) == 6);
assert (func0({1,4,9}) == 14);
assert (func0({}) == 0);
assert (func0({1,1,1,1,1,1,1,1,1}) == 9);
assert (func0({-1,-1,-1,-1,-1,-1,-1,-1,-1}) == -3);
assert (func0({0}) == 0);
assert (func0({-1,-5,2,-1,-5}) == -126);... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rax
sub %r8,%rax
sar $0x2,%rax
mov %rax,%rdi
je 1275 <_Z5func0St6vectorIiSaIiEE+0x6c>
mov $0x0,%ecx
mov $0x0,%edx
jmp 1248 <_Z5func0St6vectorIiSaIiEE+0x3f>
test $0x3,%dl
jne 126f <_Z5func0St6vectorIiSaI... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov r8, [rdi]
mov rdi, rax
sub rdi, r8
sar rdi, 2
cmp rax, r8
jz short loc_1278
mov ecx, 0
mov edx, 0
jmp short loc_124B
loc_122F:
test dl, 3
jnz short loc_1272
mov esi, [r8+rdx*4]
mov eax, esi
imul eax, esi
i... | long long func0(long long *a1)
{
long long v1; // rax
long long v2; // r8
unsigned long long v3; // rdi
unsigned int v4; // ecx
unsigned long long v5; // rdx
v1 = a1[1];
v2 = *a1;
v3 = (v1 - *a1) >> 2;
if ( v1 == v2 )
{
return 0;
}
else
{
v4 = 0;
v5 = 0LL;
do
{
if (... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV R8,qword ptr [RDI]
MOV RDI,RAX
SUB RDI,R8
SAR RDI,0x2
CMP RAX,R8
JZ 0x00101278
MOV ECX,0x0
MOV EDX,0x0
JMP 0x0010124b
LAB_0010122f:
TEST DL,0x3
JNZ 0x00101272
MOV ESI,dword ptr [R8 + RDX*0x4]
MOV EAX,ESI
IMUL EAX,ESI
IMUL EAX,ESI
ADD ECX,EAX
LAB_00101242:
ADD RDX,0x1
CMP... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
long lVar2;
long lVar3;
int iVar4;
ulong uVar5;
int4 in_register_0000003c;
lVar2 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
if (lVar2 == ... |
570 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i<lst.size();i++)
if (i%3==0) sum+=lst[i]*lst[i];
else if (i%4==0) sum+=lst[i]*lst[i]*lst[i];
else sum+=lst[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3}) == 6);
assert (func0({1,4,9}) == 14);
assert (func0({}) == 0);
assert (func0({1,1,1,1,1,1,1,1,1}) == 9);
assert (func0({-1,-1,-1,-1,-1,-1,-1,-1,-1}) == -3);
assert (func0({0}) == 0);
assert (func0({-1,-5,2,-1,-5}) == -126);... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%r9
mov 0x8(%rdi),%rsi
xor %r8d,%r8d
sub %r9,%rsi
sar $0x2,%rsi
je 1839 <_Z5func0St6vectorIiSaIiEE+0x59>
xor %eax,%eax
jmp 180f <_Z5func0St6vectorIiSaIiEE+0x2f>
nopl 0x0(%rax,%rax,1)
imul %edx,%edx
add %edx,%r8d
add $0x... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rsi, [rdi]
xor ecx, ecx
mov rdi, rax
sub rdi, rsi
sar rdi, 2
cmp rax, rsi
jz short loc_1719
xor eax, eax
jmp short loc_16EE
loc_16E0:
imul edx, edx
add ecx, edx
loc_16E5:
add rax, 1
cmp rax, rdi
jnb short... | long long func0(long long *a1)
{
long long v1; // rax
long long v2; // rsi
unsigned int v3; // ecx
unsigned long long v4; // rdi
unsigned long long i; // rax
int v6; // edx
v1 = a1[1];
v2 = *a1;
v3 = 0;
v4 = (v1 - *a1) >> 2;
if ( v1 != v2 )
{
for ( i = 0LL; i < v4; ++i )
{
while ... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
XOR ECX,ECX
MOV RDI,RAX
SUB RDI,RSI
SAR RDI,0x2
CMP RAX,RSI
JZ 0x00101719
XOR EAX,EAX
JMP 0x001016ee
LAB_001016e0:
IMUL EDX,EDX
ADD ECX,EDX
LAB_001016e5:
ADD RAX,0x1
CMP RAX,RDI
JNC 0x00101719
LAB_001016ee:
IMUL EDX,EAX,-0x55555555
CMP EDX,0x55555555
... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
int iVar4;
int iVar5;
int4 in_register_0000003c;
ulong uVar6;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
... |
571 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i<lst.size();i++)
if (i%3==0) sum+=lst[i]*lst[i];
else if (i%4==0) sum+=lst[i]*lst[i]*lst[i];
else sum+=lst[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3}) == 6);
assert (func0({1,4,9}) == 14);
assert (func0({}) == 0);
assert (func0({1,1,1,1,1,1,1,1,1}) == 9);
assert (func0({-1,-1,-1,-1,-1,-1,-1,-1,-1}) == -3);
assert (func0({0}) == 0);
assert (func0({-1,-5,2,-1,-5}) == -126);... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%r9
mov 0x8(%rdi),%rsi
xor %r8d,%r8d
sub %r9,%rsi
sar $0x2,%rsi
je 17e9 <_Z5func0St6vectorIiSaIiEE+0x59>
xor %eax,%eax
jmp 17bf <_Z5func0St6vectorIiSaIiEE+0x2f>
nopl 0x0(%rax,%rax,1)
imul %edx,%edx
add %edx,%r8d
add $0x... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rsi, [rdi]
xor ecx, ecx
mov rdi, rax
sub rdi, rsi
sar rdi, 2
cmp rax, rsi
jz short loc_17A9
xor eax, eax
jmp short loc_177E
loc_1770:
imul edx, edx
add ecx, edx
loc_1775:
add rax, 1
cmp rax, rdi
jnb short... | long long func0(long long *a1)
{
long long v1; // rax
long long v2; // rsi
unsigned int v3; // ecx
unsigned long long v4; // rdi
unsigned long long i; // rax
int v6; // edx
v1 = a1[1];
v2 = *a1;
v3 = 0;
v4 = (v1 - *a1) >> 2;
if ( v1 != v2 )
{
for ( i = 0LL; i < v4; ++i )
{
while ... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
XOR ECX,ECX
MOV RDI,RAX
SUB RDI,RSI
SAR RDI,0x2
CMP RAX,RSI
JZ 0x001017a9
XOR EAX,EAX
JMP 0x0010177e
LAB_00101770:
IMUL EDX,EDX
ADD ECX,EDX
LAB_00101775:
ADD RAX,0x1
CMP RAX,RDI
JNC 0x001017a9
LAB_0010177e:
IMUL EDX,EAX,-0x55555555
CMP EDX,0x55555555
... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
int iVar4;
int iVar5;
int4 in_register_0000003c;
ulong uVar6;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
... |
572 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string sentence){
string out="";
string current="";
sentence=sentence+' ';
for (int i=0;i<sentence.size();i++)
if (sentence[i]!=' ') current=current+sentence[i];
else
{
bool isp=true;
int l=current.length();
if (l<2) isp=false;
for (int j=2;j*j<=... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("This is a test") == "is");
assert (func0("lets go for swimming") == "go for");
assert (func0("there is no place available here") == "there is no place");
assert (func0("Hi I am Hussein") == "Hi am Hussein");
assert (func0("go for it") == "... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xb8,%rsp
mov %rdi,-0xb8(%rbp)
mov %rsi,-0xc0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0xae(%rbp),%rax
mov %rax,%rdi
callq 23d0 <_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+var_A8], rdi
mov [rbp+var_B0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_9E]
mov [rbp+var_90], rax
nop
nop
lea rdx, [rb... | long long func0(long long a1, long long a2)
{
char *v2; // rax
unsigned long long v3; // rbx
char v5; // [rsp+12h] [rbp-9Eh] BYREF
char v6; // [rsp+13h] [rbp-9Dh]
int i; // [rsp+14h] [rbp-9Ch]
int j; // [rsp+18h] [rbp-98h]
int v9; // [rsp+1Ch] [rbp-94h]
char *v10; // [rsp+20h] [rbp-90h]
char *v11; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0xa8],RDI
MOV qword ptr [RBP + -0xb0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x9e]
MOV qword ptr [RBP + -0x90],RAX
NOP
NOP
LEA RDX,[RBP + -0x9e]
MOV RAX,qword ptr [RBP + -0xa8]
LEA RCX,[0... | /* func0(std::string) */
string * func0(string *param_1,string *param_2)
{
char *pcVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
long in_FS_OFFSET;
allocator local_a6;
char local_a5;
int local_a4;
int local_a0;
int local_9c;
allocator *local_98;
allocator *local_90;
string local_88 [32];
str... |
573 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string sentence){
string out="";
string current="";
sentence=sentence+' ';
for (int i=0;i<sentence.size();i++)
if (sentence[i]!=' ') current=current+sentence[i];
else
{
bool isp=true;
int l=current.length();
if (l<2) isp=false;
for (int j=2;j*j<=... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("This is a test") == "is");
assert (func0("lets go for swimming") == "go for");
assert (func0("there is no place available here") == "there is no place");
assert (func0("Hi I am Hussein") == "Hi am Hussein");
assert (func0("go for it") == "... | 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 $0x78,%rsp
mov %rdi,%r12
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%r14
mov %r14,(%rd... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov r12, rdi
mov rbp, rsi
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rsp+0E8h+var_C0], rax
mov ... | void ** func0(void **a1, void **a2)
{
unsigned long long v4; // rbx
_BYTE *v5; // r13
_BYTE *v6; // rax
void *v7; // rcx
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 int v14; // edx
unsign... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV R12,RDI
MOV RBP,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RDI],RAX
LEA RBX,[0x103217]
MOV RDX,RBX
MOV RSI,RBX
LAB_00101370:
CALL 0x001... | /* func0(std::string) */
ulong * func0(ulong *param_1,ulong *param_2)
{
ulong *puVar1;
ulong uVar2;
bool bVar3;
char *pcVar4;
uint uVar5;
int8 uVar6;
long lVar7;
int8 *puVar8;
uint uVar9;
int iVar10;
ulong uVar11;
ulong *puVar12;
ulong uVar13;
ulong *puVar14;
int iVar15;
long in_FS_OFF... |
574 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string sentence){
string out="";
string current="";
sentence=sentence+' ';
for (int i=0;i<sentence.size();i++)
if (sentence[i]!=' ') current=current+sentence[i];
else
{
bool isp=true;
int l=current.length();
if (l<2) isp=false;
for (int j=2;j*j<=... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("This is a test") == "is");
assert (func0("lets go for swimming") == "go for");
assert (func0("there is no place available here") == "there is no place");
assert (func0("Hi I am Hussein") == "Hi am Hussein");
assert (func0("go for it") == "... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
mov %rsi,%r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movb $0x0,0x10... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
lea rdx, aFunc0Here+13h; ""
push r14
push r13
push r12
mov r12, rsi
mov rsi, rdx
push rbp
push rbx
sub rsp, 0D8h
mov [rsp+108h+var_100], rdi
mov rax, fs:28h
mov [rsp+108h+var_40], rax
mov rax... | __m128i ** func0(__m128i **a1, void **a2)
{
unsigned long long v3; // rbx
long long *v4; // r13
long long *v5; // rdi
long long v6; // rdx
long long v7; // rcx
long long v8; // rbx
unsigned long long v9; // r13
long long *v10; // rdi
long long v11; // rdx
__m128 v12; // xmm0
long long v13; // rdx
... | func0:
ENDBR64
PUSH R15
LEA RDX,[0x1030a1]
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
MOV RSI,RDX
PUSH RBP
PUSH RBX
SUB RSP,0xd8
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc8],RAX
MOV RAX,RDI
LEA RBX,[RAX + 0x10]
MOV RDI,RAX
MOV qword ptr [RAX],RBX
MOV qword ptr [RSP + 0x48],RBX
LAB_00... | /* WARNING: Restarted to delay deadcode elimination for space: stack */
/* func0(std::string) */
ulong * func0(ulong *param_1,ulong *param_2)
{
bool bVar1;
char *pcVar2;
uint uVar3;
int8 *puVar4;
ulong *puVar5;
long lVar6;
ulong *puVar7;
int iVar8;
uint uVar9;
ulong uVar10;
ulong uVar11;
ulong... |
575 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string sentence){
string out="";
string current="";
sentence=sentence+' ';
for (int i=0;i<sentence.size();i++)
if (sentence[i]!=' ') current=current+sentence[i];
else
{
bool isp=true;
int l=current.length();
if (l<2) isp=false;
for (int j=2;j*j<=... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("This is a test") == "is");
assert (func0("lets go for swimming") == "go for");
assert (func0("there is no place available here") == "there is no place");
assert (func0("Hi I am Hussein") == "Hi am Hussein");
assert (func0("go for it") == "... | O3 | 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 $0xc8,%rsp
mov %rdi,0x18(%rsp)
lea 0x60(%rsp),%rax
mov %fs:0x28,%rbx
mov %rbx,0xb8(%rsp)
xor %ebx,%ebx
lea 0x10(%rdi),%rbx
movb... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
push rbp
push rbx
sub rsp, 0D8h
mov [rsp+108h+var_F8], rdi
lea r12, [rsp+108h+src+8]
mov rax, fs:28h
mov [rsp+108h+var_40], rax
mov rax, rdi
mov byte p... | __m128i ** func0(__m128i **a1, void **a2)
{
long long *v3; // rbp
unsigned long long v4; // rbx
long long *v5; // rdi
long long v6; // rdx
long long v7; // rcx
long long v8; // rbp
void *v9; // r15
long long *v10; // rdi
long long v11; // rdx
__m128 v12; // xmm0
long long v13; // rdx
unsigned lo... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xd8
MOV qword ptr [RSP + 0x10],RDI
LEA R12,[RSP + 0xb0]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc8],RAX
MOV RAX,RDI
MOV byte ptr [RSP + 0x70],0x0
MOV qword ptr [RSP + 0x68],0x0
MOV byte ptr [RSP + 0x5e],0x20
MOV qword p... | /* WARNING: Restarted to delay deadcode elimination for space: stack */
/* func0(std::string) */
ulong * func0(ulong *param_1,ulong *param_2)
{
bool bVar1;
char *pcVar2;
uint uVar3;
int8 *puVar4;
ulong *puVar5;
long lVar6;
int iVar7;
uint uVar8;
ulong uVar9;
ulong uVar10;
ulong *puVar11;
int i... |
576 | func0 | #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| bool func0(string x,string n){
int a,b,c,d,i;
for (i=0;i<x.size();i++)
if (x[i]=='/')
{
a=atoi(x.substr(0,i).c_str());
b=atoi(x.substr(i+1).c_str());
}
for (i=0;i<n.size();i++)
if (n[i]=='/')
{
c=atoi(n.substr(0,i).c_str());
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("1/5", "5/1") == true);
assert (func0("1/6", "2/1") == false);
assert (func0("5/1", "3/1") == true);
assert (func0("7/10", "10/2") == false);
assert (func0("2/10", "50/10") == true);
assert (func0("7/2", "4/2") == true);
assert (fun... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_44], 0
jmp loc_1486
loc_13D9:
mov eax, [rbp+var_4... | _BOOL8 func0(long long a1, long long a2)
{
const char *v2; // rax
const char *v3; // rax
const char *v4; // rax
const char *v5; // rax
int v7; // [rsp+1Ch] [rbp-54h]
int v8; // [rsp+20h] [rbp-50h]
int v9; // [rsp+24h] [rbp-4Ch]
int v10; // [rsp+28h] [rbp-48h]
int i; // [rsp+2Ch] [rbp-44h]
int j; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x44],0x0
JMP 0x00101486
LAB_001013d9:
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
MOV RAX,qword ptr ... | /* func0(std::string, std::string) */
bool func0(ulong param_1,ulong param_2)
{
ulong uVar1;
char *pcVar2;
long in_FS_OFFSET;
int local_5c;
int local_58;
int local_54;
int local_50;
int local_4c;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
for (local_4c =... |
577 | func0 | #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| bool func0(string x,string n){
int a,b,c,d,i;
for (i=0;i<x.size();i++)
if (x[i]=='/')
{
a=atoi(x.substr(0,i).c_str());
b=atoi(x.substr(i+1).c_str());
}
for (i=0;i<n.size();i++)
if (n[i]=='/')
{
c=atoi(n.substr(0,i).c_str());
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("1/5", "5/1") == true);
assert (func0("1/6", "2/1") == false);
assert (func0("5/1", "3/1") == true);
assert (func0("7/10", "10/2") == false);
assert (func0("2/10", "50/10") == true);
assert (func0("7/2", "4/2") == true);
assert (fun... | 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 $0x48,%rsp
mov %rdi,%rbp
mov %rsi,%r12
mov %fs:0x28,%ra... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r12, rsi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov rdx, [rdi+8]
test rdx, rdx
jz loc_13CA
mov rbp, rdi
mo... | bool func0(long long *a1, long long *a2)
{
int v2; // r13d
unsigned long long v4; // rdx
unsigned long long i; // rbx
long long v6; // rsi
unsigned long long v7; // rax
unsigned long long v8; // rdx
unsigned long long v9; // rdx
unsigned long long j; // rbx
long long v11; // rsi
unsigned long long ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RDI + 0x8]
TEST RDX,RDX
JZ 0x001013ca
MOV RBP,RDI
MOV EBX,0x0
LEA R15,[RSP + 0x10]
JMP 0x0010130e
LAB_001012ca:
MOV RCX,qword ptr [RSP +... | /* func0(std::string, std::string) */
ulong func0(long *param_1,long *param_2)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
int unaff_R13D;
long in_FS_OFFSET;
int local_74;
int local_70;
int local_6c;
long *local_68 [2];
long local_58 [3];
long local_40;
local_40 = *(long *)(in_... |
578 | func0 | #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| bool func0(string x,string n){
int a,b,c,d,i;
for (i=0;i<x.size();i++)
if (x[i]=='/')
{
a=atoi(x.substr(0,i).c_str());
b=atoi(x.substr(i+1).c_str());
}
for (i=0;i<n.size();i++)
if (n[i]=='/')
{
c=atoi(n.substr(0,i).c_str());
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("1/5", "5/1") == true);
assert (func0("1/6", "2/1") == false);
assert (func0("5/1", "3/1") == true);
assert (func0("7/10", "10/2") == false);
assert (func0("2/10", "50/10") == true);
assert (func0("7/2", "4/2") == true);
assert (fun... | 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
mov %rdi,%r14
push %r13
push %r12
xor %r12d,%r12d
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x48,%rsp
... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rsi
sub rsp, 48h
mov rdx, [rdi+8]
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
test rdx, rdx
jz loc_1BA8
mov r14, rdi
xo... | bool func0(long long *a1, long long *a2)
{
int v2; // r13d
unsigned long long v4; // rdx
unsigned long long v5; // r12
long long v6; // rsi
unsigned long long v7; // rcx
char v8; // al
unsigned long long v9; // rdx
long long v10; // rsi
unsigned long long v11; // rcx
long long v12; // rsi
unsigne... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x48
MOV RDX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
TEST RDX,RDX
JZ 0x00101ba8
MOV R14,RDI
XOR R12D,R12D
LEA R15,[RSP + 0x10]
JMP 0x00101ae9
LAB_00101ae0:
CMP R12,RDX
JNC 0x0010... | /* func0(std::string, std::string) */
ulong func0(long *param_1,long *param_2)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
int unaff_R13D;
long in_FS_OFFSET;
int local_74;
int local_70;
int local_6c;
long *local_68 [2];
long local_58 [3];
long local_40;
uVar2 = param_1[1];
lo... |
579 | func0 | #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| bool func0(string x,string n){
int a,b,c,d,i;
for (i=0;i<x.size();i++)
if (x[i]=='/')
{
a=atoi(x.substr(0,i).c_str());
b=atoi(x.substr(i+1).c_str());
}
for (i=0;i<n.size();i++)
if (n[i]=='/')
{
c=atoi(n.substr(0,i).c_str());
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("1/5", "5/1") == true);
assert (func0("1/6", "2/1") == false);
assert (func0("5/1", "3/1") == true);
assert (func0("7/10", "10/2") == false);
assert (func0("2/10", "50/10") == true);
assert (func0("7/2", "4/2") == true);
assert (fun... | 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
xor %r14d,%r14d
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov $0x1,%ebp
push %rbx
mov %rsi,%rbx
s... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
mov rax, [rdi+8]
test rax, rax
jz loc_1BC8
lea rbx, [rsp+98h+var_68]
mov ... | bool func0(long long a1, long long a2)
{
int v2; // r14d
int v3; // r15d
unsigned long long v5; // rax
unsigned long long v7; // r13
_BYTE *v8; // rcx
unsigned long long v9; // rsi
char v10; // dl
size_t v11; // r14
_QWORD *v12; // rax
unsigned long long v13; // r14
_BYTE *v14; // rcx
size_t v1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x00101bc8
LEA RBX,[RSP + 0x30]
MOV RBP,RDI
XOR R13D,R13D
MOV qword ptr [RSP + 0x10],RBX
JMP 0x00101ac1
LAB_00101ab8:
CMP... | /* func0(std::string, std::string) */
ulong func0(long *param_1,long *param_2)
{
int *puVar1;
long lVar2;
long *plVar3;
long *plVar4;
int unaff_R14D;
long *plVar5;
int unaff_R15D;
long in_FS_OFFSET;
int local_98;
int local_90;
long *local_70;
long **local_68;
long *local_60;
long *local_58... |
580 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> nums){
vector<int> sumdigit={};
for (int i=0;i<nums.size();i++)
{
string w=to_string(abs(nums[i]));
int sum=0;
for (int j=1;j<w.length();j++)
sum+=w[j]-48;
if (nums[i]>0) sum+=w[0]-48;
else sum-=w[0]-48;
sumdigit.push_... | #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, 11, -1, -11, -12}) , {-1, -11, 1, -12, 11}));
assert (issame... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x88,%rsp
mov %rdi,-0x88(%rbp)
mov %rsi,-0x90(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movq $0x0,-0x60(%rbp)
movq $0x0,-0x58(%rbp)
movq $0x0,-0x50(%rbp)
lea -0x60(%rbp),%rax
... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_88], rdi
mov [rbp+var_90], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
pxor xmm0, xmm0
movaps [rbp+var_60], xmm0
movq [rbp+var_50], xmm0
lea rax, [rbp+var_60]
mov rdi, ... | long long func0(long long a1, long long a2)
{
int v2; // eax
int v3; // edx
char *v4; // rax
unsigned long long v5; // rbx
char *v6; // rax
char *v7; // rax
unsigned long long v8; // rbx
int v9; // ebx
int v10; // ebx
int v11; // ebx
int v12; // ebx
int v13; // ebx
unsigned long long v14; // ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x88],RDI
MOV qword ptr [RBP + -0x90],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x60],XMM0
MOVQ qword ptr [RBP + -0x50],XMM0
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL ... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int iVar1;
int4 uVar2;
int4 uVar3;
char *pcVar4;
ulong uVar5;
int *piVar6;
int4 *puVar7;
ulong uVar8;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
long in_FS_OFFSE... |
581 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> nums){
vector<int> sumdigit={};
for (int i=0;i<nums.size();i++)
{
string w=to_string(abs(nums[i]));
int sum=0;
for (int j=1;j<w.length();j++)
sum+=w[j]-48;
if (nums[i]>0) sum+=w[0]-48;
else sum-=w[0]-48;
sumdigit.push_... | #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, 11, -1, -11, -12}) , {-1, -11, 1, -12, 11}));
assert (issame... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x60,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
mov (%rsi),%rsi
mov ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 138h
mov r15, rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+168h+var_40], rax
xor eax, eax
mov [rsp+168h+var_158], 0
mov [rsp+168h+var_150], 0
mov [rsp+168h+var_148], 0
mov... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v3; // rax
unsigned long long v4; // r13
unsigned int v5; // ebx
_BYTE *v6; // rcx
int v7; // ebp
char v8; // bp
char *v9; // rax
int v10; // edx
int v11; // eax
int *v12; // rsi
int v13; // eax
unsigned int v14; // ebp
unsigned int v15; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x138
MOV R15,RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],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... | /* func0(std::vector<int, std::allocator<int> >) */
long * func0(vector param_1)
{
int4 *puVar1;
int iVar2;
int4 uVar3;
int *piVar4;
uint uVar5;
char *pcVar6;
long lVar7;
long *plVar8;
long lVar9;
uint uVar10;
uint uVar11;
ulong uVar12;
int *piVar13;
uint uVar14;
char cVar15;
ulong uVa... |
582 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> nums){
vector<int> sumdigit={};
for (int i=0;i<nums.size();i++)
{
string w=to_string(abs(nums[i]));
int sum=0;
for (int j=1;j<w.length();j++)
sum+=w[j]-48;
if (nums[i]>0) sum+=w[0]-48;
else sum-=w[0]-48;
sumdigit.push_... | #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, 11, -1, -11, -12}) , {-1, -11, 1, -12, 11}));
assert (issame... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x78,%rsp
mov (%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
movq $0x0,0x3... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
sub rsp, 158h
mov r8, [rsi]
mov [rsp+188h+var_170], rdi
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
movaps xmmword ptr [rsp+188h+var_158], x... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v3; // r8
unsigned long long v4; // rbx
char *v5; // r15
int v6; // edx
unsigned int v7; // r14d
int v8; // r8d
long long v9; // rsi
unsigned int v10; // r8d
_BYTE *v11; // rsi
long long v12; // r8
unsigned int v13; // edx
unsigned int v14; /... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
SUB RSP,0x158
MOV R8,qword ptr [RSI]
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOV qword ptr [RSP + 0x40],0x0
CMP qword ptr [R... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1)
{
uint uVar1;
int4 uVar2;
int8 uVar3;
int4 *puVar4;
char *pcVar5;
int *piVar6;
uint uVar7;
uint uVar8;
int4 *puVar9;
ulong uVar10;
... |
583 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> nums){
vector<int> sumdigit={};
for (int i=0;i<nums.size();i++)
{
string w=to_string(abs(nums[i]));
int sum=0;
for (int j=1;j<w.length();j++)
sum+=w[j]-48;
if (nums[i]>0) sum+=w[0]-48;
else sum-=w[0]-48;
sumdigit.push_... | #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, 11, -1, -11, -12}) , {-1, -11, 1, -12, 11}));
assert (issame... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x78,%rsp
mov (%rsi),%rdx
mov %rdi,(%rsp)
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
movaps %xmm0,0x20(%rsp)
movq $0x0,0x30... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
sub rsp, 158h
mov [rsp+188h+var_170], rdi
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
mov rax, [rsi]
movaps xmmword ptr [rsp+188h+var_158], ... | _QWORD * func0(_QWORD *a1, long long *a2)
{
__m128i v2; // xmm0
long long v4; // rax
unsigned long long v5; // rbx
char *v6; // r15
int v7; // edx
unsigned int v8; // r14d
int v9; // r8d
long long v10; // rsi
unsigned int v11; // r8d
_BYTE *v12; // rsi
long long v13; // r8
unsigned int v14; // e... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
SUB RSP,0x158
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOV qword ptr [RSP + 0x40],0x0
CMP qword ptr [... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1)
{
uint uVar1;
int4 *puVar2;
int auVar3 [14];
int auVar4 [12];
unkbyte10 Var5;
int auVar6 [12];
int auVar7 [12];
int auVar8 [14];
int a... |
584 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> nums){
int num=0;
for (int i=0;i<nums.size();i++)
if (nums[i]>10)
{
string w=to_string(nums[i]);
if (w[0]%2==1 and w[w.length()-1]%2==1) num+=1;
}
return num;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, -2, 1, -5}) == 0 );
assert (func0({15, -73, 14, -15}) == 1);
assert (func0({33, -2, -3, 45, 21, 109}) == 2);
assert (func0({43, -12, 93, 125, 121, 109}) == 4);
assert (func0({71, -2, -33, 75, 21, 19}) == 3);
assert (func0({1}) == 0... | 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 %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x48(%rbp)
movl $0x0,-0x44(%rbp)
mov -0x44(%rbp),%eax
movslq %eax,%rbx
mov -0x58(%rbp),%rax
mov ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_48], 0
mov [rbp+var_44], 0
jmp loc_1406
loc_133C:
mov eax, [rbp+var_44]
movsxd rdx, eax
mov rax, [rbp+va... | long long func0(long long a1)
{
int *v1; // rax
long long v2; // rax
unsigned int v5; // [rsp+18h] [rbp-48h]
int i; // [rsp+1Ch] [rbp-44h]
_BYTE v7[40]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+48h] [rbp-18h]
v8 = __readfsqword(0x28u);
v5 = 0;
for ( i = 0; i < (unsigned long long)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x48],0x0
MOV dword ptr [RBP + -0x44],0x0
JMP 0x00101406
LAB_0010133c:
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
MOV RAX,qword ptr ... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
bool bVar1;
int *piVar2;
char *pcVar3;
ulong uVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_50;
int local_4c;
string local_48 [40];
long local_20;
this = (v... |
585 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> nums){
int num=0;
for (int i=0;i<nums.size();i++)
if (nums[i]>10)
{
string w=to_string(nums[i]);
if (w[0]%2==1 and w[w.length()-1]%2==1) num+=1;
}
return num;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, -2, 1, -5}) == 0 );
assert (func0({15, -73, 14, -15}) == 1);
assert (func0({33, -2, -3, 45, 21, 109}) == 2);
assert (func0({43, -12, 93, 125, 121, 109}) == 4);
assert (func0({71, -2, -33, 75, 21, 19}) == 3);
assert (func0({1}) == 0... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov (%rdi),%rdx
cmp %rdx,0x8(%rdi)
je 12f4 <_Z5func0St6vectorIiSaIiEE+0xcb>
mov %rdi,%rbp
mov $0x0,%ebx
mov $0x0,%r12d
... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 108h
mov rax, fs:28h
mov [rsp+138h+var_40], rax
xor eax, eax
mov rdx, [rdi]
cmp [rdi+8], rdx
jz loc_1783
mov r14, rdi
mov r12d, 0
mov r15d, 0
jmp loc_16DB
loc_... | long long func0(long long *a1)
{
long long v1; // rdx
long long v2; // r12
unsigned int v3; // r15d
unsigned int v4; // ebx
char *v5; // rcx
unsigned int v6; // eax
unsigned int v7; // edx
unsigned int v8; // esi
unsigned int v9; // ebp
char v10; // al
int v11; // ebp
unsigned int v12; // r13d
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x108
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RDI]
CMP qword ptr [RDI + 0x8],RDX
JZ 0x00101783
MOV R14,RDI
MOV R12D,0x0
MOV R15D,0x0
JMP 0x001016db
LAB_00101272:
MOV EBX,0x1
LAB_00101277:
MOV R... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
ulong uVar1;
char cVar2;
uint uVar3;
long *plVar4;
uint uVar5;
uint uVar6;
long lVar7;
uint uVar8;
ulong uVar9;
int4 in_register_0000003c;
long *plVar10;
ulong uVar11;
int iVar12;
long in_FS_OFFSET;
long *loc... |
586 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> nums){
int num=0;
for (int i=0;i<nums.size();i++)
if (nums[i]>10)
{
string w=to_string(nums[i]);
if (w[0]%2==1 and w[w.length()-1]%2==1) num+=1;
}
return num;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, -2, 1, -5}) == 0 );
assert (func0({15, -73, 14, -15}) == 1);
assert (func0({33, -2, -3, 45, 21, 109}) == 2);
assert (func0({43, -12, 93, 125, 121, 109}) == 4);
assert (func0({71, -2, -33, 75, 21, 19}) == 3);
assert (func0({1}) == 0... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov (%rdi),%rdx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
cmp 0x8(%rdi),%rdx
je 16d0 <_Z5func0St6vectorIiSaIiEE+0xd0>
mov %rdi,%r13
xor %ebx,%ebx
xor %r12d,%r12d... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 108h
mov rdx, [rdi]
mov rax, fs:28h
mov [rsp+138h+var_40], rax
xor eax, eax
cmp [rdi+8], rdx
jz loc_186F
mov r14, rdi
xor r13d, r13d
xor ebp, ebp
jmp short loc... | long long func0(long long *a1)
{
long long v1; // rdx
long long v3; // r13
unsigned int v4; // ebp
unsigned int v5; // ebx
unsigned int v6; // r12d
long long v7; // rsi
__int8 *v8; // rcx
unsigned int v9; // eax
unsigned int v10; // esi
long long v11; // rax
long long v12; // rdi
long long v13;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x108
MOV RDX,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
CMP qword ptr [RDI + 0x8],RDX
JZ 0x0010186f
MOV R14,RDI
XOR R13D,R13D
XOR EBP,EBP
JMP 0x00101548
LAB_00101530:
MOV RAX,qword ptr [R14 + 0x8]
A... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
uint uVar1;
char cVar2;
uint uVar3;
long lVar4;
uint uVar5;
int iVar6;
int4 in_register_0000003c;
long *plVar7;
uint uVar8;
ulong uVa... |
587 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> nums){
int num=0;
for (int i=0;i<nums.size();i++)
if (nums[i]>10)
{
string w=to_string(nums[i]);
if (w[0]%2==1 and w[w.length()-1]%2==1) num+=1;
}
return num;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, -2, 1, -5}) == 0 );
assert (func0({15, -73, 14, -15}) == 1);
assert (func0({33, -2, -3, 45, 21, 109}) == 2);
assert (func0({43, -12, 93, 125, 121, 109}) == 4);
assert (func0({71, -2, -33, 75, 21, 19}) == 3);
assert (func0({1}) == 0... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov (%rdi),%rdx
mov 0x8(%rdi),%rcx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
cmp %rcx,%rdx
je 17c8 <_Z5func0St6vectorIiSaIiEE+0xd8>
mov %rdi,%r13
xor %ebx,%ebx
x... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 108h
mov rcx, [rdi+8]
mov rdx, [rdi]
mov rax, fs:28h
mov [rsp+138h+var_40], rax
xor eax, eax
cmp rcx, rdx
jz loc_187F
mov rbp, rdi
xor r14d, r14d
xor r12d, r12... | long long func0(long long *a1)
{
long long v1; // rcx
long long v2; // rdx
long long v4; // r14
unsigned int v5; // r12d
unsigned int v6; // ebx
unsigned int v7; // r13d
long long v8; // rsi
__int8 *v9; // rcx
unsigned int v10; // eax
unsigned int v11; // esi
long long v12; // rax
long long v13... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x108
MOV RCX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
CMP RCX,RDX
JZ 0x0010187f
MOV RBP,RDI
XOR R14D,R14D
XOR R12D,R12D
JMP 0x0010154f
LAB_00101538:
MOV RAX,RCX
ADD R... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
uint uVar1;
char cVar2;
long lVar3;
uint uVar4;
long lVar5;
uint uVar6;
int4 in_register_0000003c;
long *plVar7;
int iVar8;
uint uVar... |
588 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| int func0(int n){
vector<int> a;
vector<vector<int>> sum={{0,0,0}};
vector<vector<int>> sum2={{0,0,0}};
for (int i=1;i<=n;i++)
{
a.push_back((i*i-i+1)%3);
sum.push_back(sum[sum.size()-1]);
sum[i][a[i-1]]+=1;
}
for (int times=1;times<3;times++)
{
for (int i=1;i... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 1);
assert (func0(6) == 4);
assert (func0(10) == 36);
assert (func0(100) == 53361);
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x108,%rsp
mov %edi,-0xe4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea -0xc0(%rbp),%rax
mov %rax,%rdi
callq 1afa <_ZNSt6vectorIiSaIiEEC1Ev>
movl $0x0,-0x5c(%rbp)
mo... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 138h
mov [rbp+var_104], edi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea rax, [rbp+var_C0]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(vo... | long long func0(int a1)
{
_BYTE *i; // rbx
_BYTE *j; // rbx
long long v3; // rax
long long v4; // rax
long long v5; // rbx
int *v6; // rax
_DWORD *v7; // rax
long long v8; // rax
long long v9; // rax
long long v10; // rax
int v11; // ebx
long long v12; // r12
_DWORD *v13; // rax
_DWORD *v14... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x138
MOV dword ptr [RBP + -0x104],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xc0]
MOV RDI,RAX
CALL 0x00101c06
LEA R14,[RBP + -0x50]
MOV R15D,0x0
MOV R8,R14
MOV dword ptr [RBP + -0x... | /* func0(int) */
int4 func0(int param_1)
{
int iVar1;
int4 uVar2;
long lVar3;
vector *pvVar4;
int *piVar5;
int4 *puVar6;
vector<int,std::allocator<int>> *pvVar7;
long in_FS_OFFSET;
__new_allocator<int> local_105;
int local_104;
int local_100;
int local_fc;
int local_f8;
int local_f4;
int... |
589 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| int func0(int n){
vector<int> a;
vector<vector<int>> sum={{0,0,0}};
vector<vector<int>> sum2={{0,0,0}};
for (int i=1;i<=n;i++)
{
a.push_back((i*i-i+1)%3);
sum.push_back(sum[sum.size()-1]);
sum[i][a[i-1]]+=1;
}
for (int times=1;times<3;times++)
{
for (int i=1;i... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 1);
assert (func0(6) == 4);
assert (func0(10) == 36);
assert (func0(100) == 53361);
}
| O1 | cpp | func0(int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xb8,%rsp
mov %edi,%r14d
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
movq $0x0,0x30(%rsp)
movl $0x0,0x90(%rsp)
movl $0x0,0x94(%rsp)
movl $0x0,0x98... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov [rsp+0E8h+var_E0], edi
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
xor eax, eax
mov [rsp+0E8h+var_C8], 0
mov [rsp+0E8h+var_C0], 0
mov [rsp+0E8h+var_B8], 0
mov dword ptr [rsp+0E... | long long func0(int a1)
{
char *v1; // rax
char *v2; // rax
long long v3; // r13
struct _Unwind_Exception *v4; // rbx
_DWORD *v5; // rbp
_DWORD *v6; // rsi
long long v7; // r12
int *v8; // rsi
char *v9; // rbx
char *v10; // r14
unsigned long long v11; // r12
long long v12; // r15
int v13; // ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV dword ptr [RSP + 0x8],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV dword ptr [RSP + 0x84],0x0
MOV dword ptr... | /* func0(int) */
int4 func0(int param_1)
{
vector *pvVar1;
int *piVar2;
int4 uVar3;
int4 *puVar4;
void *pvVar5;
vector *pvVar6;
vector *pvVar7;
int8 uVar8;
int4 *puVar9;
int8 *puVar10;
long lVar11;
vector *pvVar12;
size_t sVar13;
ulong uVar14;
int iVar15;
long lVar16;
long in_FS_OFFS... |
590 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| int func0(int n){
vector<int> a;
vector<vector<int>> sum={{0,0,0}};
vector<vector<int>> sum2={{0,0,0}};
for (int i=1;i<=n;i++)
{
a.push_back((i*i-i+1)%3);
sum.push_back(sum[sum.size()-1]);
sum[i][a[i-1]]+=1;
}
for (int times=1;times<3;times++)
{
for (int i=1;i... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 1);
assert (func0(6) == 4);
assert (func0(10) == 36);
assert (func0(100) == 53361);
}
| O2 | cpp | func0(int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xb8,%rsp
mov %edi,0xc(%rsp)
mov $0xc,%edi
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
movq $0x0,0x90(%rsp)
movl $0x0,0x98(%rsp)
callq 1160 <_Znwm@plt>
mov %rax,%rbp
mov $0x18,%edi
mov ... | _Z5func0i:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0F8h
mov [rsp+128h+var_E0], edi
mov edi, 0Ch; unsigned __int64
mov rax, fs:28h
mov [rsp+128h+var_40], rax
xor eax, eax
movaps xmmword ptr [rsp+128h+var_C8], xmm0
mov [rsp+1... | long long func0(int a1)
{
_DWORD *v1; // rbx
_DWORD *v2; // rbx
char *v3; // r13
long long v4; // r8
long long v5; // r9
long long v6; // r14
void **k; // rbp
unsigned int *v8; // rdi
unsigned int *v9; // rsi
_DWORD *v10; // rcx
_DWORD *v11; // rsi
long long v12; // r12
char *v13; // rbx
_D... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xf8
MOV dword ptr [RSP + 0x48],EDI
MOV EDI,0xc
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xe8],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOV qword ptr [RSP + 0x70],0x0
MOV qword ptr [RSP + 0xc0],0x0
MOV dword ... | /* func0(int) */
int4 func0(int param_1)
{
long lVar1;
int *piVar2;
int4 uVar3;
int4 *puVar4;
long lVar5;
long lVar6;
void *pvVar7;
int8 uVar8;
int8 *puVar9;
vector *pvVar10;
vector<int,std::allocator<int>> *pvVar11;
int4 *puVar12;
vector<int,std::allocator<int>> *pvVar13;
int iVar14;
lo... |
591 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| int func0(int n){
vector<int> a;
vector<vector<int>> sum={{0,0,0}};
vector<vector<int>> sum2={{0,0,0}};
for (int i=1;i<=n;i++)
{
a.push_back((i*i-i+1)%3);
sum.push_back(sum[sum.size()-1]);
sum[i][a[i-1]]+=1;
}
for (int times=1;times<3;times++)
{
for (int i=1;i... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 1);
assert (func0(6) == 4);
assert (func0(10) == 36);
assert (func0(100) == 53361);
}
| O3 | cpp | func0(int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xb8,%rsp
mov %edi,0xc(%rsp)
mov $0xc,%edi
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
movq $0x0,0x90(%rsp)
movl $0x0,0x98(%rsp)
callq 1160 <_Znwm@plt>
mov %rax,%rbp
pxor %xmm0,%xmm0
mov ... | _Z5func0i:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 118h
mov [rsp+148h+var_144], edi
mov edi, 0Ch; unsigned __int64
mov rax, fs:28h
mov [rsp+148h+var_40], rax
xor eax, eax
movaps xmmword ptr [rsp+148h+var_C8], xmm0
mov [rsp+... | long long func0(int a1)
{
_DWORD *v1; // r14
_DWORD *v2; // rbx
_DWORD *v3; // rbx
long long v4; // r13
_QWORD *v5; // rbp
unsigned int *v6; // rcx
unsigned int *v7; // rsi
_DWORD *v8; // rcx
_DWORD *v9; // rsi
long long v10; // r12
long long v11; // rbx
long long v12; // rbx
_QWORD *v13; // ... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x118
MOV dword ptr [RSP + 0x4],EDI
MOV EDI,0xc
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x108],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOV qword ptr [RSP + 0x90],0x0
MOV qword ptr [RSP + 0xe0],0x0
MOV dword... | /* func0(int) */
int4 func0(int param_1)
{
int *piVar1;
int4 uVar2;
int *piVar3;
long lVar4;
void *pvVar5;
int4 *puVar6;
int iVar7;
int8 uVar8;
int8 *puVar9;
vector *pvVar10;
vector *pvVar11;
vector *pvVar12;
int4 *puVar13;
uint *puVar14;
vector *pvVar15;
long lVar16;
ulong uVar17;
... |
592 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string planet1,string planet2){
vector<string> planets={"Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
int pos1=-1,pos2=-1,m;
for (m=0;m<planets.size();m++)
{
if (planets[m]==planet1) pos1=m;
if (planets[m]==planet2) pos2=m;
}
if (pos1==-1 o... | #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("Jupiter", "Neptune") , {"Saturn", "Uranus"}));
assert (is... | 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 %r13
push %r12
push %rbx
sub $0x198,%rsp
mov %rdi,-0x198(%rbp)
mov %rsi,-0x1a0(%rbp)
mov %r... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0D8h
mov [rbp+var_C8], rdi
mov [rbp+var_D0], rsi
mov [rbp+var_D8], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, aMercury; "Mercury"
mov [rbp+v... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rax
long long v5; // rax
int v8; // [rsp+2Ch] [rbp-B4h]
int v9; // [rsp+30h] [rbp-B0h]
int i; // [rsp+34h] [rbp-ACh]
int v11; // [rsp+34h] [rbp-ACh]
int j; // [rsp+34h] [rbp-ACh]
_BYTE v13[32]; // [rsp+4... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xd8
MOV qword ptr [RBP + -0xc8],RDI
MOV qword ptr [RBP + -0xd0],RSI
MOV qword ptr [RBP + -0xd8],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[0x105008]
MOV qword ptr [RBP + -0x60],RAX
LEA RAX,[0x105010]
MOV qword ptr [RBP + -0x... | /* func0(std::string, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,string *param_2,string *param_3)
{
int iVar1;
bool bVar2;
ulong uVar3;
string *psVar4;
long in_FS_OFFSET;
int local_bc;
int local_b8;
int local_b4;
v... |
593 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string planet1,string planet2){
vector<string> planets={"Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
int pos1=-1,pos2=-1,m;
for (m=0;m<planets.size();m++)
{
if (planets[m]==planet1) pos1=m;
if (planets[m]==planet2) pos2=m;
}
if (pos1==-1 o... | #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("Jupiter", "Neptune") , {"Saturn", "Uranus"}));
assert (is... | 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 $0x188,%rsp
mov %rdi,0x28(%rsp)
mov %rsi,0x18(%rsp)
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0D8h
mov [rsp+108h+var_E0], rdi
mov [rsp+108h+var_F0], rsi
mov [rsp+108h+var_E8], rdx
mov rax, fs:28h
mov [rsp+108h+var_40], rax
xor eax, ... | long long func0(long long a1, long long a2, long long a3)
{
const void **v3; // rbp
long long v4; // r13
long long v5; // r15
long long v6; // r14
const void **v7; // rbx
unsigned long long v8; // r12
int v9; // r13d
const void *v10; // rsi
const void *v11; // rdi
bool v12; // zf
int v13; // eax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xd8
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc8],RAX
XOR EAX,EAX
LEA RAX,[0x103254]
MOV qword ptr [RSP + 0x80],RAX
LEA RAX,[0x10325c]
MOV q... | /* func0(std::string, std::string) */
int (*) [16] func0(int (*param_1) [16],int8 *param_2,int8 *param_3)
{
size_t sVar1;
size_t sVar2;
size_t __n;
long *plVar3;
int iVar4;
int iVar5;
string *psVar6;
string *psVar7;
string *psVar8;
string *psVar9;
void *__s2;
void *__s1;
int iVar10;
int iV... |
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.