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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
294 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> arr){
int out=0;
for (int i=0;i<arr.size()-1-i;i++)
if (arr[i]!=arr[arr.size()-1-i])
out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3,5,4,7,9,6}) == 4);
assert (func0({1, 2, 3, 4, 3, 2, 2}) == 1);
assert (func0({1, 4, 2}) == 1);
assert (func0({1, 4, 4, 2}) == 1);
assert (func0({1, 2, 3, 2, 1}) == 0);
assert (func0({3, 1, 1, 3}) == 0);
assert (func0({1}) == ... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rax
sub %rcx,%rax
sar $0x2,%rax
sub $0x1,%rax
je 17b0 <_Z5func0St6vectorIiSaIiEE+0x40>
xor %edx,%edx
xor %r8d,%r8d
nopl (%rax)
mov (%rcx,%rax,4),%esi
cmp %esi,(%rcx,%rdx,4)
je 179c <_Z5func0St6vect... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rcx, [rdi]
mov rax, [rdi+8]
sub rax, rcx
sar rax, 2
sub rax, 1
jz short loc_1580
xor edx, edx
xor esi, esi
nop dword ptr [rax+00h]
loc_1560:
mov edi, [rcx+rdx*4]
cmp [rcx+rax*4], edi
jz short loc_156B
add esi, 1
loc_156B:
add ... | long long func0(_QWORD *a1)
{
unsigned long long v1; // rax
unsigned long long v2; // rdx
unsigned int v3; // esi
v1 = ((long long)(a1[1] - *a1) >> 2) - 1;
if ( (long long)(a1[1] - *a1) >> 2 == 1 )
return 0LL;
v2 = 0LL;
v3 = 0;
do
{
if ( *(_DWORD *)(*a1 + 4 * v1) != *(_DWORD *)(*a1 + 4 * v2)... | func0:
ENDBR64
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RCX
SAR RAX,0x2
SUB RAX,0x1
JZ 0x00101580
XOR EDX,EDX
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_00101560:
MOV EDI,dword ptr [RCX + RDX*0x4]
CMP dword ptr [RCX + RAX*0x4],EDI
JZ 0x0010156b
ADD ESI,0x1
LAB_0010156b:
ADD RDX,0x1
SUB RAX,0x1
CMP RDX,RAX... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
long lVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
int4 in_register_0000003c;
lVar1 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar2 = (((long *)CONCAT44(in_register_0000003c,param_1))[1] - lVar1 >> 2) - 1;
if (uV... |
295 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> arr){
int out=0;
for (int i=0;i<arr.size()-1-i;i++)
if (arr[i]!=arr[arr.size()-1-i])
out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3,5,4,7,9,6}) == 4);
assert (func0({1, 2, 3, 4, 3, 2, 2}) == 1);
assert (func0({1, 4, 2}) == 1);
assert (func0({1, 4, 4, 2}) == 1);
assert (func0({1, 2, 3, 2, 1}) == 0);
assert (func0({3, 1, 1, 3}) == 0);
assert (func0({1}) == ... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rax
sub %rcx,%rax
sar $0x2,%rax
sub $0x1,%rax
je 17f0 <_Z5func0St6vectorIiSaIiEE+0x40>
xor %edx,%edx
xor %r8d,%r8d
nopl (%rax)
mov (%rcx,%rax,4),%esi
cmp %esi,(%rcx,%rdx,4)
je 17dc <_Z5func0St6vect... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rcx, [rdi]
mov rax, [rdi+8]
sub rax, rcx
sar rax, 2
sub rax, 1
jz short loc_1720
xor edx, edx
xor esi, esi
nop dword ptr [rax+00h]
loc_1700:
mov edi, [rcx+rdx*4]
cmp [rcx+rax*4], edi
jz short loc_170B
add esi, 1
loc_170B:
add ... | long long func0(_QWORD *a1)
{
unsigned long long v1; // rax
unsigned long long v2; // rdx
unsigned int v3; // esi
v1 = ((long long)(a1[1] - *a1) >> 2) - 1;
if ( (long long)(a1[1] - *a1) >> 2 == 1 )
return 0LL;
v2 = 0LL;
v3 = 0;
do
{
if ( *(_DWORD *)(*a1 + 4 * v1) != *(_DWORD *)(*a1 + 4 * v2)... | func0:
ENDBR64
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RCX
SAR RAX,0x2
SUB RAX,0x1
JZ 0x00101720
XOR EDX,EDX
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_00101700:
MOV EDI,dword ptr [RCX + RDX*0x4]
CMP dword ptr [RCX + RAX*0x4],EDI
JZ 0x0010170b
ADD ESI,0x1
LAB_0010170b:
ADD RDX,0x1
SUB RAX,0x1
CMP RDX,RAX... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
long lVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
int4 in_register_0000003c;
lVar1 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar2 = (((long *)CONCAT44(in_register_0000003c,param_1))[1] - lVar1 >> 2) - 1;
if (uV... |
296 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(vector<string> lst1,vector<string> lst2){
int num1,num2,i;
num1=0;num2=0;
for (i=0;i<lst1.size();i++)
num1+=lst1[i].length();
for (i=0;i<lst2.size();i++)
num2+=lst2[i].length();
if (num1>num2) return lst2;
return lst1;
}
| #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({}, {}) , {}));
assert (issame(func0({"hi", "admin"}, {"hi... | O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11:... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES7_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_24E... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rax
int v7; // [rsp+24h] [rbp-1Ch]
int v8; // [rsp+28h] [rbp-18h]
int i; // [rsp+2Ch] [rbp-14h]
int j; // [rsp+2Ch] [rbp-14h]
v7 = 0;
v8 = 0;
for ( i = 0; i < (unsigned long long)std::vector<std::string... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001024e4
LAB_001024b9:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RD... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::vector<std::string,
std::allocator<std::string > >) */
vector<std::string,std::allocator<std::string>> * func0(vector param_1,vector param_2)
{
int iVar1;
ulong uVar2;
vector<std::string,std::allocator<std::string>> *in_RDX;
int4 in_reg... |
297 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(vector<string> lst1,vector<string> lst2){
int num1,num2,i;
num1=0;num2=0;
for (i=0;i<lst1.size();i++)
num1+=lst1[i].length();
for (i=0;i<lst2.size();i++)
num2+=lst2[i].length();
if (num1>num2) return lst2;
return lst1;
}
| #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({}, {}) , {}));
assert (issame(func0({"hi", "admin"}, {"hi... | O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11:... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES7_:
endbr64
push r12
push rbp
push rbx
mov r10, rdi
mov r11, rsi
mov rbx, rdx
mov rbp, [rsi+8]
mov rdi, [rsi]
mov rsi, rbp
sub rsi, rdi
sar rsi, 5
cmp rbp, rdi
jz loc_13B9
mov eax, 0
mov ... | _QWORD * func0(_QWORD *a1, long long *a2, long long *a3)
{
long long v6; // rbp
long long v7; // rdi
unsigned long long v8; // rsi
unsigned long long v9; // rax
int v10; // ecx
long long v11; // r12
long long v12; // r8
unsigned long long v13; // rax
int v14; // edx
v6 = a2[1];
v7 = *a2;
v8 = (... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R10,RDI
MOV R11,RSI
MOV RBX,RDX
MOV RBP,qword ptr [RSI + 0x8]
MOV RDI,qword ptr [RSI]
MOV RSI,RBP
SUB RSI,RDI
SAR RSI,0x5
CMP RBP,RDI
JZ 0x001013b9
MOV EAX,0x0
MOV ECX,0x0
LAB_0010133e:
MOV RDX,RAX
SHL RDX,0x5
ADD ECX,dword ptr [RDI + RDX*0x1 + 0x8]
ADD RAX,0x1
CMP RAX,RSI
... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::vector<std::string,
std::allocator<std::string > >) */
long * func0(vector param_1,vector param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
int iVar4;
int iVar5;
long *in_RDX;
long lVar6;
int4 in_register_00000034;
long *plVar7;... |
298 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(vector<string> lst1,vector<string> lst2){
int num1,num2,i;
num1=0;num2=0;
for (i=0;i<lst1.size();i++)
num1+=lst1[i].length();
for (i=0;i<lst2.size();i++)
num2+=lst2[i].length();
if (num1>num2) return lst2;
return lst1;
}
| #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({}, {}) , {}));
assert (issame(func0({"hi", "admin"}, {"hi... | O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11:... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES7_:
endbr64
movdqu xmm0, xmmword ptr [rsi]
mov r10, rdx
mov r8, rdi
mov r9, rsi
movhlps xmm2, xmm0
movq rax, xmm0
movq rdx, xmm2
mov rcx, rdx
sub rcx, rax
sar rcx, 5
cmp rdx, rax
jz loc_1D30
xor ed... | __m128 * func0(__m128 *a1, const __m128i *a2, const __m128i *a3, double a4, double a5, __m128 a6, __m128 a7)
{
__m128 v7; // xmm0
unsigned long long v11; // rax
unsigned long long v12; // rdx
unsigned long long v13; // rcx
unsigned long long v14; // rdx
int v15; // esi
__m128 v16; // xmm1
unsigned long ... | func0:
ENDBR64
MOVDQU XMM0,xmmword ptr [RSI]
MOV R10,RDX
MOV R8,RDI
MOV R9,RSI
MOVHLPS XMM2,XMM0
MOVQ RAX,XMM0
MOVQ RDX,XMM2
MOV RCX,RDX
SUB RCX,RAX
SAR RCX,0x5
CMP RDX,RAX
JZ 0x00101d30
XOR EDX,EDX
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_00101c98:
ADD RDX,0x1
ADD ESI,dword ptr [RAX + 0x8]
ADD RAX,0x20
CMP RDX,RCX
JC 0x001... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::vector<std::string,
std::allocator<std::string > >) */
long * func0(vector param_1,vector param_2)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
int iVar6;
int (*in_RDX) [16];
ulong uVar7;
int iVar8;
int4 in_... |
299 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(vector<string> lst1,vector<string> lst2){
int num1,num2,i;
num1=0;num2=0;
for (i=0;i<lst1.size();i++)
num1+=lst1[i].length();
for (i=0;i<lst2.size();i++)
num2+=lst2[i].length();
if (num1>num2) return lst2;
return lst1;
}
| #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({}, {}) , {}));
assert (issame(func0({"hi", "admin"}, {"hi... | O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11:... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES7_:
endbr64
movdqu xmm0, xmmword ptr [rsi]
mov r10, rdx
mov r8, rdi
mov r9, rsi
movhlps xmm2, xmm0
movq rax, xmm0
movq rdx, xmm2
mov rcx, rdx
sub rcx, rax
sar rcx, 5
cmp rdx, rax
jz loc_1D30
xor ed... | __m128 * func0(__m128 *a1, const __m128i *a2, const __m128i *a3, double a4, double a5, __m128 a6, __m128 a7)
{
__m128 v7; // xmm0
unsigned long long v11; // rax
unsigned long long v12; // rdx
unsigned long long v13; // rcx
unsigned long long v14; // rdx
int v15; // esi
__m128 v16; // xmm1
unsigned long ... | func0:
ENDBR64
MOVDQU XMM0,xmmword ptr [RSI]
MOV R10,RDX
MOV R8,RDI
MOV R9,RSI
MOVHLPS XMM2,XMM0
MOVQ RAX,XMM0
MOVQ RDX,XMM2
MOV RCX,RDX
SUB RCX,RAX
SAR RCX,0x5
CMP RDX,RAX
JZ 0x00101d30
XOR EDX,EDX
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_00101c98:
ADD RDX,0x1
ADD ESI,dword ptr [RAX + 0x8]
ADD RAX,0x20
CMP RDX,RCX
JC 0x001... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::vector<std::string,
std::allocator<std::string > >) */
long * func0(vector param_1,vector param_2)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
int iVar6;
int (*in_RDX) [16];
ulong uVar7;
int iVar8;
int4 in_... |
300 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int a){
int num=0;
for (int i=2;i*i<=a;i++)
while (a%i==0 and a>i)
{
a=a/i;
num+=1;
}
if (num==2) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == false);
assert (func0(30) == true);
assert (func0(8) == true);
assert (func0(10) == false);
assert (func0(125) == true);
assert (func0(3 * 5 * 7) == true);
assert (func0(3 * 6 * 7) == false);
assert (func0(9 * 9 * 9) == fa... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x2,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jl 1198 <_Z5func0i+0x4f>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1192 <_Z5func0i+0x49... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 2
jmp short loc_118B
loc_1164:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov [rbp+var_14], eax
add [rbp+var_8], 1
loc_1172:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov ... | _BOOL8 func0(int a1)
{
int v3; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v3 = 0;
for ( i = 2; a1 >= i * i; ++i )
{
while ( !(a1 % i) && a1 > i )
{
a1 /= i;
++v3;
}
}
return v3 == 2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0010118b
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x14],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_00101172:
MOV EAX,dword ptr [R... | /* func0(int) */
bool func0(int param_1)
{
int local_1c;
int local_10;
int local_c;
local_10 = 0;
local_1c = param_1;
for (local_c = 2; local_c * local_c <= local_1c; local_c = local_c + 1) {
for (; (local_1c % local_c == 0 && (local_c < local_1c)); local_1c = local_1c / local_c) {
local_10 =... |
301 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int a){
int num=0;
for (int i=2;i*i<=a;i++)
while (a%i==0 and a>i)
{
a=a/i;
num+=1;
}
if (num==2) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == false);
assert (func0(30) == true);
assert (func0(8) == true);
assert (func0(10) == false);
assert (func0(125) == true);
assert (func0(3 * 5 * 7) == true);
assert (func0(3 * 6 * 7) == false);
assert (func0(9 * 9 * 9) == fa... | O1 | cpp | func0(int):
endbr64
cmp $0x3,%edi
jle 1192 <_Z5func0i+0x49>
mov $0x2,%ecx
mov $0x0,%r8d
jmp 116b <_Z5func0i+0x22>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 1198 <_Z5func0i+0x4f>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 115f <_Z5func0i+0x16>
cmp %ecx,%e... | _Z5func0i:
endbr64
mov ecx, 2
mov r8d, 0
cmp edi, 3
jg short loc_1171
loc_115D:
cmp r8d, 2
setz al
retn
loc_1165:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jg short loc_115D
loc_1171:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_1165
cmp ed... | bool func0(int a1)
{
int v1; // ecx
int v2; // r8d
int v4; // esi
v1 = 2;
v2 = 0;
if ( a1 > 3 )
{
do
{
if ( !(a1 % v1) && a1 > v1 )
{
do
{
v4 = a1 / v1;
a1 = v4;
++v2;
}
while ( !(v4 % v1) && v4 > v1 );
}
++v1;... | func0:
ENDBR64
MOV ECX,0x2
MOV R8D,0x0
CMP EDI,0x3
JG 0x00101171
LAB_0010115d:
CMP R8D,0x2
SETZ AL
RET
LAB_00101165:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x0010115d
LAB_00101171:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101165
CMP EDI,ECX
JLE 0x00101165
LAB_0010117e:
MOV EAX,EDI
CDQ
IDIV ECX
MOV ESI... | /* func0(int) */
bool func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
iVar2 = 2;
iVar5 = 0;
iVar4 = 0;
if (3 < param_1) {
do {
iVar3 = param_1 % iVar2;
iVar5 = iVar4;
while ((iVar3 == 0 && (iVar2 < param_1))) {
lVar1 = (long)param_1;
... |
302 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int a){
int num=0;
for (int i=2;i*i<=a;i++)
while (a%i==0 and a>i)
{
a=a/i;
num+=1;
}
if (num==2) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == false);
assert (func0(30) == true);
assert (func0(8) == true);
assert (func0(10) == false);
assert (func0(125) == true);
assert (func0(3 * 5 * 7) == true);
assert (func0(3 * 6 * 7) == false);
assert (func0(9 * 9 * 9) == fa... | O2 | cpp | func0(int):
endbr64
cmp $0x3,%edi
jle 1448 <_Z5func0i+0x48>
mov $0x2,%ecx
xor %esi,%esi
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1431 <_Z5func0i+0x31>
jmp 1435 <_Z5func0i+0x35>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
add $0x1,%esi
cltd
idiv %ecx
cltd
mov %eax,%edi
idiv %ecx
te... | _Z5func0i:
endbr64
mov ecx, 2
xor esi, esi
cmp edi, 3
jle short loc_1398
loc_1360:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1381
jmp short loc_1385
loc_1370:
mov eax, edi
add esi, 1
cdq
idiv ecx
cdq
mov edi, eax
idiv ecx
test edx, edx
jnz short loc... | bool func0(int a1)
{
int v1; // ecx
int v2; // esi
int v3; // edx
v1 = 2;
v2 = 0;
if ( a1 <= 3 )
return 0;
do
{
if ( !(a1 % v1) )
{
do
{
if ( a1 <= v1 )
break;
++v2;
v3 = (a1 / v1) >> 31;
a1 /= v1;
}
while ( !(unsigned int)(... | func0:
ENDBR64
MOV ECX,0x2
XOR ESI,ESI
CMP EDI,0x3
JLE 0x00101398
LAB_00101360:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101381
JMP 0x00101385
LAB_00101370:
MOV EAX,EDI
ADD ESI,0x1
CDQ
IDIV ECX
CDQ
MOV EDI,EAX
IDIV ECX
TEST EDX,EDX
JNZ 0x00101385
LAB_00101381:
CMP EDI,ECX
JG 0x00101370
LAB_00101385:
ADD ECX,0x1
MOV... | /* func0(int) */
int4 func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
iVar2 = 2;
iVar4 = 0;
if (3 < param_1) {
do {
iVar3 = param_1 % iVar2;
while ((iVar3 == 0 && (iVar2 < param_1))) {
iVar4 = iVar4 + 1;
lVar1 = (long)param_1;
param_1 = (int)(... |
303 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int a){
int num=0;
for (int i=2;i*i<=a;i++)
while (a%i==0 and a>i)
{
a=a/i;
num+=1;
}
if (num==2) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == false);
assert (func0(30) == true);
assert (func0(8) == true);
assert (func0(10) == false);
assert (func0(125) == true);
assert (func0(3 * 5 * 7) == true);
assert (func0(3 * 6 * 7) == false);
assert (func0(9 * 9 * 9) == fa... | O3 | cpp | func0(int):
endbr64
cmp $0x3,%edi
jle 1448 <_Z5func0i+0x48>
mov $0x2,%ecx
xor %esi,%esi
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1431 <_Z5func0i+0x31>
jmp 1435 <_Z5func0i+0x35>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
add $0x1,%esi
cltd
idiv %ecx
cltd
mov %eax,%edi
idiv %ecx
te... | _Z5func0i:
endbr64
mov ecx, 2
xor esi, esi
cmp edi, 3
jle short loc_1448
loc_1410:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1431
jmp short loc_1435
loc_1420:
mov eax, edi
add esi, 1
cdq
idiv ecx
cdq
mov edi, eax
idiv ecx
test edx, edx
jnz short loc... | bool func0(int a1)
{
int v1; // ecx
int v2; // esi
int v3; // edx
v1 = 2;
v2 = 0;
if ( a1 <= 3 )
return 0;
do
{
if ( !(a1 % v1) )
{
do
{
if ( a1 <= v1 )
break;
++v2;
v3 = (a1 / v1) >> 31;
a1 /= v1;
}
while ( !(unsigned int)(... | func0:
ENDBR64
MOV ECX,0x2
XOR ESI,ESI
CMP EDI,0x3
JLE 0x00101448
LAB_00101410:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101431
JMP 0x00101435
LAB_00101420:
MOV EAX,EDI
ADD ESI,0x1
CDQ
IDIV ECX
CDQ
MOV EDI,EAX
IDIV ECX
TEST EDX,EDX
JNZ 0x00101435
LAB_00101431:
CMP EDI,ECX
JG 0x00101420
LAB_00101435:
ADD ECX,0x1
MOV... | /* func0(int) */
int4 func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
int iVar4;
iVar2 = 2;
iVar4 = 0;
if (3 < param_1) {
do {
iVar3 = param_1 % iVar2;
while ((iVar3 == 0 && (iVar2 < param_1))) {
iVar4 = iVar4 + 1;
lVar1 = (long)param_1;
param_1 = (int)(... |
304 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int x,int n){
int p=1,count=0;
while (p<=x and count<100)
{
if (p==x) return true;
p=p*n;count+=1;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1, 4)== true);
assert (func0(2, 2)==true);
assert (func0(8, 2)==true);
assert (func0(3, 2)==false);
assert (func0(3, 1)==false);
assert (func0(5, 3)==false);
assert (func0(16, 2)== true);
assert (func0(143214, 16)== false);
... | O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jg 1192 <_Z5func0ii+0x49>
cmpl $0x63,-0x4(%rbp)
jg 1192 <_Z5func0ii+0x49>
mov -0x8(%rbp),%eax
cmp -0x14(%rbp)... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_1184
loc_1167:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_14]
jnz short loc_1176
mov eax, 1
jmp short loc_1197
loc_1176:
mov eax, [rbp+... | long long func0(int a1, int a2)
{
int v3; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v3 = 1;
for ( i = 0; v3 <= a1 && i <= 99; ++i )
{
if ( v3 == a1 )
return 1LL;
v3 *= a2;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101184
LAB_00101167:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x14]
JNZ 0x00101176
MOV EAX,0x1
JMP 0x00101197
LAB_00101176:
MOV EAX,dw... | /* func0(int, int) */
int8 func0(int param_1,int param_2)
{
int local_10;
int local_c;
local_10 = 1;
for (local_c = 0; (local_10 <= param_1 && (local_c < 100)); local_c = local_c + 1) {
if (local_10 == param_1) {
return 1;
}
local_10 = local_10 * param_2;
}
return 0;
} |
305 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int x,int n){
int p=1,count=0;
while (p<=x and count<100)
{
if (p==x) return true;
p=p*n;count+=1;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1, 4)== true);
assert (func0(2, 2)==true);
assert (func0(8, 2)==true);
assert (func0(3, 2)==false);
assert (func0(3, 1)==false);
assert (func0(5, 3)==false);
assert (func0(16, 2)== true);
assert (func0(143214, 16)== false);
... | O1 | cpp | func0(int, int):
endbr64
test %edi,%edi
jle 117f <_Z5func0ii+0x36>
cmp $0x1,%edi
je 1185 <_Z5func0ii+0x3c>
mov $0x0,%edx
mov $0x1,%eax
imul %esi,%eax
add $0x1,%edx
cmp %eax,%edi
jl 1179 <_Z5func0ii+0x30>
cmp $0x63,%edx
jg 1179 <_Z5func0ii+0x30>
cmp %eax,%edi
jne 1160 <_Z5func0... | _Z5func0ii:
endbr64
test edi, edi
jle short loc_117D
cmp edi, 1
jz short loc_1183
mov ecx, 0
mov edx, 1
loc_1160:
imul edx, esi
add ecx, 1
cmp edi, edx
setnl al
cmp ecx, 63h ; 'c'
setle r8b
and al, r8b
jz short locret_117C
cmp edi, edx
jnz short loc_1160
retn
... | bool func0(int a1, int a2)
{
int v2; // ecx
int v3; // edx
bool result; // al
if ( a1 <= 0 )
return 0;
if ( a1 == 1 )
return 1;
v2 = 0;
v3 = 1;
do
{
v3 *= a2;
result = ++v2 <= 99 && a1 >= v3;
}
while ( result && a1 != v3 );
return result;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x0010117d
CMP EDI,0x1
JZ 0x00101183
MOV ECX,0x0
MOV EDX,0x1
LAB_00101160:
IMUL EDX,ESI
ADD ECX,0x1
CMP EDI,EDX
SETGE AL
CMP ECX,0x63
SETLE R8B
AND AL,R8B
JZ 0x0010117c
CMP EDI,EDX
JNZ 0x00101160
RET
LAB_0010117c:
RET
LAB_0010117d:
MOV EAX,0x0
RET
LAB_00101183:
MOV EAX,0x1
RET | /* func0(int, int) */
bool func0(int param_1,int param_2)
{
bool bVar1;
int iVar2;
int iVar3;
if (param_1 < 1) {
return false;
}
if (param_1 != 1) {
iVar2 = 0;
iVar3 = 1;
do {
iVar3 = iVar3 * param_2;
iVar2 = iVar2 + 1;
bVar1 = iVar3 <= param_1 && iVar2 < 100;
if... |
306 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int x,int n){
int p=1,count=0;
while (p<=x and count<100)
{
if (p==x) return true;
p=p*n;count+=1;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1, 4)== true);
assert (func0(2, 2)==true);
assert (func0(8, 2)==true);
assert (func0(3, 2)==false);
assert (func0(3, 1)==false);
assert (func0(5, 3)==false);
assert (func0(16, 2)== true);
assert (func0(143214, 16)== false);
... | O2 | cpp | func0(int, int):
endbr64
test %edi,%edi
jle 1228 <_Z5func0ii+0x38>
cmp $0x1,%edi
je 121b <_Z5func0ii+0x2b>
xor %edx,%edx
mov $0x1,%eax
nopl 0x0(%rax)
imul %esi,%eax
add $0x1,%edx
cmp %eax,%edi
jl 1228 <_Z5func0ii+0x38>
cmp $0x63,%edx
jg 1228 <_Z5func0ii+0x38>
cmp %eax,%edi
jne ... | _Z5func0ii:
endbr64
test edi, edi
jle short loc_1272
cmp edi, 1
jz short loc_126C
xor ecx, ecx
mov edx, 1
jmp short loc_1254
loc_1250:
cmp edi, edx
jz short locret_1271
loc_1254:
imul edx, esi
add ecx, 1
cmp edi, edx
setnl al
cmp ecx, 63h ; 'c'
setle r8b
and a... | bool func0(int a1, int a2)
{
int v2; // ecx
int v3; // edx
bool result; // al
if ( a1 <= 0 )
return 0;
if ( a1 == 1 )
return 1;
v2 = 0;
v3 = 1;
do
{
v3 *= a2;
result = ++v2 <= 99 && a1 >= v3;
}
while ( result && a1 != v3 );
return result;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101272
CMP EDI,0x1
JZ 0x0010126c
XOR ECX,ECX
MOV EDX,0x1
JMP 0x00101254
LAB_00101250:
CMP EDI,EDX
JZ 0x00101271
LAB_00101254:
IMUL EDX,ESI
ADD ECX,0x1
CMP EDI,EDX
SETGE AL
CMP ECX,0x63
SETLE R8B
AND AL,R8B
JNZ 0x00101250
RET
LAB_0010126c:
MOV EAX,0x1
LAB_00101271:
RET
LAB_00101272:
X... | /* func0(int, int) */
bool func0(int param_1,int param_2)
{
bool bVar1;
int iVar2;
int iVar3;
if (param_1 < 1) {
return false;
}
if (param_1 == 1) {
bVar1 = true;
}
else {
iVar2 = 0;
iVar3 = 1;
do {
iVar3 = iVar3 * param_2;
iVar2 = iVar2 + 1;
bVar1 = iVar3 <= p... |
307 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int x,int n){
int p=1,count=0;
while (p<=x and count<100)
{
if (p==x) return true;
p=p*n;count+=1;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1, 4)== true);
assert (func0(2, 2)==true);
assert (func0(8, 2)==true);
assert (func0(3, 2)==false);
assert (func0(3, 1)==false);
assert (func0(5, 3)==false);
assert (func0(16, 2)== true);
assert (func0(143214, 16)== false);
... | O3 | cpp | func0(int, int):
endbr64
test %edi,%edi
jle 1228 <_Z5func0ii+0x38>
cmp $0x1,%edi
je 121b <_Z5func0ii+0x2b>
xor %edx,%edx
mov $0x1,%eax
nopl 0x0(%rax)
imul %esi,%eax
add $0x1,%edx
cmp %eax,%edi
jl 1228 <_Z5func0ii+0x38>
cmp $0x63,%edx
jg 1228 <_Z5func0ii+0x38>
cmp %eax,%edi
jne ... | _Z5func0ii:
endbr64
test edi, edi
jle short loc_1232
cmp edi, 1
jz short loc_122C
xor ecx, ecx
mov edx, 1
jmp short loc_1214
loc_1210:
cmp edi, edx
jz short locret_1231
loc_1214:
imul edx, esi
add ecx, 1
cmp edi, edx
setnl al
cmp ecx, 63h ; 'c'
setle r8b
and a... | bool func0(int a1, int a2)
{
int v2; // ecx
int v3; // edx
bool result; // al
if ( a1 <= 0 )
return 0;
if ( a1 == 1 )
return 1;
v2 = 0;
v3 = 1;
do
{
v3 *= a2;
result = ++v2 <= 99 && a1 >= v3;
}
while ( result && a1 != v3 );
return result;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101232
CMP EDI,0x1
JZ 0x0010122c
XOR ECX,ECX
MOV EDX,0x1
JMP 0x00101214
LAB_00101210:
CMP EDI,EDX
JZ 0x00101231
LAB_00101214:
IMUL EDX,ESI
ADD ECX,0x1
CMP EDI,EDX
SETGE AL
CMP ECX,0x63
SETLE R8B
AND AL,R8B
JNZ 0x00101210
RET
LAB_0010122c:
MOV EAX,0x1
LAB_00101231:
RET
LAB_00101232:
X... | /* func0(int, int) */
bool func0(int param_1,int param_2)
{
bool bVar1;
int iVar2;
int iVar3;
if (param_1 < 1) {
return false;
}
if (param_1 == 1) {
bVar1 = true;
}
else {
iVar2 = 0;
iVar3 = 1;
do {
iVar3 = iVar3 * param_2;
iVar2 = iVar2 + 1;
bVar1 = iVar3 <= p... |
308 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int a){
for (int i=0;i*i*i<=abs(a);i++)
if (i*i*i==abs(a)) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == true);
assert (func0(2) == false);
assert (func0(-1) == true);
assert (func0(64) == true);
assert (func0(180) == false);
assert (func0(1000) == true);
assert (func0(0) == true);
assert (func0(1729) == false);
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax
mov %eax,%ecx
mov -0x14(%rbp),%eax
cltd
mov %edx,%eax
xor -0x14(%rbp),%eax
sub %edx,%eax
cmp %eax,%ecx
jg 119e <_Z5func0i+0x55>
mov -0x4... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
jmp short loc_1182
loc_115D:
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+var_4]
mov edx, eax
mov eax, [rbp+var_14]
mov ecx, eax
neg ecx
cmovns eax, ecx
cmp edx, eax
jnz short loc... | long long func0(int a1)
{
int v1; // eax
int v3; // eax
int i; // [rsp+10h] [rbp-4h]
for ( i = 0; ; ++i )
{
v3 = a1;
if ( a1 <= 0 )
v3 = -a1;
if ( i * i * i > v3 )
break;
v1 = a1;
if ( a1 <= 0 )
v1 = -a1;
if ( i * i * i == v1 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101182
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
CMP EDX,EAX
JNZ 0x0010117e
MOV EAX,0x... | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
int local_c;
local_c = 0;
while( true ) {
iVar1 = param_1;
if (param_1 < 1) {
iVar1 = -param_1;
}
if (iVar1 < local_c * local_c * local_c) {
return 0;
}
iVar1 = param_1;
if (param_1 < 1) {
iVar1 = -param_1;
... |
309 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int a){
for (int i=0;i*i*i<=abs(a);i++)
if (i*i*i==abs(a)) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == true);
assert (func0(2) == false);
assert (func0(-1) == true);
assert (func0(64) == true);
assert (func0(180) == false);
assert (func0(1000) == true);
assert (func0(0) == true);
assert (func0(1729) == false);
}
| O1 | cpp | func0(int):
endbr64
mov %edi,%eax
sar $0x1f,%eax
mov %eax,%ecx
xor %edi,%ecx
sub %eax,%ecx
test %edi,%edi
je 117f <_Z5func0i+0x36>
mov $0x1,%edx
mov $0x1,%eax
cmp %eax,%ecx
je 1185 <_Z5func0i+0x3c>
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
imul %edx,%eax
cmp %ecx,%eax
jle... | _Z5func0i:
endbr64
mov ecx, edi
neg ecx
cmovs ecx, edi
test edi, edi
jz short loc_117A
mov eax, 0
loc_115D:
add eax, 1
mov edx, eax
imul edx, eax
imul edx, eax
cmp edx, ecx
jg short loc_1174
jnz short loc_115D
mov eax, 1
retn
loc_1174:
mov eax, 0
retn
loc_117A:
m... | long long func0(int a1)
{
int v1; // ecx
int v2; // eax
int v3; // edx
v1 = -a1;
if ( a1 > 0 )
v1 = a1;
if ( !a1 )
return 1LL;
v2 = 0;
while ( 1 )
{
++v2;
v3 = v2 * v2 * v2;
if ( v3 > v1 )
break;
if ( v3 == v1 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV ECX,EDI
NEG ECX
CMOVS ECX,EDI
TEST EDI,EDI
JZ 0x0010117a
MOV EAX,0x0
LAB_0010115d:
ADD EAX,0x1
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
CMP EDX,ECX
JG 0x00101174
JNZ 0x0010115d
MOV EAX,0x1
RET
LAB_00101174:
MOV EAX,0x0
RET
LAB_0010117a:
MOV EAX,0x1
RET | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar2 = -param_1;
if (0 < param_1) {
iVar2 = param_1;
}
if (param_1 != 0) {
iVar1 = 0;
do {
iVar1 = iVar1 + 1;
iVar3 = iVar1 * iVar1 * iVar1;
if (iVar2 < iVar3) {
return 0;
}
} ... |
310 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int a){
for (int i=0;i*i*i<=abs(a);i++)
if (i*i*i==abs(a)) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == true);
assert (func0(2) == false);
assert (func0(-1) == true);
assert (func0(64) == true);
assert (func0(180) == false);
assert (func0(1000) == true);
assert (func0(0) == true);
assert (func0(1729) == false);
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%eax
sar $0x1f,%eax
mov %eax,%ecx
xor %edi,%ecx
sub %eax,%ecx
test %edi,%edi
je 12a0 <_Z5func0i+0x40>
mov $0x1,%edx
mov $0x1,%eax
nopl (%rax)
cmp %eax,%ecx
je 12a0 <_Z5func0i+0x40>
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
imul %edx,%eax
cmp ... | _Z5func0i:
endbr64
mov ecx, edi
neg ecx
cmovs ecx, edi
test edi, edi
jz short loc_1280
xor eax, eax
jmp short loc_126A
loc_1268:
jz short loc_1280
loc_126A:
add eax, 1
mov edx, eax
imul edx, eax
imul edx, eax
cmp edx, ecx
jle short loc_1268
xor eax, eax
retn
loc_... | long long func0(int a1)
{
int v1; // ecx
int v2; // eax
int v3; // edx
v1 = -a1;
if ( a1 > 0 )
v1 = a1;
if ( !a1 )
return 1LL;
v2 = 0;
while ( 1 )
{
++v2;
v3 = v2 * v2 * v2;
if ( v3 > v1 )
break;
if ( v3 == v1 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV ECX,EDI
NEG ECX
CMOVS ECX,EDI
TEST EDI,EDI
JZ 0x00101280
XOR EAX,EAX
JMP 0x0010126a
LAB_00101268:
JZ 0x00101280
LAB_0010126a:
ADD EAX,0x1
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
CMP EDX,ECX
JLE 0x00101268
XOR EAX,EAX
RET
LAB_00101280:
MOV EAX,0x1
RET | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar2 = -param_1;
if (0 < param_1) {
iVar2 = param_1;
}
if (param_1 != 0) {
iVar1 = 0;
do {
iVar1 = iVar1 + 1;
iVar3 = iVar1 * iVar1 * iVar1;
if (iVar2 < iVar3) {
return 0;
}
} ... |
311 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(int a){
for (int i=0;i*i*i<=abs(a);i++)
if (i*i*i==abs(a)) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == true);
assert (func0(2) == false);
assert (func0(-1) == true);
assert (func0(64) == true);
assert (func0(180) == false);
assert (func0(1000) == true);
assert (func0(0) == true);
assert (func0(1729) == false);
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%eax
sar $0x1f,%eax
mov %eax,%ecx
xor %edi,%ecx
sub %eax,%ecx
test %edi,%edi
je 12a0 <_Z5func0i+0x40>
mov $0x1,%edx
mov $0x1,%eax
nopl (%rax)
cmp %eax,%ecx
je 12a0 <_Z5func0i+0x40>
add $0x1,%edx
mov %edx,%eax
imul %edx,%eax
imul %edx,%eax
cmp ... | _Z5func0i:
endbr64
mov ecx, edi
neg ecx
cmovs ecx, edi
test edi, edi
jz short loc_1280
xor eax, eax
jmp short loc_126A
loc_1268:
jz short loc_1280
loc_126A:
add eax, 1
mov edx, eax
imul edx, eax
imul edx, eax
cmp edx, ecx
jle short loc_1268
xor eax, eax
retn
loc_... | long long func0(int a1)
{
int v1; // ecx
int v2; // eax
int v3; // edx
v1 = -a1;
if ( a1 > 0 )
v1 = a1;
if ( !a1 )
return 1LL;
v2 = 0;
while ( 1 )
{
++v2;
v3 = v2 * v2 * v2;
if ( v3 > v1 )
break;
if ( v3 == v1 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV ECX,EDI
NEG ECX
CMOVS ECX,EDI
TEST EDI,EDI
JZ 0x00101280
XOR EAX,EAX
JMP 0x0010126a
LAB_00101268:
JZ 0x00101280
LAB_0010126a:
ADD EAX,0x1
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
CMP EDX,ECX
JLE 0x00101268
XOR EAX,EAX
RET
LAB_00101280:
MOV EAX,0x1
RET | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar2 = -param_1;
if (0 < param_1) {
iVar2 = param_1;
}
if (param_1 != 0) {
iVar1 = 0;
do {
iVar1 = iVar1 + 1;
iVar3 = iVar1 * iVar1 * iVar1;
if (iVar2 < iVar3) {
return 0;
}
} ... |
312 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string num){
string key="2357BD";
int out=0;
for (int i=0;i<num.length();i++)
if (find(key.begin(),key.end(),num[i])!=key.end()) out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("AB") == 1 );
assert (func0("1077E") == 2 );
assert (func0("ABED1A33") == 4 );
assert (func0("2020") == 2 );
assert (func0("123456789ABCDEF0") == 6 );
assert (func0("112233445566778899AABBCCDDEEFF00") == 12 );
assert (... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x60,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x48(%rbp),%rax
mov %rax,%rdi
callq 2300 <_ZNSaIcEC1Ev@... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 60h
mov [rbp+var_68], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_50]
mov [rbp+var_48], rax
nop
nop
lea rdx, [rbp+var_50]
lea ... | long long func0(long long a1)
{
long long v1; // r12
long long v2; // rbx
long long v3; // rax
unsigned int v5; // [rsp+10h] [rbp-60h]
int i; // [rsp+14h] [rbp-5Ch]
long long v7; // [rsp+18h] [rbp-58h] BYREF
_QWORD v8[2]; // [rsp+20h] [rbp-50h] BYREF
_BYTE v9[40]; // [rsp+30h] [rbp-40h] BYREF
unsigne... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x60
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV qword ptr [RBP + -0x48],RAX
NOP
NOP
LEA RDX,[RBP + -0x50]
LEA RAX,[RBP + -0x40]
LEA RCX,[0x103008]
MOV RSI,RCX
MOV RDI,RAX
... | /* func0(std::string) */
int func0(ulong param_1)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
char *pcVar4;
int4 extraout_var;
ulong uVar5;
long in_FS_OFFSET;
int local_68;
int local_64;
int8 local_60;
int8 local_58;
int8 *local_50;
string local_48 [40];
long local_20;
... |
313 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string num){
string key="2357BD";
int out=0;
for (int i=0;i<num.length();i++)
if (find(key.begin(),key.end(),num[i])!=key.end()) out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("AB") == 1 );
assert (func0("1077E") == 2 );
assert (func0("ABED1A33") == 4 );
assert (func0("2020") == 2 );
assert (func0("123456789ABCDEF0") == 6 );
assert (func0("112233445566778899AABBCCDDEEFF00") == 12 );
assert (... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %rsp,%rdi
lea 0x10(%rsp),%rax
mov %rax,(%rsp)
lea 0xdff(%rip),%rdx
lea -0x6(%rdx),%rs... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbx
sub rsp, 30h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+38h+var_10], rax
xor eax, eax
mov rdi, rsp
lea rax, [rsp+38h+var_28]
mov [rsp+38h+var_38], rax
lea rdx, a2357bd+6; ""
lea rsi, [rdx-6]
call _ZNS... | long long func0(long long a1)
{
long long v2; // rdi
char *v3; // r9
char *v4; // rsi
char *v5; // rdi
unsigned int v6; // ebx
char *v7; // rax
char v8; // dl
long long v9; // rdx
void *v11; // [rsp+0h] [rbp-38h] BYREF
long long v12; // [rsp+8h] [rbp-30h]
_QWORD v13[5]; // [rsp+10h] [rbp-28h] BYR... | func0:
ENDBR64
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RDI,RSP
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
LEA RDX,[0x1020e6]
LEA RSI,[RDX + -0x6]
CALL 0x0010172a
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x00101345
MOV R8,qword ptr [RSP]
MOV RCX... | /* func0(std::string) */
int func0(int8 *param_1)
{
char cVar1;
long *plVar2;
long *plVar3;
long *plVar4;
long lVar5;
int iVar6;
char *pcVar7;
char *pcVar8;
long in_FS_OFFSET;
long *local_38;
ulong local_30;
long local_28 [3];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
... |
314 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string num){
string key="2357BD";
int out=0;
for (int i=0;i<num.length();i++)
if (find(key.begin(),key.end(),num[i])!=key.end()) out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("AB") == 1 );
assert (func0("1077E") == 2 );
assert (func0("ABED1A33") == 4 );
assert (func0("2020") == 2 );
assert (func0("123456789ABCDEF0") == 6 );
assert (func0("112233445566778899AABBCCDDEEFF00") == 12 );
assert (... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
sub $0x38,%rsp
mov 0x8(%rdi),%rcx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rax
movl $0x37353332,0x10(%rsp)
mov %rax,(%rsp)
mov $0x4442,%eax
mov %ax,0x14(%rsp)
movq $0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
test rsi, rsi
jz short loc_148D
mov rdx, [rdi]
xor ecx, ecx
add rsi, rdx
nop dword ptr [rax]
loc_1458:
movzx eax, byte ptr [rdx]
cmp al, 32h ; '2'
jz short loc_1488
cmp al, 33h ; '3'
jz ... | long long func0(long long a1)
{
long long v1; // rsi
char *v2; // rdx
unsigned int v3; // ecx
char *v4; // rsi
char v5; // al
v1 = *(_QWORD *)(a1 + 8);
if ( !v1 )
return 0LL;
v2 = *(char **)a1;
v3 = 0;
v4 = (char *)(*(_QWORD *)a1 + v1);
do
{
v5 = *v2;
if ( *v2 == 50 || v5 == 51 || ... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x0010148d
MOV RDX,qword ptr [RDI]
XOR ECX,ECX
ADD RSI,RDX
NOP dword ptr [RAX]
LAB_00101458:
MOVZX EAX,byte ptr [RDX]
CMP AL,0x32
JZ 0x00101488
CMP AL,0x33
JZ 0x00101488
CMP AL,0x35
JZ 0x00101488
CMP AL,0x37
JZ 0x00101488
CMP AL,0x42
JZ 0x00101488
CMP AL,0x44... | /* func0(std::string) */
int func0(int8 *param_1)
{
char cVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (param_1[1] == 0) {
return 0;
}
pcVar3 = (char *)*param_1;
iVar2 = 0;
pcVar4 = pcVar3 + param_1[1];
do {
cVar1 = *pcVar3;
if ((((cVar1 == '2') || (cVar1 == '3')) || (cVar1 == '5... |
315 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string num){
string key="2357BD";
int out=0;
for (int i=0;i<num.length();i++)
if (find(key.begin(),key.end(),num[i])!=key.end()) out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("AB") == 1 );
assert (func0("1077E") == 2 );
assert (func0("ABED1A33") == 4 );
assert (func0("2020") == 2 );
assert (func0("123456789ABCDEF0") == 6 );
assert (func0("112233445566778899AABBCCDDEEFF00") == 12 );
assert (... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
sub $0x38,%rsp
mov 0x8(%rdi),%rcx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rax
movl $0x37353332,0x10(%rsp)
mov %rax,(%rsp)
mov $0x4442,%eax
mov %ax,0x14(%rsp)
movq $0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov r8, [rdi+8]
test r8, r8
jz loc_182D
lea rax, [r8-1]
mov rcx, [rdi]
cmp rax, 0Eh
jbe loc_1832
mov rax, r8
mov rdx, rcx
movdqa xmm11, cs:xmmword_2180
movdqa xmm10, cs:xmmword_2190
and rax, 0FFFFFFFFFFFFFFF0... | long long func0(const __m128i **a1)
{
unsigned long long v1; // r8
const __m128i *v2; // rcx
const __m128i *v3; // rdx
__m128i si128; // xmm11
__m128i v5; // xmm10
unsigned long long v6; // rax
__m128i v7; // xmm4
__m128i v8; // xmm9
__m128i v9; // xmm7
__m128i v10; // xmm8
__m128i v11; // xmm6
... | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
TEST R8,R8
JZ 0x0010182d
LEA RAX,[R8 + -0x1]
MOV RCX,qword ptr [RDI]
CMP RAX,0xe
JBE 0x00101832
MOV RAX,R8
MOV RDX,RCX
MOVDQA XMM11,xmmword ptr [0x00102180]
MOVDQA XMM10,xmmword ptr [0x00102190]
AND RAX,-0x10
PXOR XMM4,XMM4
PXOR XMM2,XMM2
MOVDQA XMM9,xmmword ptr [0x001021a0]
... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::string) */
int func0(long *param_1)
{
ulong uVar1;
char *pcVar2;
int auVar3 [14];
int auVar4 [12];
int auVar5 [11];
unkuint10 Var6;
unkuint9 Var7;
ulong uVar8;
char cVar9;
char cVar10;
char cVar11;... |
316 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int decimal){
string out="";
if (decimal==0) return "db0db";
while (decimal>0)
{
out=to_string(decimal%2)+out;
decimal=decimal/2;
}
out="db"+out+"db";
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0) == "db0db");
assert (func0(32) == "db100000db");
assert (func0(103) == "db1100111db");
assert (func0(15) == "db1111db");
}
| O0 | cpp | func0[abi:cxx11](int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x98,%rsp
mov %rdi,-0x98(%rbp)
mov %esi,-0x9c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x81(%rbp),%rax
mov %rax,%rdi
callq 23b0 <_ZNSaIcEC1Ev@plt>
lea -0x81(%rbp),%rdx
lea -0x80(%rbp),%rax
... | _Z5func0B5cxx11i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+var_A8], rdi
mov [rbp+var_AC], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_91]
mov [rbp+var_90], rax
nop
nop
lea rdx, [rbp+var_91]
lea rax, [rbp+var_80]
lea ... | long long func0[abi:cxx11](long long a1, int a2)
{
int v3; // [rsp+4h] [rbp-ACh]
char v4; // [rsp+1Fh] [rbp-91h] BYREF
char *v5; // [rsp+20h] [rbp-90h]
char *v6; // [rsp+28h] [rbp-88h]
_BYTE v7[32]; // [rsp+30h] [rbp-80h] BYREF
_BYTE v8[32]; // [rsp+50h] [rbp-60h] BYREF
_BYTE v9[40]; // [rsp+70h] [rbp-40... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0xa8],RDI
MOV dword ptr [RBP + -0xac],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x91]
MOV qword ptr [RBP + -0x90],RAX
NOP
NOP
LEA RDX,[RBP + -0x91]
LEA RAX,[RBP + -0x80]
LEA RCX,[... | /* func0[abi:cxx11](int) */
string * func0_abi_cxx11_(int param_1)
{
int in_ESI;
int4 in_register_0000003c;
string *this;
long in_FS_OFFSET;
int local_b4;
allocator local_99;
allocator *local_98;
allocator *local_90;
string local_88 [32];
string local_68 [32];
string local_48 [40];
long local_... |
317 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int decimal){
string out="";
if (decimal==0) return "db0db";
while (decimal>0)
{
out=to_string(decimal%2)+out;
decimal=decimal/2;
}
out="db"+out+"db";
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0) == "db0db");
assert (func0(32) == "db100000db");
assert (func0(103) == "db1100111db");
assert (func0(15) == "db1111db");
}
| O1 | cpp | func0[abi:cxx11](int):
endbr64
push %r12
push %rbp
push %rbx
sub $0x70,%rsp
mov %rdi,%r12
mov %esi,%ebx
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rdi
lea 0x10(%rsp),%rax
mov %rax,(%rsp)
lea 0xdd6(%rip),%rdx
mov %rdx,%rsi
callq 1ab8 <_ZNSt7__cxx1112basic_string... | _Z5func0B5cxx11i:
endbr64
push r12
push rbp
push rbx
sub rsp, 70h
mov rbp, rdi
mov ebx, esi
mov rax, fs:28h
mov [rsp+88h+var_20], rax
xor eax, eax
mov rdi, rsp
lea rax, [rsp+88h+var_78]
mov [rsp+88h+var_88], rax
lea rsi, aFunc032Db10000+19h; ""
mov rdx, rsi
call _... | void ** func0[abi:cxx11](void **a1, int a2)
{
int v3; // ebx
unsigned long long v4; // rbx
void *v5; // r12
long long v6; // rdx
char *v7; // rax
long long v8; // rcx
long long v9; // rax
long long v10; // rsi
_DWORD *v11; // r9
_DWORD *v12; // rcx
long long v13; // rdi
unsigned int v14; // ecx
... | func0[abi:cxx11]:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOV RBP,RDI
MOV EBX,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RDI,RSP
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
LEA RSI,[0x102062]
MOV RDX,RSI
LAB_00101300:
CALL 0x00101cf8
TEST EBX,EBX
JZ 0x0010134d
MOV R12,0x3fff... | /* func0[abi:cxx11](int) */
long * func0_abi_cxx11_(int param_1)
{
long *plVar1;
bool bVar2;
char cVar3;
long *plVar4;
uint uVar5;
int8 *puVar6;
int8 uVar7;
ulong uVar8;
long *plVar9;
uint uVar10;
long lVar11;
int in_ESI;
int4 in_register_0000003c;
long *plVar12;
long lVar13;
long *plV... |
318 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int decimal){
string out="";
if (decimal==0) return "db0db";
while (decimal>0)
{
out=to_string(decimal%2)+out;
decimal=decimal/2;
}
out="db"+out+"db";
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0) == "db0db");
assert (func0(32) == "db100000db");
assert (func0(103) == "db1100111db");
assert (func0(15) == "db1111db");
}
| O2 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
lea 0xc26(%rip),%rdx
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
mov %esi,%ebx
mov %rdx,%rsi
sub $0x88,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rdi
lea 0x20(%rsp),%rax
mov %rax,0x8(%... | _Z5func0B5cxx11i:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
mov ebx, esi
lea rsi, aFunc032Db10000+19h; ""
mov rdx, rsi
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rdi, [rsp+0B8h+var_A8]
lea r13, [rsp+... | unsigned long long ** func0[abi:cxx11](unsigned long long **a1, int a2)
{
int v3; // ebx
__m128i *v4; // rdx
long long *v5; // rax
long long *v6; // rsi
__m128i v7; // xmm0
long long v8; // rsi
long long v9; // rax
long long v10; // rsi
long long v11; // rdi
unsigned int v12; // edi
long long *v13... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
LEA RSI,[0x102062]
MOV RDX,RSI
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x10]
LEA R13,[RSP + 0x20]
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP + 0x10],R1... | /* func0[abi:cxx11](int) */
long * func0_abi_cxx11_(int param_1)
{
long *plVar1;
uint uVar2;
int8 *puVar3;
long *plVar4;
long lVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
long *plVar9;
int in_ESI;
int4 in_register_0000003c;
long *plVar10;
ulong uVar11;
long lVar12;
long *plVar13;
long ... |
319 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int decimal){
string out="";
if (decimal==0) return "db0db";
while (decimal>0)
{
out=to_string(decimal%2)+out;
decimal=decimal/2;
}
out="db"+out+"db";
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0) == "db0db");
assert (func0(32) == "db100000db");
assert (func0(103) == "db1100111db");
assert (func0(15) == "db1111db");
}
| O3 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rax
movb $0x0,0x20(%rsp)
mov %rax,0x8(%rsp)
mov %rax,0x10(%rsp)
movq $0x0,0x18(%rsp)
test ... | _Z5func0B5cxx11i:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea r13, [rsp+0B8h+var_A0+8]
mov byte ptr [rsp+0B8h+var_A0+8], 0
mov [rsp+0B8h+var_A8], r13
mov qword pt... | long long func0[abi:cxx11](long long a1, int a2)
{
int v3; // r14d
long long v4; // rax
long long v5; // rsi
long long v6; // rdi
__m128i *v7; // rdx
long long *v8; // rax
__m128i *v9; // rsi
__m128i v10; // xmm0
long long v11; // rsi
unsigned long long v12; // r14
long long v13; // rsi
long lo... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA R13,[RSP + 0x20]
MOV byte ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x10],R13
MOV qword ptr [RSP + 0x18],0x0
TEST ESI,ESI
JZ 0x00101831
MOV ... | /* func0[abi:cxx11](int) */
int8 * func0_abi_cxx11_(int param_1)
{
ulong *puVar1;
uint uVar2;
int8 *puVar3;
ulong uVar4;
ulong *puVar5;
long lVar6;
uint uVar7;
ulong uVar8;
ulong uVar9;
ulong *puVar10;
int in_ESI;
int4 in_register_0000003c;
int8 *puVar11;
ulong uVar12;
ulong *puVar13;
... |
320 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string s){
if (s.length()<3) return false;
for (int i=2;i<s.length();i++)
if (s[i]==s[i-1] or s[i]==s[i-2]) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("a") == false );
assert (func0("aa") == false );
assert (func0("abcd") == true );
assert (func0("aabb") == false );
assert (func0("adb") == true );
assert (func0("xyy") == false );
assert (func0("iopaxpoi") == true );
assert (fu... | 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)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1290 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv@plt>
cmp $0x2,%rax
s... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
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 __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
cmp rax, 2
setbe ... | long long func0(long long a1)
{
char v2; // bl
char v3; // bl
int i; // [rsp+1Ch] [rbp-14h]
if ( (unsigned long long)std::string::length(a1) <= 2 )
return 0LL;
for ( i = 2; i < (unsigned long long)std::string::length(a1); ++i )
{
v2 = *(_BYTE *)std::string::operator[](a1, i);
if ( v2 != *(_BYT... | 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 0x00101210
CMP RAX,0x2
SETBE AL
TEST AL,AL
JZ 0x0010137b
MOV EAX,0x0
JMP 0x00101435
LAB_0010137b:
MOV dword ptr [RBP + -0x14],0x2
JMP 0x00101410
LAB_00101387:
MOV EAX,dword ptr [RBP... | /* func0(std::string) */
int8 func0(ulong param_1)
{
char cVar1;
bool bVar2;
ulong uVar3;
int8 uVar4;
char *pcVar5;
int local_1c;
uVar3 = std::string::length();
if (uVar3 < 3) {
uVar4 = 0;
}
else {
for (local_1c = 2; uVar3 = std::string::length(), (ulong)(long)local_1c < uVar3;
... |
321 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string s){
if (s.length()<3) return false;
for (int i=2;i<s.length();i++)
if (s[i]==s[i-1] or s[i]==s[i-2]) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("a") == false );
assert (func0("aa") == false );
assert (func0("abcd") == true );
assert (func0("aabb") == false );
assert (func0("adb") == true );
assert (func0("xyy") == false );
assert (func0("iopaxpoi") == true );
assert (fu... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rdx
mov $0x0,%eax
cmp $0x2,%rdx
jbe 122b <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x42>
mov (%rdi),%rax
lea -0x2(%rax,%rdx,1),%rcx
movzbl 0x2(%rax),%edx
cmp 0x1(%rax),... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rdx, [rdi+8]
mov eax, 0
cmp rdx, 2
jbe short locret_124B
mov rax, [rdi]
lea rcx, [rax+rdx-2]
loc_1224:
movzx edx, byte ptr [rax+2]
cmp dl, [rax+1]
jz short loc_1240
cmp dl, [rax]
jz short loc_1246
add ... | long long func0(long long a1)
{
unsigned long long v1; // rdx
long long result; // rax
_BYTE *v3; // rax
long long v4; // rcx
char v5; // dl
v1 = *(_QWORD *)(a1 + 8);
result = 0LL;
if ( v1 > 2 )
{
v3 = *(_BYTE **)a1;
v4 = *(_QWORD *)a1 + v1 - 2;
while ( 1 )
{
v5 = v3[2];
... | func0:
ENDBR64
MOV RDX,qword ptr [RDI + 0x8]
MOV EAX,0x0
CMP RDX,0x2
JBE 0x0010124b
MOV RAX,qword ptr [RDI]
LEA RCX,[RAX + RDX*0x1 + -0x2]
LAB_00101224:
MOVZX EDX,byte ptr [RAX + 0x2]
CMP DL,byte ptr [RAX + 0x1]
JZ 0x00101240
CMP DL,byte ptr [RAX]
JZ 0x00101246
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101224
MOV EAX,0x1
RET
LAB... | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
if (2 < (ulong)param_1[1]) {
pcVar2 = (char *)*param_1;
pcVar1 = pcVar2 + (param_1[1] - 2);
while( true ) {
if (pcVar2[2] == pcVar2[1]) {
return 0;
}
if (pcVar2[2] == *pcVar2) break;
p... |
322 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string s){
if (s.length()<3) return false;
for (int i=2;i<s.length();i++)
if (s[i]==s[i-1] or s[i]==s[i-2]) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("a") == false );
assert (func0("aa") == false );
assert (func0("abcd") == true );
assert (func0("aabb") == false );
assert (func0("adb") == true );
assert (func0("xyy") == false );
assert (func0("iopaxpoi") == true );
assert (fu... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rdx
xor %eax,%eax
cmp $0x2,%rdx
jbe 1518 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x38>
mov (%rdi),%rax
lea -0x2(%rdx,%rax,1),%rcx
jmp 150d <_Z5func0NSt7__cxx1112basic... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rdx, [rdi+8]
xor eax, eax
cmp rdx, 2
jbe short locret_14B8
mov rax, [rdi]
lea rcx, [rdx+rax-2]
jmp short loc_14AD
loc_14A0:
cmp dl, [rax]
jz short loc_14B6
add rax, 1
cmp rax, rcx
jz short loc_14C... | long long func0(long long a1)
{
unsigned long long v1; // rdx
long long result; // rax
_BYTE *v3; // rax
long long v4; // rcx
char v5; // dl
v1 = *(_QWORD *)(a1 + 8);
result = 0LL;
if ( v1 > 2 )
{
v3 = *(_BYTE **)a1;
v4 = v1 + *(_QWORD *)a1 - 2;
do
{
v5 = v3[2];
if ( v5 =... | func0:
ENDBR64
MOV RDX,qword ptr [RDI + 0x8]
XOR EAX,EAX
CMP RDX,0x2
JBE 0x001014b8
MOV RAX,qword ptr [RDI]
LEA RCX,[RDX + RAX*0x1 + -0x2]
JMP 0x001014ad
LAB_001014a0:
CMP DL,byte ptr [RAX]
JZ 0x001014b6
ADD RAX,0x1
CMP RAX,RCX
JZ 0x001014c0
LAB_001014ad:
MOVZX EDX,byte ptr [RAX + 0x2]
CMP DL,byte ptr [RAX + 0x1]
JNZ 0... | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
if (2 < (ulong)param_1[1]) {
pcVar2 = (char *)*param_1;
pcVar1 = pcVar2 + (param_1[1] - 2);
while ((pcVar2[2] != pcVar2[1] && (pcVar2[2] != *pcVar2))) {
pcVar2 = pcVar2 + 1;
if (pcVar2 == pcVar1) {
... |
323 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string s){
if (s.length()<3) return false;
for (int i=2;i<s.length();i++)
if (s[i]==s[i-1] or s[i]==s[i-2]) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("a") == false );
assert (func0("aa") == false );
assert (func0("abcd") == true );
assert (func0("aabb") == false );
assert (func0("adb") == true );
assert (func0("xyy") == false );
assert (func0("iopaxpoi") == true );
assert (fu... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rdx
xor %eax,%eax
cmp $0x2,%rdx
jbe 15a8 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x38>
mov (%rdi),%rax
lea -0x2(%rdx,%rax,1),%rcx
jmp 159d <_Z5func0NSt7__cxx1112basic... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rdx, [rdi+8]
xor eax, eax
cmp rdx, 2
jbe short locret_1568
mov rax, [rdi]
lea rcx, [rdx+rax-2]
jmp short loc_155D
loc_1550:
cmp dl, [rax]
jz short loc_1566
add rax, 1
cmp rcx, rax
jz short loc_157... | long long func0(long long a1)
{
unsigned long long v1; // rdx
long long result; // rax
_BYTE *v3; // rax
long long v4; // rcx
char v5; // dl
v1 = *(_QWORD *)(a1 + 8);
result = 0LL;
if ( v1 > 2 )
{
v3 = *(_BYTE **)a1;
v4 = v1 + *(_QWORD *)a1 - 2;
do
{
v5 = v3[2];
if ( v5 =... | func0:
ENDBR64
MOV RDX,qword ptr [RDI + 0x8]
XOR EAX,EAX
CMP RDX,0x2
JBE 0x00101568
MOV RAX,qword ptr [RDI]
LEA RCX,[RDX + RAX*0x1 + -0x2]
JMP 0x0010155d
LAB_00101550:
CMP DL,byte ptr [RAX]
JZ 0x00101566
ADD RAX,0x1
CMP RCX,RAX
JZ 0x00101570
LAB_0010155d:
MOVZX EDX,byte ptr [RAX + 0x2]
CMP DL,byte ptr [RAX + 0x1]
JNZ 0... | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
if (2 < (ulong)param_1[1]) {
pcVar2 = (char *)*param_1;
pcVar1 = pcVar2 + (param_1[1] - 2);
while ((pcVar2[2] != pcVar2[1] && (pcVar2[2] != *pcVar2))) {
pcVar2 = pcVar2 + 1;
if (pcVar1 == pcVar2) {
... |
324 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<float> grades){
vector<string> out={};
for (int i=0;i<grades.size();i++)
{
if (grades[i]>=3.9999) out.push_back("A+");
if (grades[i]>3.7001 and grades[i]<3.9999) out.push_back("A");
if (grades[i]>3.3001 and grades[i]<=3.7001) out.push_back("A-");
i... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({4.0, 3, 1.7, 2, 3.5}) , {"A+", "B", "C-", "C", "A-"}));
a... | O0 | cpp | func0[abi:cxx11](std::vector<float, std::allocator<float> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x58(%rbp),%rax
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
movq $0x0,0x10... | _Z5func0B5cxx11St6vectorIfSaIfEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0B8h
mov [rbp+var_B8], rdi
mov [rbp+var_C0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_B8]
pxor xmm0, xmm0
movups xmmword ptr [rax], xmm0
movq qword ptr [rax+10h]... | long long func0[abi:cxx11](long long a1, long long a2)
{
unsigned long long v13; // rbx
char v15; // [rsp+13h] [rbp-ADh] BYREF
int i; // [rsp+14h] [rbp-ACh]
char *v17; // [rsp+18h] [rbp-A8h]
char *v18; // [rsp+20h] [rbp-A0h]
char *v19; // [rsp+28h] [rbp-98h]
char *v20; // [rsp+30h] [rbp-90h]
char *v21;... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RBP + -0xb8],RDI
MOV qword ptr [RBP + -0xc0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0xb8]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword ptr [RAX + 0x10],XMM0
MOV R... | /* func0[abi:cxx11](std::vector<float, std::allocator<float> >) */
vector<std::string,std::allocator<std::string>> * func0_abi_cxx11_(vector param_1)
{
bool bVar1;
float *pfVar2;
ulong uVar3;
ulong uVar4;
vector<float,std::allocator<float>> *in_RSI;
int4 in_register_0000003c;
vector<std::string,std::all... |
325 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<float> grades){
vector<string> out={};
for (int i=0;i<grades.size();i++)
{
if (grades[i]>=3.9999) out.push_back("A+");
if (grades[i]>3.7001 and grades[i]<3.9999) out.push_back("A");
if (grades[i]>3.3001 and grades[i]<=3.7001) out.push_back("A-");
i... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({4.0, 3, 1.7, 2, 3.5}) , {"A+", "B", "C-", "C", "A-"}));
a... | O1 | cpp | func0[abi:cxx11](std::vector<float, std::allocator<float> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r13
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
j... | _Z5func0B5cxx11St6vectorIfSaIfEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r13, rdi
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp [rsi+8], rdx
jz ... | long long func0[abi:cxx11](long long a1, long long *a2)
{
long long v2; // rdx
unsigned long long i; // r12
double v4; // xmm0_8
double v5; // xmm0_8
double v6; // xmm0_8
double v7; // xmm0_8
double v8; // xmm0_8
double v9; // xmm0_8
double v10; // xmm0_8
double v11; // xmm0_8
double v12; // xmm0... | func0[abi:cxx11]:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R13,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDX
JZ 0x00101b27
MOV RBX,RSI
MOV R1... | /* func0[abi:cxx11](std::vector<float, std::allocator<float> >) */
vector<std::string,std::allocator<std::string>> * func0_abi_cxx11_(vector param_1)
{
long lVar1;
long lVar2;
long *in_RSI;
int4 in_register_0000003c;
vector<std::string,std::allocator<std::string>> *this;
ulong uVar3;
long in_FS_OFFSET;
... |
326 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<float> grades){
vector<string> out={};
for (int i=0;i<grades.size();i++)
{
if (grades[i]>=3.9999) out.push_back("A+");
if (grades[i]>3.7001 and grades[i]<3.9999) out.push_back("A");
if (grades[i]>3.3001 and grades[i]<=3.7001) out.push_back("A-");
i... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({4.0, 3, 1.7, 2, 3.5}) , {"A+", "B", "C-", "C", "A-"}));
a... | O2 | cpp | func0[abi:cxx11](std::vector<float, std::allocator<float> >):
endbr64
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
mov (%rsi),%rax
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
cmp 0x8(... | _Z5func0B5cxx11St6vectorIfSaIfEE:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rdi
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
mov rax, [rsi]
movups xmmword ptr [rdi], xmm0
cmp ... | long long func0[abi:cxx11](long long a1, long long *a2)
{
long long v2; // rax
unsigned long long i; // r12
double v4; // xmm0_8
void *v6[2]; // [rsp+18h] [rbp-68h] BYREF
_QWORD v7[11]; // [rsp+28h] [rbp-58h] BYREF
v7[3] = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
v2 = *a2;
*(_OWORD *)a1 = 0... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI]
MOVUPS xmmword ptr [RDI],XMM0
CMP qword ptr [RSI + 0x8],RAX
JZ 0x00102310
... | /* func0[abi:cxx11](std::vector<float, std::allocator<float> >) */
vector<std::string,std::allocator<std::string>> * func0_abi_cxx11_(vector param_1)
{
long lVar1;
double dVar2;
long lVar3;
long *in_RSI;
int4 in_register_0000003c;
vector<std::string,std::allocator<std::string>> *this;
ulong uVar4;
lon... |
327 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<float> grades){
vector<string> out={};
for (int i=0;i<grades.size();i++)
{
if (grades[i]>=3.9999) out.push_back("A+");
if (grades[i]>3.7001 and grades[i]<3.9999) out.push_back("A");
if (grades[i]>3.3001 and grades[i]<=3.7001) out.push_back("A-");
i... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({4.0, 3, 1.7, 2, 3.5}) , {"A+", "B", "C-", "C", "A-"}));
a... | O3 | cpp | func0[abi:cxx11](std::vector<float, std::allocator<float> >):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x30,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
mov (%rsi),%rax
movups %xmm0,(%rdi)
cmp 0x8(%r... | _Z5func0B5cxx11St6vectorIfSaIfEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 58h
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
mov rax, [rsi]
movups xmmword ptr [rdi], xmm0
cmp ... | long long func0[abi:cxx11](long long a1, long long *a2)
{
long long v2; // rax
unsigned long long i; // r12
long long v5; // rsi
double v6; // xmm0_8
long long v7; // rsi
long long v8; // rsi
long long v9; // rsi
long long v10; // rsi
long long v11; // rsi
long long v12; // rsi
long long v13; // ... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI]
MOVUPS xmmword ptr [RDI],XMM0
CMP qword ptr [RSI + 0x8],RAX
JZ 0x001022c0
... | /* WARNING: Removing unreachable block (ram,0x001020dd) */
/* WARNING: Removing unreachable block (ram,0x00102051) */
/* WARNING: Removing unreachable block (ram,0x00101eab) */
/* WARNING: Removing unreachable block (ram,0x00101d01) */
/* WARNING: Removing unreachable block (ram,0x00102263) */
/* WARNING: Removing unre... |
328 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string str){
int l,i;
l=str.length();
if (l<2) return false;
for (i=2;i*i<=l;i++)
if (l%i==0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello") == true);
assert (func0("abcdcba") == true);
assert (func0("kittens") == true);
assert (func0("orange") == false);
assert (func0("wow") == true);
assert (func0("world") == true);
assert (func0("MadaM") == true);
assert ... | 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 1280 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv@plt>
mov %eax,-0x4(%rbp)
cmpl ... | _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)
mov [rbp+var_4], eax
cmp [r... | long long func0(long long a1)
{
int i; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
v3 = std::string::length(a1);
if ( v3 <= 1 )
return 0LL;
for ( i = 2; v3 >= i * i; ++i )
{
if ( !(v3 % i) )
return 0LL;
}
return 1LL;
} | 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 0x00101200
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x1
JG 0x00101355
MOV EAX,0x0
JMP 0x00101386
LAB_00101355:
MOV dword ptr [RBP + -0x8],0x2
JMP 0x00101376
LAB_0010135e:
MO... | /* func0(std::string) */
int8 func0(void)
{
int iVar1;
int8 uVar2;
int local_10;
iVar1 = std::string::length();
if (iVar1 < 2) {
uVar2 = 0;
}
else {
for (local_10 = 2; local_10 * local_10 <= iVar1; local_10 = local_10 + 1) {
if (iVar1 % local_10 == 0) {
return 0;
}
}
... |
329 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string str){
int l,i;
l=str.length();
if (l<2) return false;
for (i=2;i*i<=l;i++)
if (l%i==0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello") == true);
assert (func0("abcdcba") == true);
assert (func0("kittens") == true);
assert (func0("orange") == false);
assert (func0("wow") == true);
assert (func0("world") == true);
assert (func0("MadaM") == true);
assert ... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
mov %eax,%esi
mov $0x0,%edx
cmp $0x1,%eax
jle 122c <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x43>
cmp $0x3,%eax
jle 122f <_Z5func0NSt7__cxx1112basic_stringIcSt11ch... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
mov esi, eax
mov edx, 0
cmp eax, 1
jle short loc_124C
cmp eax, 3
jle short loc_124F
test al, 1
jz short loc_1256
mov ecx, 2
loc_122B:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp ea... | long long func0(long long a1)
{
long long v1; // rax
unsigned int v2; // edx
int v3; // ecx
v1 = *(_QWORD *)(a1 + 8);
v2 = 0;
if ( (int)v1 > 1 )
{
if ( (int)v1 <= 3 )
{
return 1;
}
else if ( (v1 & 1) != 0 )
{
v3 = 2;
while ( 1 )
{
++v3;
if ( v3... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV ESI,EAX
MOV EDX,0x0
CMP EAX,0x1
JLE 0x0010124c
CMP EAX,0x3
JLE 0x0010124f
TEST AL,0x1
JZ 0x00101256
MOV ECX,0x2
LAB_0010122b:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JG 0x00101247
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010122b
MOV EDX,0x0
JMP 0x0010124c
LA... | /* func0(std::string) */
int8 func0(long param_1)
{
ulong uVar1;
int iVar2;
int iVar3;
int8 uVar4;
uVar1 = *(ulong *)(param_1 + 8);
iVar2 = (int)uVar1;
uVar4 = 0;
if (1 < iVar2) {
if (iVar2 < 4) {
uVar4 = 1;
}
else if ((uVar1 & 1) == 0) {
uVar4 = 0;
}
else {
iV... |
330 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string str){
int l,i;
l=str.length();
if (l<2) return false;
for (i=2;i*i<=l;i++)
if (l%i==0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello") == true);
assert (func0("abcdcba") == true);
assert (func0("kittens") == true);
assert (func0("orange") == false);
assert (func0("wow") == true);
assert (func0("world") == true);
assert (func0("MadaM") == true);
assert ... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
xor %r8d,%r8d
mov %eax,%esi
cmp $0x1,%eax
jle 1aa3 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x43>
cmp $0x3,%eax
jle 1a9d <_Z5func0NSt7__cxx1112basic_stringIcSt11ch... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
xor edx, edx
mov esi, eax
cmp eax, 1
jle short loc_16F2
cmp eax, 3
jle short loc_16ED
test al, 1
jz short loc_16F2
mov ecx, 2
jmp short loc_16E1
loc_16D8:
mov eax, esi
cdq
idiv ecx
t... | long long func0(long long a1)
{
long long v1; // rax
unsigned int v2; // edx
int v3; // ecx
v1 = *(_QWORD *)(a1 + 8);
v2 = 0;
if ( (int)v1 <= 1 )
return v2;
if ( (int)v1 <= 3 )
return 1;
if ( (v1 & 1) != 0 )
{
v3 = 2;
while ( 1 )
{
++v3;
if ( v3 * v3 > (int)v1 )
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
XOR EDX,EDX
MOV ESI,EAX
CMP EAX,0x1
JLE 0x001016f2
CMP EAX,0x3
JLE 0x001016ed
TEST AL,0x1
JZ 0x001016f2
MOV ECX,0x2
JMP 0x001016e1
LAB_001016d8:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001016f8
LAB_001016e1:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JLE 0x001016d8
... | /* func0(std::string) */
int8 func0(long param_1)
{
ulong uVar1;
int iVar2;
int iVar3;
int8 uVar4;
uVar1 = *(ulong *)(param_1 + 8);
uVar4 = 0;
iVar2 = (int)uVar1;
if (1 < iVar2) {
if (3 < iVar2) {
if ((uVar1 & 1) == 0) {
return 0;
}
iVar3 = 2;
while (iVar3 = iVar... |
331 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string str){
int l,i;
l=str.length();
if (l<2) return false;
for (i=2;i*i<=l;i++)
if (l%i==0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello") == true);
assert (func0("abcdcba") == true);
assert (func0("kittens") == true);
assert (func0("orange") == false);
assert (func0("wow") == true);
assert (func0("world") == true);
assert (func0("MadaM") == true);
assert ... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
xor %r8d,%r8d
mov %eax,%esi
cmp $0x1,%eax
jle 1aa3 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x43>
cmp $0x3,%eax
jle 1a9d <_Z5func0NSt7__cxx1112basic_stringIcSt11ch... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
xor edx, edx
mov esi, eax
cmp eax, 1
jle short loc_1A32
cmp eax, 3
jle short loc_1A2D
test al, 1
jz short loc_1A32
mov ecx, 2
jmp short loc_1A21
loc_1A18:
mov eax, esi
cdq
idiv ecx
t... | long long func0(long long a1)
{
long long v1; // rax
unsigned int v2; // edx
int v3; // ecx
v1 = *(_QWORD *)(a1 + 8);
v2 = 0;
if ( (int)v1 <= 1 )
return v2;
if ( (int)v1 <= 3 )
return 1;
if ( (v1 & 1) != 0 )
{
v3 = 2;
while ( 1 )
{
++v3;
if ( v3 * v3 > (int)v1 )
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
XOR EDX,EDX
MOV ESI,EAX
CMP EAX,0x1
JLE 0x00101a32
CMP EAX,0x3
JLE 0x00101a2d
TEST AL,0x1
JZ 0x00101a32
MOV ECX,0x2
JMP 0x00101a21
LAB_00101a18:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101a38
LAB_00101a21:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JLE 0x00101a18
... | /* func0(std::string) */
int8 func0(long param_1)
{
ulong uVar1;
int iVar2;
int iVar3;
int8 uVar4;
uVar1 = *(ulong *)(param_1 + 8);
uVar4 = 0;
iVar2 = (int)uVar1;
if (1 < iVar2) {
if (3 < iVar2) {
if ((uVar1 & 1) == 0) {
return 0;
}
iVar3 = 2;
while (iVar3 = iVar... |
332 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
if (n<1) return 0;
if (n==1) return 1;
int out=18;
for (int i=2;i<n;i++)
out=out*10;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 1);
assert (func0(2) == 18);
assert (func0(3) == 180);
assert (func0(4) == 1800);
assert (func0(5) == 18000);
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jg 1161 <_Z5func0i+0x18>
mov $0x0,%eax
jmp 119c <_Z5func0i+0x53>
cmpl $0x1,-0x14(%rbp)
jne 116e <_Z5func0i+0x25>
mov $0x1,%eax
jmp 119c <_Z5func0i+0x53>
movl $0x12,-0x8(%rbp)
movl $0x2,-0x4(%rbp)
mo... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jg short loc_1161
mov eax, 0
jmp short loc_119C
loc_1161:
cmp [rbp+var_14], 1
jnz short loc_116E
mov eax, 1
jmp short loc_119C
loc_116E:
mov [rbp+var_8], 12h
mov [rbp+var_4], 2
jmp ... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
if ( a1 <= 0 )
return 0LL;
if ( a1 == 1 )
return 1LL;
v2 = 18;
for ( i = 2; i < a1; ++i )
v2 *= 10;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JG 0x00101161
MOV EAX,0x0
JMP 0x0010119c
LAB_00101161:
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x0010116e
MOV EAX,0x1
JMP 0x0010119c
LAB_0010116e:
MOV dword ptr [RBP + -0x8],0x12
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00101191... | /* func0(int) */
int func0(int param_1)
{
int4 local_10;
int4 local_c;
if (param_1 < 1) {
local_10 = 0;
}
else if (param_1 == 1) {
local_10 = 1;
}
else {
local_10 = 0x12;
for (local_c = 2; local_c < param_1; local_c = local_c + 1) {
local_10 = local_10 * 10;
}
}
return l... |
333 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
if (n<1) return 0;
if (n==1) return 1;
int out=18;
for (int i=2;i<n;i++)
out=out*10;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 1);
assert (func0(2) == 18);
assert (func0(3) == 180);
assert (func0(4) == 1800);
assert (func0(5) == 18000);
}
| O1 | cpp | func0(int):
endbr64
mov $0x0,%eax
test %edi,%edi
jle 117e <_Z5func0i+0x35>
mov %edi,%eax
cmp $0x1,%edi
je 117e <_Z5func0i+0x35>
cmp $0x2,%edi
jle 1179 <_Z5func0i+0x30>
mov $0x2,%edx
mov $0x12,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
add $0x1,%edx
cmp %edx,%edi
jne 116c <_Z5... | _Z5func0i:
endbr64
mov eax, 0
test edi, edi
jle short locret_117E
mov eax, edi
cmp edi, 1
jz short locret_117E
cmp edi, 2
jle short loc_1179
mov edx, 2
mov eax, 12h
loc_116C:
lea eax, [rax+rax*4]
add eax, eax
add edx, 1
cmp edi, edx
jnz short loc_116C
retn
loc... | long long func0(int a1)
{
long long result; // rax
int v2; // edx
result = 0LL;
if ( a1 > 0 )
{
result = (unsigned int)a1;
if ( a1 != 1 )
{
if ( a1 <= 2 )
{
return 18LL;
}
else
{
v2 = 2;
LODWORD(result) = 18;
do
{
re... | func0:
ENDBR64
MOV EAX,0x0
TEST EDI,EDI
JLE 0x0010117e
MOV EAX,EDI
CMP EDI,0x1
JZ 0x0010117e
CMP EDI,0x2
JLE 0x00101179
MOV EDX,0x2
MOV EAX,0x12
LAB_0010116c:
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
ADD EDX,0x1
CMP EDI,EDX
JNZ 0x0010116c
RET
LAB_00101179:
MOV EAX,0x12
LAB_0010117e:
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = 0;
if ((0 < param_1) && (iVar1 = param_1, param_1 != 1)) {
if (2 < param_1) {
iVar2 = 2;
iVar1 = 0x12;
do {
iVar1 = iVar1 * 10;
iVar2 = iVar2 + 1;
} while (param_1 != iVar2);
return iVa... |
334 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
if (n<1) return 0;
if (n==1) return 1;
int out=18;
for (int i=2;i<n;i++)
out=out*10;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 1);
assert (func0(2) == 18);
assert (func0(3) == 180);
assert (func0(4) == 1800);
assert (func0(5) == 18000);
}
| O2 | cpp | func0(int):
endbr64
xor %eax,%eax
test %edi,%edi
jle 1178 <_Z5func0i+0x38>
mov $0x1,%eax
cmp $0x1,%edi
je 1178 <_Z5func0i+0x38>
mov $0x12,%eax
cmp $0x2,%edi
je 1178 <_Z5func0i+0x38>
mov $0x2,%edx
nopl 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%eax
add $0x1,%edx
add %eax,%eax
cmp %e... | _Z5func0i:
endbr64
xor eax, eax
test edi, edi
jle short locret_117D
mov eax, 1
cmp edi, 1
jz short locret_117D
cmp edi, 2
jz short loc_1178
mov edx, 2
mov eax, 12h
nop dword ptr [rax+rax+00h]
loc_1168:
lea eax, [rax+rax*4]
add edx, 1
add eax, eax
cmp edi, edx... | long long func0(int a1)
{
long long result; // rax
int v2; // edx
result = 0LL;
if ( a1 > 0 )
{
result = 1LL;
if ( a1 != 1 )
{
if ( a1 == 2 )
{
return 18LL;
}
else
{
v2 = 2;
LODWORD(result) = 18;
do
{
++v2;
... | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x0010117d
MOV EAX,0x1
CMP EDI,0x1
JZ 0x0010117d
CMP EDI,0x2
JZ 0x00101178
MOV EDX,0x2
MOV EAX,0x12
NOP dword ptr [RAX + RAX*0x1]
LAB_00101168:
LEA EAX,[RAX + RAX*0x4]
ADD EDX,0x1
ADD EAX,EAX
CMP EDI,EDX
JNZ 0x00101168
RET
LAB_00101178:
MOV EAX,0x12
LAB_0010117d:
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = 0;
if ((0 < param_1) && (iVar1 = 1, param_1 != 1)) {
if (param_1 != 2) {
iVar2 = 2;
iVar1 = 0x12;
do {
iVar2 = iVar2 + 1;
iVar1 = iVar1 * 10;
} while (param_1 != iVar2);
return iVar1;
... |
335 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
if (n<1) return 0;
if (n==1) return 1;
int out=18;
for (int i=2;i<n;i++)
out=out*10;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 1);
assert (func0(2) == 18);
assert (func0(3) == 180);
assert (func0(4) == 1800);
assert (func0(5) == 18000);
}
| O3 | cpp | func0(int):
endbr64
xor %eax,%eax
test %edi,%edi
jle 1178 <_Z5func0i+0x38>
mov $0x1,%eax
cmp $0x1,%edi
je 1178 <_Z5func0i+0x38>
mov $0x12,%eax
cmp $0x2,%edi
je 1178 <_Z5func0i+0x38>
mov $0x2,%edx
nopl 0x0(%rax,%rax,1)
lea (%rax,%rax,4),%eax
add $0x1,%edx
add %eax,%eax
cmp %e... | _Z5func0i:
endbr64
xor eax, eax
test edi, edi
jle short locret_117D
mov eax, 1
cmp edi, 1
jz short locret_117D
cmp edi, 2
jz short loc_1178
mov edx, 2
mov eax, 12h
nop dword ptr [rax+rax+00h]
loc_1168:
lea eax, [rax+rax*4]
add edx, 1
add eax, eax
cmp edi, edx... | long long func0(int a1)
{
long long result; // rax
int v2; // edx
result = 0LL;
if ( a1 > 0 )
{
result = 1LL;
if ( a1 != 1 )
{
if ( a1 == 2 )
{
return 18LL;
}
else
{
v2 = 2;
LODWORD(result) = 18;
do
{
++v2;
... | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x0010117d
MOV EAX,0x1
CMP EDI,0x1
JZ 0x0010117d
CMP EDI,0x2
JZ 0x00101178
MOV EDX,0x2
MOV EAX,0x12
NOP dword ptr [RAX + RAX*0x1]
LAB_00101168:
LEA EAX,[RAX + RAX*0x4]
ADD EDX,0x1
ADD EAX,EAX
CMP EDI,EDX
JNZ 0x00101168
RET
LAB_00101178:
MOV EAX,0x12
LAB_0010117d:
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = 0;
if ((0 < param_1) && (iVar1 = 1, param_1 != 1)) {
if (param_1 != 2) {
iVar2 = 2;
iVar1 = 0x12;
do {
iVar2 = iVar2 + 1;
iVar1 = iVar1 * 10;
} while (param_1 != iVar2);
return iVar1;
... |
336 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int N){
string str,bi="";
str=to_string(N);
int i,sum=0;
for (int i=0;i<str.length();i++)
sum+=str[i]-48;
while (sum>0)
{
bi=to_string(sum%2)+bi;
sum=sum/2;
}
return bi;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1000) == "1");
assert (func0(150) == "110");
assert (func0(147) == "1100");
assert (func0(333) == "1001");
assert (func0(963) == "10010");
}
| O0 | cpp | func0[abi:cxx11](int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x98,%rsp
mov %rdi,-0x98(%rbp)
mov %esi,-0x9c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x80(%rbp),%rax
mov %rax,%rdi
callq 2320 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev@plt>
lea... | _Z5func0B5cxx11i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+var_A8], rdi
mov [rbp+var_AC], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_80]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::stri... | long long func0[abi:cxx11](long long a1, int a2)
{
char *v2; // rax
unsigned long long v3; // rbx
char v5; // [rsp+1Fh] [rbp-91h] BYREF
int v6; // [rsp+20h] [rbp-90h]
int i; // [rsp+24h] [rbp-8Ch]
char *v8; // [rsp+28h] [rbp-88h]
_BYTE v9[32]; // [rsp+30h] [rbp-80h] BYREF
_BYTE v10[32]; // [rsp+50h] [r... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0xa8],RDI
MOV dword ptr [RBP + -0xac],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x80]
MOV RDI,RAX
CALL 0x001022f0
LEA RAX,[RBP + -0x91]
MOV qword ptr [RBP + -0x88],RAX
NOP
NOP
LEA... | /* func0[abi:cxx11](int) */
string * func0_abi_cxx11_(int param_1)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
int4 in_register_0000003c;
string *this;
long in_FS_OFFSET;
allocator local_99;
int local_98;
int local_94;
allocator *local_90;
string local_88 [32];
string local_68 [32];
string loc... |
337 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int N){
string str,bi="";
str=to_string(N);
int i,sum=0;
for (int i=0;i<str.length();i++)
sum+=str[i]-48;
while (sum>0)
{
bi=to_string(sum%2)+bi;
sum=sum/2;
}
return bi;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1000) == "1");
assert (func0(150) == "110");
assert (func0(147) == "1100");
assert (func0(333) == "1001");
assert (func0(963) == "10010");
}
| O1 | cpp | func0[abi:cxx11](int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rdi,%rbp
mov %esi,%r8d
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rax
mov %rax,(%rsp)
movq $0x0,0x8(%rsp)
movb $0x0,0x10(%rsp)
lea 0x10(%rdi),%r13
mov %r13,(%rdi)... | _Z5func0B5cxx11i:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 70h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+98h+var_30], rax
xor eax, eax
lea rax, [rsp+98h+var_88]
mov [rsp+98h+var_98], rax
mov [rsp+98h+var_90], 0
mov byte ptr [rsp+98h+var_88], 0
lea ... | long long func0[abi:cxx11](long long a1, int a2)
{
long long v3; // r12
unsigned int v4; // r14d
unsigned int v5; // r13d
unsigned int v6; // eax
unsigned int v7; // ebp
unsigned int v8; // edx
char *v9; // rax
int v10; // ebp
int v11; // edx
unsigned int v12; // edx
unsigned int v13; // edx
un... | func0[abi:cxx11]:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
MOV... | /* WARNING: Removing unreachable block (ram,0x0010137e) */
/* WARNING: Removing unreachable block (ram,0x00101391) */
/* WARNING: Removing unreachable block (ram,0x001013b7) */
/* WARNING: Type propagation algorithm not settling */
/* func0[abi:cxx11](int) */
ulong * func0_abi_cxx11_(int param_1)
{
bool bVar1;
ul... |
338 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int N){
string str,bi="";
str=to_string(N);
int i,sum=0;
for (int i=0;i<str.length();i++)
sum+=str[i]-48;
while (sum>0)
{
bi=to_string(sum%2)+bi;
sum=sum/2;
}
return bi;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1000) == "1");
assert (func0(150) == "110");
assert (func0(147) == "1100");
assert (func0(333) == "1001");
assert (func0(963) == "10010");
}
| O2 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
lea 0x10(%rdi),%r15
mov %esi,%r8d
lea 0xba0(%rip),%rcx
push %r14
mov $0x10,%edx
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x88,%rsp
mov 0x2b56(%rip),%r14
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
mov %r15,(%... | _Z5func0B5cxx11i:
endbr64
push r15
push r14
mov r14d, esi
push r13
mov r13d, esi
push r12
shr r13d, 1Fh
push rbp
push rbx
mov rbx, rdi
sub rsp, 168h
mov rax, fs:28h
mov [rsp+198h+var_40], rax
xor eax, eax
neg r14d
lea rax, [rsp+198h+var_170+8]
mov byte ptr [... | long long func0[abi:cxx11](long long a1, int a2)
{
unsigned int v2; // r13d
unsigned int v4; // r14d
long long v5; // rbp
int v6; // eax
unsigned int v7; // r15d
__int8 *v8; // r13
long long v9; // rdx
unsigned long long v10; // rdx
int v11; // eax
unsigned int v12; // ecx
long long v13; // rax
... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,ESI
PUSH R13
MOV R13D,ESI
PUSH R12
SHR R13D,0x1f
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x168
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x158],RAX
XOR EAX,EAX
NEG R14D
LEA RAX,[RSP + 0x30]
MOV byte ptr [RSP + 0x30],0x0
CMOVS R14D,ESI
MOV byte ptr [RDI + 0x10],0... | /* WARNING: Removing unreachable block (ram,0x001016ec) */
/* WARNING: Removing unreachable block (ram,0x00101704) */
/* WARNING: Type propagation algorithm not settling */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* WARNING: Restarted to delay deadcode elimination for space:... |
339 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int N){
string str,bi="";
str=to_string(N);
int i,sum=0;
for (int i=0;i<str.length();i++)
sum+=str[i]-48;
while (sum>0)
{
bi=to_string(sum%2)+bi;
sum=sum/2;
}
return bi;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1000) == "1");
assert (func0(150) == "110");
assert (func0(147) == "1100");
assert (func0(333) == "1001");
assert (func0(963) == "10010");
}
| O3 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
mov %esi,%r8d
mov $0x10,%edx
lea 0x9df(%rip),%rcx
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x98,%rsp
mov 0x299a(%rip),%r14
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%rax
movb $0x0,0x... | _Z5func0B5cxx11i:
endbr64
push r15
push r14
mov r14d, esi
push r13
mov r13d, esi
push r12
shr r13d, 1Fh
push rbp
push rbx
mov rbx, rdi
sub rsp, 168h
mov rax, fs:28h
mov [rsp+198h+var_40], rax
xor eax, eax
neg r14d
lea rax, [rsp+198h+var_170+8]
mov byte ptr [... | long long func0[abi:cxx11](
long long a1,
int a2,
double a3,
__m128i a4,
__m128i a5,
__m128i a6,
double a7,
double a8,
__m128i a9)
{
unsigned int v9; // r13d
unsigned int v11; // r14d
long long v12; // rbp
int v13; // eax
unsigned int v1... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,ESI
PUSH R13
MOV R13D,ESI
PUSH R12
SHR R13D,0x1f
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x168
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x158],RAX
XOR EAX,EAX
NEG R14D
LEA RAX,[RSP + 0x30]
MOV byte ptr [RSP + 0x30],0x0
CMOVS R14D,ESI
MOV byte ptr [RDI + 0x10],0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int) */
ulong * func0_abi_cxx11_(int param_1)
{
ushort uVar1;
int auVar2 [14];
int auVar3 [12];
unkbyte10 Var4;
int auVar5 [12];
int auVar6 [12];
int auVar7 [14];
int auVar8 [12];
int auVar9 [12]... |
340 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i*2+1<lst.size();i++)
if (lst[i*2+1]%2==0) sum+=lst[i*2+1];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({4, 88}) == 88);
assert (func0({4, 5, 6, 7, 2, 122}) == 122);
assert (func0({4, 0, 6, 7}) == 0);
assert (func0({4, 4, 6, 8}) == 12);
assert (func0({4, 2, 6, 7}) == 2);
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
add %eax,%eax
add $0x1,%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 173c <_ZNKS... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_12B5
loc_126A:
mov eax, [rbp+var_14]
add eax, eax
add eax, 1
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mo... | long long func0(long long a1)
{
unsigned int v2; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = 0;
for ( i = 0; 2 * i + 1 < (unsigned long long)std::vector<int>::size(a1); ++i )
{
if ( (*(_DWORD *)std::vector<int>::operator[](a1, 2 * i + 1) & 1) == 0 )
v2 += *(_DWORD *)std::vector<int>:... | 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 0x001012b5
LAB_0010126a:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,EAX
ADD EAX,0x1
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
uint *puVar1;
int *piVar2;
ulong uVar3;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int4 local_20;
int4 local_1c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
... |
341 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i*2+1<lst.size();i++)
if (lst[i*2+1]%2==0) sum+=lst[i*2+1];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({4, 88}) == 88);
assert (func0({4, 5, 6, 7, 2, 122}) == 122);
assert (func0({4, 0, 6, 7}) == 0);
assert (func0({4, 4, 6, 8}) == 12);
assert (func0({4, 2, 6, 7}) == 2);
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rax
sub %rdx,%rax
mov %rax,%rcx
sar $0x2,%rcx
cmp $0x7,%rax
jbe 1255 <_Z5func0St6vectorIiSaIiEE+0x4c>
lea 0x4(%rdx),%rax
lea -0x8(,%rcx,4),%rcx
and $0xfffffffffffffff8,%rcx
lea 0xc(%rdx,%rcx,1),%rdi
mo... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov r8, [rdi]
mov rax, [rdi+8]
sub rax, r8
mov rdi, rax
sar rdi, 2
cmp rax, 4
jbe short loc_1247
mov eax, 1
mov edx, 0
loc_122E:
mov ecx, [r8+rax*4]
lea esi, [rdx+rcx]
test cl, 1
cmovz edx, esi
add rax, 2
cmp rax, rdi
jb sh... | long long func0(long long *a1)
{
long long v1; // r8
long long v2; // rax
unsigned long long v3; // rdi
unsigned long long v4; // rax
unsigned int v5; // edx
int v6; // ecx
v1 = *a1;
v2 = a1[1] - *a1;
v3 = v2 >> 2;
if ( (unsigned long long)v2 <= 4 )
{
return 0;
}
else
{
v4 = 1LL;
... | func0:
ENDBR64
MOV R8,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,R8
MOV RDI,RAX
SAR RDI,0x2
CMP RAX,0x4
JBE 0x00101247
MOV EAX,0x1
MOV EDX,0x0
LAB_0010122e:
MOV ECX,dword ptr [R8 + RAX*0x4]
LEA ESI,[RDX + RCX*0x1]
TEST CL,0x1
CMOVZ EDX,ESI
ADD RAX,0x2
CMP RAX,RDI
JC 0x0010122e
LAB_00101244:
MOV EAX,EDX
RET
L... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
uint uVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
int4 in_register_0000003c;
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar3 = ((long *)CONCAT44(in_register_0000003c,param_1))[1] - lVar2;
if ... |
342 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i*2+1<lst.size();i++)
if (lst[i*2+1]%2==0) sum+=lst[i*2+1];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({4, 88}) == 88);
assert (func0({4, 5, 6, 7, 2, 122}) == 122);
assert (func0({4, 0, 6, 7}) == 0);
assert (func0({4, 4, 6, 8}) == 12);
assert (func0({4, 2, 6, 7}) == 2);
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rax
sub %rdx,%rax
mov %rax,%rcx
sar $0x2,%rcx
cmp $0x7,%rax
jbe 1638 <_Z5func0St6vectorIiSaIiEE+0x58>
lea -0x8(,%rcx,4),%rcx
lea 0x4(%rdx),%rax
xor %r8d,%r8d
and $0xfffffffffffffff8,%rcx
lea 0xc(%rd... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov r8, [rdi]
mov rax, [rdi+8]
sub rax, r8
mov rdi, rax
sar rdi, 2
cmp rax, 4
jbe short loc_1468
mov eax, 1
xor edx, edx
nop word ptr [rax+rax+00h]
loc_1448:
mov ecx, [r8+rax*4]
lea esi, [rdx+rcx]
and ecx, 1
cmovz edx, esi
add ... | long long func0(long long *a1)
{
long long v1; // r8
long long v2; // rax
unsigned long long v3; // rdi
unsigned long long v4; // rax
unsigned int v5; // edx
int v6; // ecx
v1 = *a1;
v2 = a1[1] - *a1;
v3 = v2 >> 2;
if ( (unsigned long long)v2 <= 4 )
return 0LL;
v4 = 1LL;
v5 = 0;
do
{
... | func0:
ENDBR64
MOV R8,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,R8
MOV RDI,RAX
SAR RDI,0x2
CMP RAX,0x4
JBE 0x00101468
MOV EAX,0x1
XOR EDX,EDX
NOP word ptr [RAX + RAX*0x1]
LAB_00101448:
MOV ECX,dword ptr [R8 + RAX*0x4]
LEA ESI,[RDX + RCX*0x1]
AND ECX,0x1
CMOVZ EDX,ESI
ADD RAX,0x2
CMP RAX,RDI
JC 0x00101448
MO... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
uint uVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
int4 in_register_0000003c;
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar3 = ((long *)CONCAT44(in_register_0000003c,param_1))[1] - lVar2;
if ... |
343 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int sum=0;
for (int i=0;i*2+1<lst.size();i++)
if (lst[i*2+1]%2==0) sum+=lst[i*2+1];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({4, 88}) == 88);
assert (func0({4, 5, 6, 7, 2, 122}) == 122);
assert (func0({4, 0, 6, 7}) == 0);
assert (func0({4, 4, 6, 8}) == 12);
assert (func0({4, 2, 6, 7}) == 2);
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%rax
sub %rsi,%rax
mov %rax,%rdi
sar $0x2,%rdi
cmp $0x7,%rax
jbe 1a90 <_Z5func0St6vectorIiSaIiEE+0x100>
lea -0x2(%rdi),%rdx
cmp $0x7,%rdx
jbe 1a93 <_Z5func0St6vectorIiSaIiEE+0x103>
shr $0x3,%rdx
pxor ... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rcx, [rdi]
mov rax, [rdi+8]
sub rax, rcx
mov rdi, rax
sar rdi, 2
cmp rax, 4
jbe loc_1A88
lea rsi, [rdi-2]
cmp rax, 24h ; '$'
jbe loc_1A8B
shr rsi, 3
pxor xmm2, xmm2
movdqa xmm4, cs:xmmword_2100
mov rax, rcx
mov rdx, rsi
movdq... | long long func0(long long *a1)
{
long long v1; // rcx
long long v2; // rax
unsigned long long v3; // rdi
unsigned long long v4; // rsi
__m128i v5; // xmm2
__m128i si128; // xmm4
long long v7; // rax
__m128 v8; // xmm1
__m128 v9; // xmm5
__m128i v10; // xmm1
long long v11; // rdx
int v12; // esi... | func0:
ENDBR64
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RCX
MOV RDI,RAX
SAR RDI,0x2
CMP RAX,0x4
JBE 0x00101a88
LEA RSI,[RDI + -0x2]
CMP RAX,0x24
JBE 0x00101a8b
SHR RSI,0x3
PXOR XMM2,XMM2
MOVDQA XMM4,xmmword ptr [0x00102100]
MOV RAX,RCX
MOV RDX,RSI
MOVDQA XMM3,XMM2
SHL RDX,0x5
ADD RDX,RCX
NOP
LAB_00... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
uint *puVar1;
uint *puVar2;
uint uVar3;
long lVar4;
uint *puVar5;
uint *puVar6;
ulong uVar7;
long lVar8;
int iVar9;
int4 in_register_... |
344 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string s){
string out="";
string current="";
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ')
{
sort(current.begin(),current.end());
if (out.length()>0) out=out+' ';
out=out+current;
current="";
}
else current=current+s[i];
return ou... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hi") == "Hi");
assert (func0("hello") == "ehllo");
assert (func0("number") == "bemnru");
assert (func0("abcd") == "abcd");
assert (func0("Hello World!!!") == "Hello !!!Wdlor");
assert (func0("") == "");
assert (func0("Hi. My name i... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xd8,%rsp
mov %rdi,-0xd8(%rbp)
mov %rsi,-0xe0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0xc5(%rbp),%rax
mov %rax,%rdi
callq 23d0 <_... | _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
lea rax, [rbp+var_75]
mov [rbp+var_70], rax
nop
nop
lea rdx, [rbp... | 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
char v7; // [rsp+1Bh] [rbp-75h] BYREF
int i; // [rsp+1Ch] [rbp-74h]
char *v9; // [rsp+20h] [rbp-70h]
char *v10; // [rsp+28h] [rbp-68h]
_BYTE v11[32]; // [rsp+30h] [rb... | 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
LEA RAX,[RBP + -0x75]
MOV qword ptr [RBP + -0x70],RAX
NOP
NOP
LEA RDX,[RBP + -0x75]
MOV RAX,qword ptr [RBP + -0x88]
LEA RCX,[0... | /* func0(std::string) */
string * func0(string *param_1,string *param_2)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
char *pcVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
long in_FS_OFFSET;
allocator local_7d;
int local_7c;
allocator *local_78;
allocator *local_70;
string local_68 [32];
... |
345 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string s){
string out="";
string current="";
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ')
{
sort(current.begin(),current.end());
if (out.length()>0) out=out+' ';
out=out+current;
current="";
}
else current=current+s[i];
return ou... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hi") == "Hi");
assert (func0("hello") == "ehllo");
assert (func0("number") == "bemnru");
assert (func0("abcd") == "abcd");
assert (func0("Hello World!!!") == "Hello !!!Wdlor");
assert (func0("") == "");
assert (func0("Hi. My name i... | 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 $0xc8,%rsp
mov %rdi,%rbp
mov %rsi,%r13
mov %fs:0x28,%rax
mov %rax,0xb8(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
mov %rax,0x8(... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov rbp, rdi
mov r15, rsi
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rsp+0B8h+var_A0], rax
mov ... | void ** func0(void **a1, void **a2)
{
unsigned long long v4; // rbx
_BYTE *v5; // r12
_BYTE *v6; // rax
void *v7; // rcx
unsigned long long i; // r12
unsigned int v9; // edx
unsigned long long v10; // rax
unsigned long long v11; // rsi
_BYTE *v12; // rax
char *v13; // rcx
unsigned int v14; // edx
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RBP,RDI
MOV R15,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RDI],RAX
LEA RBX,[0x10320c]
MOV RDX,RBX
MOV RSI,RBX
LAB_0010134d:
CALL 0x001... | /* func0(std::string) */
ulong * func0(ulong *param_1,ulong *param_2)
{
ulong *puVar1;
ulong *puVar2;
char cVar3;
char cVar4;
ulong uVar5;
ulong *puVar6;
ulong *puVar7;
char *pcVar8;
ulong *puVar9;
int8 uVar10;
long lVar11;
__normal_iterator _Var12;
uint uVar13;
_Iter_less_iter extraout_ED... |
346 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string s){
string out="";
string current="";
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ')
{
sort(current.begin(),current.end());
if (out.length()>0) out=out+' ';
out=out+current;
current="";
}
else current=current+s[i];
return ou... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hi") == "Hi");
assert (func0("hello") == "ehllo");
assert (func0("number") == "bemnru");
assert (func0("abcd") == "abcd");
assert (func0("Hello World!!!") == "Hello !!!Wdlor");
assert (func0("") == "");
assert (func0("Hi. My name i... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0xd8,%rsp
mov %fs:0x28,%rax
mov %rax,0xc8(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movb $0x0,0x10... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
lea rdx, aHelloWorld+0Eh; ""
push r14
push r13
mov r13, rsi
mov rsi, rdx
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 0A8h
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
xor eax, eax
lea ... | void ** func0(void **a1, void **a2)
{
size_t v4; // rbp
double *v5; // r14
double *v6; // rdi
size_t v7; // rdx
double v8; // rcx
unsigned long long v9; // rbp
size_t v10; // r14
void *v11; // r15
double *v12; // rdi
size_t v13; // rdx
__m128 v14; // xmm0
double v15; // rdx
long long v16; // r... | func0:
ENDBR64
PUSH R15
LEA RDX,[0x1030b6]
PUSH R14
PUSH R13
MOV R13,RSI
MOV RSI,RDX
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV qword ptr [RSP + 0x28],RAX
LAB_00101b84:
CALL 0x001018c0
LEA RA... | /* func0(std::string) */
ulong * func0(ulong *param_1,ulong *param_2)
{
ulong *****pppppuVar1;
char cVar2;
long lVar3;
ulong *****pppppuVar4;
ulong ****ppppuVar5;
char *pcVar6;
ulong ****ppppuVar7;
ulong *****pppppuVar8;
ulong *puVar9;
char cVar10;
_Iter_less_iter extraout_EDX;
ulong uVar11;
... |
347 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string s){
string out="";
string current="";
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ')
{
sort(current.begin(),current.end());
if (out.length()>0) out=out+' ';
out=out+current;
current="";
}
else current=current+s[i];
return ou... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hi") == "Hi");
assert (func0("hello") == "ehllo");
assert (func0("number") == "bemnru");
assert (func0("abcd") == "abcd");
assert (func0("Hello World!!!") == "Hello !!!Wdlor");
assert (func0("") == "");
assert (func0("Hi. My name i... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0xf8,%rsp
mov %fs:0x28,%rax
mov %rax,0xe8(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movb $0x0,0x10... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
sub rsp, 0A8h
mov [rsp+0D8h+var_C8], rdi
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
mov rax, rdi
mov byte ptr [rsp+0D8h+var_80+8], 0
mov ... | long long func0(long long a1, void **a2)
{
void **v2; // rbp
void *v3; // r13
size_t v4; // r12
double *k; // rbx
double *v6; // rdi
size_t v7; // rdx
double v8; // rcx
unsigned long long v9; // r15
double *v10; // rdi
size_t v11; // rdx
__m128 v12; // xmm0
double v13; // rdx
signed long long... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,RDI
MOV byte ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x58],0x0
MOV byte ptr [RSP + 0x4d],0x20
MOV qword ptr [RSP + 0x78],0x0
M... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::string) */
ulong * func0(ulong *param_1,ulong *param_2)
{
ulong *******pppppppuVar1;
ulong *******pppppppuVar2;
char cVar3;
long lVar4;
ulong *******pppppppuVar5;
char *pcVar6;
char *pcVar7;
int8 uVar8;
char cVar9;
size_t sVar10;... |
348 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<vector<int>> func0(vector<vector<int>> lst, int x){
vector<vector<int>> out={};
for (int i=0;i<lst.size();i++)
for (int j=lst[i].size()-1;j>=0;j-=1)
if (lst[i][j]==x) out.push_back({i,j});
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<vector<int>> a,vector<vector<int>> b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i].size()!=b[i].size()) return false;
for (int j=0;j<a[i].size();j++)
if (a[i][j]!=b[i][j]) return false;
}
... | 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 %r13
push %r12
push %rbx
sub $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %edx,-0x74(%rbp)
mov %fs:0x28,%rax
mov %rax,-... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov [rbp+var_84], edx
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov rax, [rbp+var_78]
pxor xmm0, xmm0
movup... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
long long v4; // rax
unsigned long long v5; // rbx
char v8; // [rsp+2Fh] [rbp-61h] BYREF
int i; // [rsp+30h] [rbp-60h]
int j; // [rsp+34h] [rbp-5Ch]
char *v11; // [rsp+38h] [rbp-58h]
_BYTE v12[32]; // [rsp+40h] [rbp-50h] BYREF
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV dword ptr [RBP + -0x84],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0(vector param_1,int param_2)
{
vector<int,std::allocator<int>> *pvVar1;
int *p... |
349 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<vector<int>> func0(vector<vector<int>> lst, int x){
vector<vector<int>> out={};
for (int i=0;i<lst.size();i++)
for (int j=lst[i].size()-1;j>=0;j-=1)
if (lst[i][j]==x) out.push_back({i,j});
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<vector<int>> a,vector<vector<int>> b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i].size()!=b[i].size()) return false;
for (int j=0;j<a[i].size();j++)
if (a[i][j]!=b[i][j]) return false;
}
... | O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%r15
mov %edx,%r14d
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
mov... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r15, rdi
mov r14d, edx
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
... | long long func0(long long a1, long long *a2, int a3)
{
long long v4; // rdx
long long *v6; // rdx
long long **v7; // rsi
long long v8; // rbp
long long v9; // rbx
long long *v10; // rax
unsigned long long v12; // [rsp+0h] [rbp-78h]
void *v13; // [rsp+20h] [rbp-58h] BYREF
_QWORD *v14; // [rsp+28h] [rb... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R15,RDI
MOV R14D,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP RDX,qword ptr [RSI + 0x8]
JZ 0x0010152... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0(vector param_1,int param_2)
{
int8 *puVar1;
int in_EDX;
long *plVar2;
int... |
350 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<vector<int>> func0(vector<vector<int>> lst, int x){
vector<vector<int>> out={};
for (int i=0;i<lst.size();i++)
for (int j=lst[i].size()-1;j>=0;j-=1)
if (lst[i][j]==x) out.push_back({i,j});
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<vector<int>> a,vector<vector<int>> b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i].size()!=b[i].size()) return false;
for (int j=0;j<a[i].size();j++)
if (a[i][j]!=b[i][j]) return false;
}
... | O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
mov %edx,%r13d
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rsi,0x8(%rsp)
mov %fs:0x28,%rcx
mov %rcx,0x38(%rsp... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rdi
push r14
push r13
mov r13d, edx
push r12
push rbp
push rbx
sub rsp, 48h
mov [rsp+78h+var_68], rsi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
m... | long long func0(long long a1, long long *a2, int a3)
{
long long v4; // rdx
unsigned long long v5; // r14
long long v6; // rbx
long long v7; // rbp
long long *v8; // rax
_QWORD *v9; // rdx
long long **v10; // rsi
_QWORD *v11; // rsi
long long *v14; // [rsp+18h] [rbp-58h]
char *v15; // [rsp+28h] [rb... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV R15,RDI
PUSH R14
PUSH R13
MOV R13D,EDX
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP RDX,qwo... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0(vector param_1,int param_2)
{
long *plVar1;
int8 *puVar2;
int in_EDX;
lon... |
351 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<vector<int>> func0(vector<vector<int>> lst, int x){
vector<vector<int>> out={};
for (int i=0;i<lst.size();i++)
for (int j=lst[i].size()-1;j>=0;j-=1)
if (lst[i][j]==x) out.push_back({i,j});
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<vector<int>> a,vector<vector<int>> b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i].size()!=b[i].size()) return false;
for (int j=0;j<a[i].size();j++)
if (a[i][j]!=b[i][j]) return false;
}
... | O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
push %r15
pxor %xmm0,%xmm0
mov %rdi,%r15
push %r14
push %r13
mov %edx,%r13d
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rsi,0x18(%rsp)
mov %fs:0x28,%rax
m... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rdi
push r14
push r13
mov r13d, edx
push r12
push rbp
push rbx
sub rsp, 48h
mov [rsp+78h+var_60], rsi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
m... | long long func0(long long a1, long long *a2, int a3)
{
long long v4; // rcx
long long v5; // rdx
unsigned long long v6; // r14
long long v7; // rbx
long long v8; // rbp
long long *v9; // rax
_QWORD *v10; // rdx
long long **v11; // rsi
_QWORD *v12; // rsi
long long *v15; // [rsp+18h] [rbp-58h]
cha... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV R15,RDI
PUSH R14
PUSH R13
MOV R13D,EDX
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RCX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RSI]
MOV qword pt... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>> *
func0(vector param_1,int param_2)
{
long *plVar1;
int8 *puVar2;
int in_EDX;
lon... |
352 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> array){
if (array.size()==0) return {};
if ((array[0]+array[array.size()-1]) %2==1)
{
sort(array.begin(),array.end());
return array;
}
else
{
sort(array.begin(),array.end());
vector<int> out={};
for (int i=array.size()-1;i>=0;... | #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({}) , {}));
assert (issame(func0({5}) , {5}));
assert (issam... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 230a <_ZNKSt6vectorIiSaIiEE4sizeEv>
test %rax,... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_50]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
te... | long long func0(long long a1, long long a2)
{
int v2; // ebx
long long v3; // rax
long long v4; // rbx
long long v5; // rax
long long v6; // rbx
long long v7; // rax
long long v8; // rax
int i; // [rsp+1Ch] [rbp-34h]
__int128 v11; // [rsp+20h] [rbp-30h] BYREF
long long v12; // [rsp+30h] [rbp-20h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x0010237e
TEST RAX,RAX
SETZ AL
TEST AL,AL
JZ 0x001012a4
MOV RAX,qword ptr [R... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int iVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
long lVar4;
int *piVar5;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;... |
353 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> array){
if (array.size()==0) return {};
if ((array[0]+array[array.size()-1]) %2==1)
{
sort(array.begin(),array.end());
return array;
}
else
{
sort(array.begin(),array.end());
vector<int> out={};
for (int i=array.size()-1;i>=0;... | #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({}) , {}));
assert (issame(func0({5}) , {5}));
assert (issam... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %rdi,%r13
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov 0x8(%rsi),%rbp
mov (%rsi),%rbx
cmp %rbp,%rbx
je 1344 <_Z5func0St6vectorIiSaIiEE+0xc4>
mov ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 20h
mov r13, rdi
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov rbp, [rsi+8]
mov rbx, [rsi]
cmp rbx, rbp
jz loc_134D
mov r12, rsi
mov rdx, rbp
sub rdx, rbx... | long long func0(long long a1, long long a2)
{
long long v2; // rbp
_DWORD *v3; // rbx
long long v5; // rdx
unsigned long long v6; // rdx
int v7; // eax
unsigned long long v8; // rax
int v9; // ebx
long long v10; // rbp
unsigned long long v11; // rdx
int v12; // eax
unsigned long long v13; // rax
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV R13,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV RBP,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
CMP RBX,RBP
JZ 0x0010134d
MOV R12,RSI
MOV RDX,RBP
SUB RDX,RBX
MOV EAX,dword ptr [RBX]
ADD EAX,dword ptr [RBP +... | /* func0(std::vector<int, std::allocator<int> >) */
int (*) [16]
func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7,int8 param_8,int8 param_9)
{
int *piVar1;
int *piVar2;
uint uVar3;
_Iter_less_iter _Var4;
_Iter_less_iter extraout_EDX;
_Iter_less_iter extra... |
354 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> array){
if (array.size()==0) return {};
if ((array[0]+array[array.size()-1]) %2==1)
{
sort(array.begin(),array.end());
return array;
}
else
{
sort(array.begin(),array.end());
vector<int> out={};
for (int i=array.size()-1;i>=0;... | #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({}) , {}));
assert (issame(func0({5}) , {5}));
assert (issam... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov (%rsi),%rbp
mov 0x8(%rsi),%r14
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
cmp %r14,%rbp
je 1c98 <_Z5func0St6vectorIiSaIiEE+0x198>
mov ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 20h
mov r13, [rsi+8]
mov r14, [rsi]
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
cmp r14, r13
jz loc_1E80
mov eax, [r14]
add eax, [r13-4]
mov r1... | long long func0(long long a1, const __m128i *a2)
{
char *v3; // r13
char *v4; // r14
long long v6; // r12
unsigned long long v7; // rdx
char *j; // rdi
int v9; // ecx
int v10; // edx
char *v11; // rsi
char *v12; // rax
long long v13; // rdx
long long v14; // r12
int v15; // r12d
long long v16... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x20
MOV R13,qword ptr [RSI + 0x8]
MOV R14,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CMP R14,R13
JZ 0x00101e80
MOV EAX,dword ptr [R14]
ADD EAX,dword ptr [R13 + -0x4]
MOV R12,R13
MOV RBX,RSI
MOV E... | /* func0(std::vector<int, std::allocator<int> >) */
int (*) [16]
func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int8 param_8,int8 param_9)
{
int iVar1;
int iVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int *piVar6;
_Iter_less_iter _Var7;
int *piVar8;
... |
355 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> array){
if (array.size()==0) return {};
if ((array[0]+array[array.size()-1]) %2==1)
{
sort(array.begin(),array.end());
return array;
}
else
{
sort(array.begin(),array.end());
vector<int> out={};
for (int i=array.size()-1;i>=0;... | #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({}) , {}));
assert (issame(func0({5}) , {5}));
assert (issam... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x38,%rsp
mov (%rsi),%r13
mov 0x8(%rsi),%r15
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
cmp %r15,%r13
je 1d70 <_Z5func0St6vectorIiSaIiEE+... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
mov r15, rdi
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r14, [rsi+8]
mov rbx, [rsi]
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
cmp rbx, r14
jz loc_2030
mov eax, [rbx]
add eax, [r14-4... | long long func0(long long a1, const __m128i *a2)
{
char *v3; // r14
char *v4; // rbx
char *v6; // r12
unsigned long long v7; // rdx
long long jj; // rbp
char *v9; // r8
int v10; // ebp
char *v11; // rsi
int v12; // ecx
int v13; // edx
char *v14; // rax
char *v15; // rsi
int v16; // ebp
char... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R14,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
CMP RBX,R14
JZ 0x00102030
MOV EAX,dword ptr [RBX]
ADD EAX,dword ptr [R14 + -0x4]
MOV R13,RSI
MOV RCX,... | /* func0(std::vector<int, std::allocator<int> >) */
int (*) [16]
func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7,int8 param_8,int8 param_9,
int1 param_10 [16],int8 param_11,int8 param_12)
{
int iVar1;
int iVar2;
int *piVar3;
long lVar4;
int8 uVar5;
... |
356 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+4-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("hi") == "lm");
assert (func0("asdfghjkl") == "ewhjklnop");
assert (func0("gf") == "kj");
assert (func0("et") == "ix");
assert (func0("faewfawefaewg")=="jeiajeaijeiak");
assert (func0("hellomyfriend")=="lippsqcjvmirh");
assert (func... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x58(%rbp),%rax
mov %rax,%rdi
callq 2310 <_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_58]
mov rdi, rax
call __ZNSt7__cxx1112basic_stri... | long long func0(long long a1, long long a2)
{
int v2; // edx
int i; // [rsp+18h] [rbp-48h]
_BYTE v5[40]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v6; // [rsp+48h] [rbp-18h]
v6 = __readfsqword(0x28u);
std::string::basic_string(a1);
for ( i = 0; i < (unsigned long long)std::string::length(a2); ++i ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
CALL 0x00102320
MOV dword ptr [RBP + -0x48],0x0
JMP 0x00102541
LAB_001024c2:
MOV E... | /* func0(std::string) */
string * func0(string *param_1,ulong param_2)
{
char *pcVar1;
ulong uVar2;
long in_FS_OFFSET;
int local_50;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::string::string(param_1);
local_50 = 0;
while( true ) {
uVar2 = std::strin... |
357 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+4-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("hi") == "lm");
assert (func0("asdfghjkl") == "ewhjklnop");
assert (func0("gf") == "kj");
assert (func0("et") == "ix");
assert (func0("faewfawefaewg")=="jeiajeaijeiak");
assert (func0("hellomyfriend")=="lippsqcjvmirh");
assert (func... | 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 $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
mov %rax,0x8(%rsp)
mov %rax... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rsp+88h+var_80], rax
mov [rdi], rax
mov ... | void ** func0(void **a1, _QWORD *a2)
{
long long v4; // rbp
_BYTE *v5; // rax
void *v6; // rcx
unsigned long long v7; // r12
void *v8; // r15
char *v9; // rdx
unsigned long long v10; // rdi
_BYTE *v11; // rax
char *v12; // rsi
unsigned int v13; // ecx
unsigned int v14; // eax
char *v15; // rax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
CMP qword ptr [RSI +... | /* func0(std::string) */
ulong * func0(ulong *param_1,long *param_2)
{
ulong *puVar1;
ulong uVar2;
int iVar3;
uint uVar4;
int8 uVar5;
long lVar6;
uint uVar7;
ulong uVar8;
ulong uVar9;
long in_FS_OFFSET;
char local_69;
ulong *local_68;
int8 local_60;
ulong local_58 [5];
local_58[3] = *... |
358 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+4-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("hi") == "lm");
assert (func0("asdfghjkl") == "ewhjklnop");
assert (func0("gf") == "kj");
assert (func0("et") == "ix");
assert (func0("faewfawefaewg")=="jeiajeaijeiak");
assert (func0("hellomyfriend")=="lippsqcjvmirh");
assert (func... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x0,0x8(%rdi)
cmpq $0x0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10... | long long func0(long long a1, _QWORD *a2)
{
bool v3; // zf
long long v4; // rbp
size_t v5; // r12
double v6; // rcx
int v7; // eax
double *v8; // rdi
size_t v9; // rdx
size_t v11; // rdx
double *v12; // rdi
double *v13; // [rsp+8h] [rbp-A0h]
long long v14; // [rsp+10h] [rbp-98h]
char v15; // [r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],0x0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
ulong *puVar1;
long lVar2;
int iVar3;
ulong uVar4;
ulong *__dest;
ulong uVar5;
long in_FS_OFFSET;
ulong *local_a0;
char local_69;
ulong *local_68;
size_t local_60;
ulong local_58 [3];
long local_40;
local_40 = *(long *... |
359 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+4-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("hi") == "lm");
assert (func0("asdfghjkl") == "ewhjklnop");
assert (func0("gf") == "kj");
assert (func0("et") == "ix");
assert (func0("faewfawefaewg")=="jeiajeaijeiak");
assert (func0("hellomyfriend")=="lippsqcjvmirh");
assert (func... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x0,0x8(%rdi)
cmpq $0x0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10... | long long func0(long long a1, _QWORD *a2)
{
bool v3; // zf
unsigned long long v4; // rbp
size_t v5; // r12
double v6; // rcx
int v7; // eax
double *v8; // rdi
size_t v9; // rdx
size_t v11; // rdx
double *v12; // rdi
double *v13; // [rsp+8h] [rbp-A0h]
long long v14; // [rsp+10h] [rbp-98h]
char v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],0x0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
ulong *puVar1;
int iVar2;
long lVar3;
ulong *__dest;
ulong uVar4;
long in_FS_OFFSET;
ulong *local_a0;
char local_69;
ulong *local_68;
size_t local_60;
ulong local_58 [3];
long local_40;
local_40 = *(long *)(in_FS_OFFSET ... |
360 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> lst){
sort(lst.begin(),lst.end());
for (int i=1;i<lst.size();i++)
if (lst[i]!=lst[i-1]) return lst[i];
return -1;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 3, 4, 5}) == 2);
assert (func0({5, 1, 4, 3, 2}) == 2);
assert (func0({}) == -1);
assert (func0({1, 1}) == -1);
assert (func0({1,1,1,1,0}) == 1);
assert (func0({-35, 34, 12, -45}) == -35);
}
| 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 1948 <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 18fc <_ZNSt6vectorIiSaIiEE5beginEv>... | _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 _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5begin... | long long func0(long long a1)
{
long long v1; // rbx
long long v2; // rax
int v3; // ebx
int i; // [rsp+1Ch] [rbp-14h]
v1 = std::vector<int>::end(a1);
v2 = std::vector<int>::begin(a1);
std::sort<__gnu_cxx::__normal_iterator<int *,std::vector<int>>>(v2, v1);
for ( i = 1; i < (unsigned long long)std::ve... | 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 0x001019e4
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101998
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00101a34
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001012e0
LAB_0010128... | /* func0(std::vector<int, std::allocator<int> >) */
int4 func0(vector param_1)
{
int iVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int *piVar4;
int4 *puVar5;
ulong uVar6;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int local_1c;
this = (vector<int,std::allocator... |
361 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> lst){
sort(lst.begin(),lst.end());
for (int i=1;i<lst.size();i++)
if (lst[i]!=lst[i-1]) return lst[i];
return -1;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 3, 4, 5}) == 2);
assert (func0({5, 1, 4, 3, 2}) == 2);
assert (func0({}) == -1);
assert (func0({1, 1}) == -1);
assert (func0({1,1,1,1,0}) == 1);
assert (func0({-35, 34, 12, -45}) == -35);
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov 0x8(%rdi),%r12
mov (%rdi),%r13
cmp %r13,%r12
je 12cb <_Z5func0St6vectorIiSaIiEE+0xa2>
mov %r12,%rbx
sub %r13,%rbx
mov %rbx,%rax
sar $0x2,%rax
bsr %rax,... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r12, [rdi+8]
mov r13, [rdi]
cmp r13, r12
jz loc_12D1
mov rbx, r12
sub rbx, r13
mov rdx, rbx
sar rdx, 2
mov eax, 40h ; '@'
jz short loc_1265
bsr rax, rdx
xo... | long long func0(char **a1)
{
char *v1; // r12
char *v2; // r13
int v3; // eax
unsigned long long v4; // rax
char *v5; // rbx
int v6; // ecx
char *v7; // rax
int v8; // edx
char *v9; // rsi
char *v10; // rdx
long long v11; // rax
unsigned int v12; // ecx
v1 = a1[1];
v2 = *a1;
if ( *a1 != ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV R13,qword ptr [RDI]
CMP R13,R12
JZ 0x001012d1
MOV RBX,R12
SUB RBX,R13
MOV RDX,RBX
SAR RDX,0x2
MOV EAX,0x40
JZ 0x00101265
BSR RAX,RDX
XOR EAX,0x3f
LAB_00101265:
MOV EDX,0x3f
SUB EDX,EAX
MOVSXD RDX,EDX
ADD RDX,RDX... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
int iVar2;
int *piVar3;
long lVar4;
int *piVar5;
int *piVar6;
int *piVar7;
uint uVar8;
_Iter_less_iter in_ECX;
_Iter_less_iter extraout_EDX;
ulong uVar9;
int *piVar10;
__normal_iterator _Var11;
int4 ... |
362 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> lst){
sort(lst.begin(),lst.end());
for (int i=1;i<lst.size();i++)
if (lst[i]!=lst[i-1]) return lst[i];
return -1;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 3, 4, 5}) == 2);
assert (func0({5, 1, 4, 3, 2}) == 2);
assert (func0({}) == -1);
assert (func0({1, 1}) == -1);
assert (func0({1,1,1,1,0}) == 1);
assert (func0({-35, 34, 12, -45}) == -35);
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rdi),%r12
mov (%rdi),%rbp
mov %r12,%rbx
sub %rbp,%rbx
mov %rbx,%rax
sar $0x2,%rax
mov %rax,%rdx
cmp %rbp,%r12
je 15ea <_Z5func0St6vectorIiSaIiEE+0xda>
bsr %rax,... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, [rdi+8]
mov r13, [rdi]
cmp r13, rbp
jz loc_1938
mov rbx, rbp
mov r12, rdi
mov rsi, rbp
mov rdi, r13
sub rbx, r13
mov rdx, rbx
sar rdx, 2
bsr rdx, rdx
movsxd rdx, e... | long long func0(char **a1)
{
char *v1; // rbp
char *v2; // r13
unsigned long long v3; // rdx
char *v4; // rsi
unsigned int v5; // edx
long long v6; // rax
unsigned int v7; // ecx
char *v9; // rbx
int v10; // ecx
int v11; // edx
char *v12; // rax
char *v13; // rsi
char *v14; // rsi
v1 = a1[... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,qword ptr [RDI + 0x8]
MOV R13,qword ptr [RDI]
CMP R13,RBP
JZ 0x00101938
MOV RBX,RBP
MOV R12,RDI
MOV RSI,RBP
MOV RDI,R13
SUB RBX,R13
MOV RDX,RBX
SAR RDX,0x2
BSR RDX,RDX
MOVSXD RDX,EDX
ADD RDX,RDX
CALL 0x00101660
CMP RBX,0x40
JG 0x001018d0
MOV RSI,RBP... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int *piVar1;
int *piVar2;
long lVar3;
int *piVar4;
_Iter_less_iter in_ECX;
int iVar5;
_Iter_less_iter extraout_EDX;
int iVar6;
ulong uVar7;
int *piVar8;
__normal_iterator _Var9;
int4 in_register_0000003c;
int8 *p... |
363 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(vector<int> lst){
sort(lst.begin(),lst.end());
for (int i=1;i<lst.size();i++)
if (lst[i]!=lst[i-1]) return lst[i];
return -1;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 3, 4, 5}) == 2);
assert (func0({5, 1, 4, 3, 2}) == 2);
assert (func0({}) == -1);
assert (func0({1, 1}) == -1);
assert (func0({1,1,1,1,0}) == 1);
assert (func0({-35, 34, 12, -45}) == -35);
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rdi),%r13
mov (%rdi),%rbx
mov %r13,%r12
sub %rbx,%r12
mov %r12,%rax
sar $0x2,%rax
mov %rax,%rdx
cmp %rbx,%r13
je 15ea <_Z5func0St6vectorIiS... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r12, [rdi+8]
mov rbx, [rdi]
mov r8, r12
sub r8, rbx
mov rax, r8
sar rax, 2
mov r13, rax
cmp rbx, r12
jz loc_1884
mov rbp, rdi
lea r15, [rbx+4]
test... | long long func0(int **a1)
{
int *v1; // r12
int *v2; // rbx
long long v3; // r8
unsigned long long v4; // rax
unsigned long long k; // r13
int *v6; // r15
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; /... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RDI]
MOV R8,R12
SUB R8,RBX
MOV RAX,R8
SAR RAX,0x2
MOV R13,RAX
CMP RBX,R12
JZ 0x00101884
MOV RBP,RDI
LEA R15,[RBX + 0x4]
TEST RAX,RAX
JZ 0x001018bb
BSR RDX,RAX
MOV RSI,R12
MOV RDI,RBX
MOV qw... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7)
{
int *piVar1;
long lVar2;
ulong uVar3;
int *piVar4;
_Iter_less_iter _Var5;
int7 in_register_00000009;
int iVar6;
int iVar7;
size_t sVar8;
... |
364 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string S){
bool isstart=true;
bool isi=false;
int sum=0;
for (int i=0;i<S.length();i++)
{
if (S[i]==' ' and isi) {isi=false; sum+=1;}
if (S[i]=='I' and isstart) {isi=true; }
else isi=false;
if (S[i]!=' ') { isstart=false;}
if (S[i]=='.' or S[i]==... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello world") == 0);
assert (func0("Is the sky blue?") == 0);
assert (func0("I love It !") == 1);
assert (func0("bIt") == 0);
assert (func0("I feel good today. I will be productive. will kill It") == 2);
assert (func0("You and I are go... | 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)
movb $0x1,-0x1a(%rbp)
movb $0x0,-0x19(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_1A], 1
mov [rbp+var_19], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp loc_147C
loc_1375:
mov eax, [rbp+var_14]
movsxd rdx, eax
... | long long func0(long long a1)
{
bool v2; // al
char v5; // [rsp+16h] [rbp-1Ah]
bool v6; // [rsp+17h] [rbp-19h]
unsigned int v7; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v5 = 1;
v6 = 0;
v7 = 0;
for ( i = 0; i < (unsigned long long)std::string::length(a1); ++i )
{
if ( *(_BYTE *)std:... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV byte ptr [RBP + -0x1a],0x1
MOV byte ptr [RBP + -0x19],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010147c
LAB_00101375:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x... | /* func0(std::string) */
int func0(ulong param_1)
{
bool bVar1;
bool bVar2;
bool bVar3;
char *pcVar4;
ulong uVar5;
int local_20;
int local_1c;
bVar3 = true;
bVar1 = false;
local_20 = 0;
for (local_1c = 0; uVar5 = std::string::length(), (ulong)(long)local_1c < uVar5;
local_1c = local_1c ... |
365 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string S){
bool isstart=true;
bool isi=false;
int sum=0;
for (int i=0;i<S.length();i++)
{
if (S[i]==' ' and isi) {isi=false; sum+=1;}
if (S[i]=='I' and isstart) {isi=true; }
else isi=false;
if (S[i]!=' ') { isstart=false;}
if (S[i]=='.' or S[i]==... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello world") == 0);
assert (func0("Is the sky blue?") == 0);
assert (func0("I love It !") == 1);
assert (func0("bIt") == 0);
assert (func0("I feel good today. I will be productive. will kill It") == 2);
assert (func0("You and I are go... | 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 126e <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x85>
mov (%rax),%rdx
add %rdx,%rdi
mov $0x0,%r9d
mov $0x0,%esi
mov $0x1,%eax
m... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov r8, [rdi+8]
test r8, r8
jz short loc_127C
mov rdx, [rdi]
add r8, rdx
mov r10d, 0
mov ecx, 0
mov edi, 1
mov r9, 8000400200000000h
jmp short loc_1258
loc_1238:
add r10d, 1
mov ecx, 0
jmp short loc... | long long func0(unsigned __int8 **a1)
{
unsigned __int8 *v1; // r8
unsigned __int8 *v2; // rdx
unsigned __int8 *v3; // r8
unsigned int v4; // r10d
int v5; // ecx
int v6; // edi
unsigned long long v7; // r9
unsigned long long v8; // rax
int v9; // eax
v1 = a1[1];
if ( v1 )
{
v2 = *a1;
v... | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
TEST R8,R8
JZ 0x0010127c
MOV RDX,qword ptr [RDI]
ADD R8,RDX
MOV R10D,0x0
MOV ECX,0x0
MOV EDI,0x1
MOV R9,-0x7fffbffe00000000
JMP 0x00101258
LAB_00101238:
ADD R10D,0x1
MOV ECX,0x0
JMP 0x0010124f
LAB_00101243:
CMP AL,0x3f
JA 0x00101278
BT R9,RAX
SETC DIL
LAB_0010124f:
ADD RDX,0x... | /* func0(std::string) */
int func0(int8 *param_1)
{
byte bVar1;
bool bVar2;
bool bVar3;
byte *pbVar4;
bool bVar5;
bool bVar6;
byte *pbVar7;
int iVar8;
if (param_1[1] == 0) {
iVar8 = 0;
}
else {
pbVar4 = (byte *)*param_1;
pbVar7 = pbVar4 + param_1[1];
iVar8 = 0;
bVar2 = fal... |
366 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string S){
bool isstart=true;
bool isi=false;
int sum=0;
for (int i=0;i<S.length();i++)
{
if (S[i]==' ' and isi) {isi=false; sum+=1;}
if (S[i]=='I' and isstart) {isi=true; }
else isi=false;
if (S[i]!=' ') { isstart=false;}
if (S[i]=='.' or S[i]==... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello world") == 0);
assert (func0("Is the sky blue?") == 0);
assert (func0("I love It !") == 1);
assert (func0("bIt") == 0);
assert (func0("I feel good today. I will be productive. will kill It") == 2);
assert (func0("You and I are go... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
test %rsi,%rsi
je 1500 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x70>
mov (%rdi),%rax
xor %r8d,%r8d
xor %ecx,%ecx
mov $0x1,%edi
add %rax,%rsi
jmp 14d2 <_Z5fu... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rcx, [rdi+8]
test rcx, rcx
jz short loc_14D0
mov rax, [rdi]
xor r8d, r8d
xor esi, esi
mov edi, 1
mov r9, 8000400200000000h
add rcx, rax
jmp short loc_149D
loc_1480:
cmp dl, 49h ; 'I'
jz short loc_1... | long long func0(unsigned __int8 **a1)
{
unsigned __int8 *v1; // rcx
unsigned __int8 *v2; // rax
unsigned int v3; // r8d
unsigned __int8 v4; // si
unsigned __int8 v5; // di
unsigned long long v6; // r9
unsigned __int8 *v7; // rcx
unsigned long long v8; // rdx
v1 = a1[1];
if ( v1 )
{
v2 = *a1;... | func0:
ENDBR64
MOV RCX,qword ptr [RDI + 0x8]
TEST RCX,RCX
JZ 0x001014d0
MOV RAX,qword ptr [RDI]
XOR R8D,R8D
XOR ESI,ESI
MOV EDI,0x1
MOV R9,-0x7fffbffe00000000
ADD RCX,RAX
JMP 0x0010149d
LAB_00101480:
CMP DL,0x49
JZ 0x001014c0
CMP DL,0x3f
JA 0x001014d7
BT R9,RDX
SETC DIL
XOR ESI,ESI
LAB_00101494:
ADD RAX,0x1
CMP RCX,RAX... | /* func0(std::string) */
int func0(int8 *param_1)
{
byte bVar1;
bool bVar2;
bool bVar3;
byte *pbVar4;
byte *pbVar5;
int iVar6;
if (param_1[1] != 0) {
pbVar4 = (byte *)*param_1;
iVar6 = 0;
bVar2 = false;
bVar3 = true;
pbVar5 = pbVar4 + param_1[1];
do {
bVar1 = *pbVar4;
... |
367 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string S){
bool isstart=true;
bool isi=false;
int sum=0;
for (int i=0;i<S.length();i++)
{
if (S[i]==' ' and isi) {isi=false; sum+=1;}
if (S[i]=='I' and isstart) {isi=true; }
else isi=false;
if (S[i]!=' ') { isstart=false;}
if (S[i]=='.' or S[i]==... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello world") == 0);
assert (func0("Is the sky blue?") == 0);
assert (func0("I love It !") == 1);
assert (func0("bIt") == 0);
assert (func0("I feel good today. I will be productive. will kill It") == 2);
assert (func0("You and I are go... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
test %rsi,%rsi
je 15a0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x70>
mov (%rdi),%rax
xor %r8d,%r8d
xor %ecx,%ecx
mov $0x1,%edi
add %rax,%rsi
jmp 1572 <_Z5fu... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rcx, [rdi+8]
test rcx, rcx
jz short loc_1590
mov rax, [rdi]
xor r8d, r8d
xor esi, esi
mov edi, 1
mov r9, 8000400200000000h
add rcx, rax
jmp short loc_155D
loc_1540:
cmp dl, 49h ; 'I'
jz short loc_1... | long long func0(unsigned __int8 **a1)
{
unsigned __int8 *v1; // rcx
unsigned __int8 *v2; // rax
unsigned int v3; // r8d
unsigned __int8 v4; // si
unsigned __int8 v5; // di
unsigned long long v6; // r9
unsigned __int8 *v7; // rcx
unsigned long long v8; // rdx
v1 = a1[1];
if ( v1 )
{
v2 = *a1;... | func0:
ENDBR64
MOV RCX,qword ptr [RDI + 0x8]
TEST RCX,RCX
JZ 0x00101590
MOV RAX,qword ptr [RDI]
XOR R8D,R8D
XOR ESI,ESI
MOV EDI,0x1
MOV R9,-0x7fffbffe00000000
ADD RCX,RAX
JMP 0x0010155d
LAB_00101540:
CMP DL,0x49
JZ 0x00101580
CMP DL,0x3f
JA 0x00101597
BT R9,RDX
SETC DIL
XOR ESI,ESI
LAB_00101554:
ADD RAX,0x1
CMP RCX,RAX... | /* func0(std::string) */
int func0(int8 *param_1)
{
byte bVar1;
bool bVar2;
bool bVar3;
byte *pbVar4;
byte *pbVar5;
int iVar6;
if (param_1[1] != 0) {
pbVar4 = (byte *)*param_1;
iVar6 = 0;
bVar2 = false;
bVar3 = true;
pbVar5 = pbVar4 + param_1[1];
do {
bVar1 = *pbVar4;
... |
368 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(float a,float b,float c){
if (round(a)!=a) return false;
if (round(b)!=b) return false;
if (round(c)!=c) return false;
if (a+b==c or a+c==b or b+c==a) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2, 3, 1)==true);
assert (func0(2.5, 2, 3)==false);
assert (func0(1.5, 5, 3.5)==false);
assert (func0(2, 6, 2)==false);
assert (func0(4, 2, 2)==true);
assert (func0(2.2, 2.2, 2.2)==false);
assert (func0(-4, 6, 2)==true);
assert (... | O0 | cpp | func0(float, float, float):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
movss %xmm0,-0x4(%rbp)
movss %xmm1,-0x8(%rbp)
movss %xmm2,-0xc(%rbp)
mov -0x4(%rbp),%eax
movd %eax,%xmm0
callq 1615 <_ZSt5roundf>
ucomiss -0x4(%rbp),%xmm0
setp %al
mov $0x1,%edx
ucomiss -0x4(%rbp),%xmm0
cmovne %edx,%eax
tes... | _Z5func0fff:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
movss [rbp+var_4], xmm0
movss [rbp+var_8], xmm1
movss [rbp+var_C], xmm2
mov eax, [rbp+var_4]
movd xmm0, eax; float
call _ZSt5roundf; std::round(float)
movd eax, xmm0
movd xmm3, eax
ucomiss xmm3, [rbp+var_4]
setp dl
mov ecx, ... | _BOOL8 func0(float a1, float a2, float a3)
{
__m128i v3; // xmm0
__m128i v5; // xmm0
__m128i v6; // xmm0
v3 = _mm_cvtsi32_si128(LODWORD(a1));
std::round(*(float *)v3.m128i_i32);
if ( COERCE_FLOAT(_mm_cvtsi128_si32(v3)) != a1 )
return 0LL;
v5 = _mm_cvtsi32_si128(LODWORD(a2));
std::round(*(float *)v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS dword ptr [RBP + -0x8],XMM1
MOVSS dword ptr [RBP + -0xc],XMM2
MOV EAX,dword ptr [RBP + -0x4]
MOVD XMM0,EAX
CALL 0x001016dc
MOVD EAX,XMM0
MOVD XMM3,EAX
UCOMISS XMM3,dword ptr [RBP + -0x4]
SETP DL
MOV ECX,0x1
MOVD XMM4,EAX
UCOMISS XM... | /* func0(float, float, float) */
int8 func0(float param_1,float param_2,float param_3)
{
int8 uVar1;
float fVar2;
fVar2 = (float)std::round(param_1);
if (fVar2 == param_1) {
fVar2 = (float)std::round(param_2);
if (fVar2 == param_2) {
fVar2 = (float)std::round(param_3);
if (fVar2 == para... |
369 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(float a,float b,float c){
if (round(a)!=a) return false;
if (round(b)!=b) return false;
if (round(c)!=c) return false;
if (a+b==c or a+c==b or b+c==a) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2, 3, 1)==true);
assert (func0(2.5, 2, 3)==false);
assert (func0(1.5, 5, 3.5)==false);
assert (func0(2, 6, 2)==false);
assert (func0(4, 2, 2)==true);
assert (func0(2.2, 2.2, 2.2)==false);
assert (func0(-4, 6, 2)==true);
assert (... | O1 | cpp | func0(float, float, float):
endbr64
sub $0x18,%rsp
movss %xmm1,0x4(%rsp)
movss %xmm2,0xc(%rsp)
movss %xmm0,0x8(%rsp)
callq 1060 <roundf@plt>
movss 0x8(%rsp),%xmm3
ucomiss %xmm0,%xmm3
jp 1225 <_Z5func0fff+0xbc>
jne 1225 <_Z5func0fff+0xbc>
movss 0x4(%rsp),%xmm0
callq 1060 <roundf@plt>
movss 0x4(%rsp),%x... | _Z5func0fff:
endbr64
sub rsp, 18h
movss [rsp+18h+x], xmm1
movss [rsp+18h+var_C], xmm2
movss [rsp+18h+var_14], xmm0
call _roundf
movss xmm3, [rsp+18h+var_14]
ucomiss xmm3, xmm0
jp loc_1221
jnz loc_1221
movss xmm0, [rsp+18h+x]; x
call _roundf
movss xmm4, [rsp+18h+x]
ucomiss xmm4, xmm0
jp ... | bool func0(float a1, float a2, float a3)
{
bool result; // al
if ( a1 != roundf(a1) )
return 0;
if ( a2 != roundf(a2) )
return 0;
if ( roundf(a3) != a3 )
return 0;
result = 1;
if ( (float)(a1 + a2) != a3 )
{
result = 1;
if ( (float)(a1 + a3) != a2 )
return (float)(a2 + a3) == a... | func0:
ENDBR64
SUB RSP,0x18
MOVSS dword ptr [RSP + 0x8],XMM1
MOVSS dword ptr [RSP + 0xc],XMM2
MOVSS dword ptr [RSP + 0x4],XMM0
CALL 0x00101060
MOVSS XMM3,dword ptr [RSP + 0x4]
UCOMISS XMM3,XMM0
JP 0x00101221
JNZ 0x00101221
MOVSS XMM0,dword ptr [RSP + 0x8]
CALL 0x00101060
MOVSS XMM4,dword ptr [RSP + 0x8]
UCOMISS XMM4,XM... | /* func0(float, float, float) */
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
fVar2 = roundf(param_1);
if (param_1 == fVar2) {
fVar2 = roundf(param_2);
if (param_2 == fVar2) {
fVar2 = roundf(param_3);
if (fVar2 == param_3) {
bVar1 = true;
... |
370 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(float a,float b,float c){
if (round(a)!=a) return false;
if (round(b)!=b) return false;
if (round(c)!=c) return false;
if (a+b==c or a+c==b or b+c==a) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2, 3, 1)==true);
assert (func0(2.5, 2, 3)==false);
assert (func0(1.5, 5, 3.5)==false);
assert (func0(2, 6, 2)==false);
assert (func0(4, 2, 2)==true);
assert (func0(2.2, 2.2, 2.2)==false);
assert (func0(-4, 6, 2)==true);
assert (... | O2 | cpp | func0(float, float, float):
endbr64
sub $0x18,%rsp
movss %xmm1,0x4(%rsp)
movss %xmm2,0x8(%rsp)
movss %xmm0,0xc(%rsp)
callq 1060 <roundf@plt>
movss 0xc(%rsp),%xmm3
ucomiss %xmm0,%xmm3
jp 15c8 <_Z5func0fff+0xa8>
jne 15c8 <_Z5func0fff+0xa8>
movss 0x4(%rsp),%xmm0
callq 1060 <roundf@plt>
movss 0x4(%rsp),%x... | _Z5func0fff:
endbr64
sub rsp, 18h
movss [rsp+18h+x], xmm1
movss [rsp+18h+var_C], xmm2
movss [rsp+18h+var_10], xmm0
call _roundf
movss xmm3, [rsp+18h+var_10]
ucomiss xmm3, xmm0
jp loc_15E0
jnz loc_15E0
movss xmm0, [rsp+18h+x]; x
call _roundf
movss xmm4, [rsp+18h+x]
ucomiss xmm4, xmm0
jp ... | bool func0(float a1, float a2, float a3)
{
bool result; // al
if ( a1 != roundf(a1) || a2 != roundf(a2) || roundf(a3) != a3 )
return 0;
result = 1;
if ( a3 != (float)(a1 + a2) )
{
result = 1;
if ( a2 != (float)(a1 + a3) )
return (float)(a2 + a3) == a1;
}
return result;
} | func0:
ENDBR64
SUB RSP,0x18
MOVSS dword ptr [RSP + 0x4],XMM1
MOVSS dword ptr [RSP + 0xc],XMM2
MOVSS dword ptr [RSP + 0x8],XMM0
CALL 0x00101060
MOVSS XMM3,dword ptr [RSP + 0x8]
UCOMISS XMM3,XMM0
JP 0x001015e0
JNZ 0x001015e0
MOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x00101060
MOVSS XMM4,dword ptr [RSP + 0x4]
UCOMISS XMM4,XM... | /* func0(float, float, float) */
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
fVar2 = roundf(param_1);
if (((param_1 == fVar2) && (fVar2 = roundf(param_2), param_2 == fVar2)) &&
(fVar2 = roundf(param_3), fVar2 == param_3)) {
bVar1 = true;
if ((param_3 != par... |
371 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(float a,float b,float c){
if (round(a)!=a) return false;
if (round(b)!=b) return false;
if (round(c)!=c) return false;
if (a+b==c or a+c==b or b+c==a) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2, 3, 1)==true);
assert (func0(2.5, 2, 3)==false);
assert (func0(1.5, 5, 3.5)==false);
assert (func0(2, 6, 2)==false);
assert (func0(4, 2, 2)==true);
assert (func0(2.2, 2.2, 2.2)==false);
assert (func0(-4, 6, 2)==true);
assert (... | O3 | cpp | func0(float, float, float):
endbr64
sub $0x18,%rsp
movss %xmm1,0x4(%rsp)
movss %xmm2,0x8(%rsp)
movss %xmm0,0xc(%rsp)
callq 1060 <roundf@plt>
movss 0xc(%rsp),%xmm3
ucomiss %xmm0,%xmm3
jp 15c8 <_Z5func0fff+0xa8>
jne 15c8 <_Z5func0fff+0xa8>
movss 0x4(%rsp),%xmm0
callq 1060 <roundf@plt>
movss 0x4(%rsp),%x... | _Z5func0fff:
endbr64
sub rsp, 18h
movss [rsp+18h+x], xmm1
movss [rsp+18h+var_C], xmm2
movss [rsp+18h+var_10], xmm0
call _roundf
movss xmm3, [rsp+18h+var_10]
ucomiss xmm3, xmm0
jp loc_15E0
jnz loc_15E0
movss xmm0, [rsp+18h+x]; x
call _roundf
movss xmm4, [rsp+18h+x]
ucomiss xmm4, xmm0
jp ... | bool func0(float a1, float a2, float a3)
{
bool result; // al
if ( a1 != roundf(a1) || a2 != roundf(a2) || roundf(a3) != a3 )
return 0;
result = 1;
if ( a3 != (float)(a1 + a2) )
{
result = 1;
if ( a2 != (float)(a1 + a3) )
return (float)(a2 + a3) == a1;
}
return result;
} | func0:
ENDBR64
SUB RSP,0x18
MOVSS dword ptr [RSP + 0x4],XMM1
MOVSS dword ptr [RSP + 0xc],XMM2
MOVSS dword ptr [RSP + 0x8],XMM0
CALL 0x00101060
MOVSS XMM3,dword ptr [RSP + 0x8]
UCOMISS XMM3,XMM0
JP 0x001015e0
JNZ 0x001015e0
MOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x00101060
MOVSS XMM4,dword ptr [RSP + 0x4]
UCOMISS XMM4,XM... | /* func0(float, float, float) */
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
fVar2 = roundf(param_1);
if (((param_1 == fVar2) && (fVar2 = roundf(param_2), param_2 == fVar2)) &&
(fVar2 = roundf(param_3), fVar2 == param_3)) {
bVar1 = true;
if ((param_3 != par... |
372 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string message){
string vowels="aeiouAEIOU";
string out="";
for (int i=0;i<message.length();i++)
{
char w=message[i];
if (w>=97 and w<=122){w=w-32;}
else if (w>=65 and w<=90) w=w+32;
if (find(vowels.begin(),vowels.end(),w)!=vowels.end()) w=w+2;
out=ou... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("TEST") == "tgst");
assert (func0("Mudasir") == "mWDCSKR");
assert (func0("YES") == "ygs");
assert (func0("This is a message") == "tHKS KS C MGSSCGG");
assert (func0("I DoNt KnOw WhAt tO WrItE") == "k dQnT kNqW wHcT Tq wRkTg");
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
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
lea -0x68(%rbp),%rax
mov %rax,%rdi
callq 2380 <_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_78]
mov [rbp+var_70], rax
nop
nop
lea rdx, [rbp... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
unsigned long long v4; // rbx
char v6; // [rsp+1Bh] [rbp-85h] BYREF
int i; // [rsp+1Ch] [rbp-84h]
long long v8; // [rsp+20h] [rbp-80h] BYREF
_QWORD v9[3]; // [rsp+28h] [rbp-78h] BYREF
_BYTE v10[32]; // [rsp+40h] [rb... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x78]
MOV qword ptr [RBP + -0x70],RAX
NOP
NOP
LEA RDX,[RBP + -0x78]
LEA RAX,[RBP + -0x60]
LEA RCX,[0x104008]
M... | /* func0(std::string) */
string * func0(string *param_1,ulong param_2)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
char *pcVar4;
int4 extraout_var;
ulong uVar5;
ulong uVar6;
long in_FS_OFFSET;
char local_8d;
int local_8c;
int8 local_88;
int8 local_80;
int8 *local_78;
in... |
373 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string message){
string vowels="aeiouAEIOU";
string out="";
for (int i=0;i<message.length();i++)
{
char w=message[i];
if (w>=97 and w<=122){w=w-32;}
else if (w>=65 and w<=90) w=w+32;
if (find(vowels.begin(),vowels.end(),w)!=vowels.end()) w=w+2;
out=ou... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("TEST") == "tgst");
assert (func0("Mudasir") == "mWDCSKR");
assert (func0("YES") == "ygs");
assert (func0("This is a message") == "tHKS KS C MGSSCGG");
assert (func0("I DoNt KnOw WhAt tO WrItE") == "k dQnT kNqW wHcT Tq wRkTg");
}
| 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,%rbx
mov %rsi,%r14
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rdi
lea 0x30(%rsp... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov rbx, rdi
mov r13, rsi
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rdi, [rsp+0A8h+var_88]
lea rax, [rsp+0A8h+var_7... | void ** func0(void **a1, _QWORD *a2)
{
unsigned long long i; // rbp
char v5; // dl
char *v6; // rax
unsigned long long v7; // r12
_BYTE *v8; // r15
char *v9; // rcx
_BYTE *v10; // rax
void *v11; // rcx
char *v12; // rsi
long long v13; // rax
char *v14; // rdx
unsigned long long v15; // rdi
_BY... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RBX,RDI
MOV R13,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x20]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LEA RDX,[0x1020ec]
LEA RSI,[RDX + -0xa]
LAB_0010130b:
CALL 0x00101a9c
... | /* func0(std::string) */
ulong * func0(ulong *param_1,long *param_2)
{
long *plVar1;
ulong uVar2;
ulong *puVar3;
uint uVar4;
int8 uVar5;
long *plVar6;
long lVar7;
uint uVar8;
ulong uVar9;
ulong uVar10;
long in_FS_OFFSET;
char local_89;
long *local_88;
long local_80;
long local_78 [2];
... |
374 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string message){
string vowels="aeiouAEIOU";
string out="";
for (int i=0;i<message.length();i++)
{
char w=message[i];
if (w>=97 and w<=122){w=w-32;}
else if (w>=65 and w<=90) w=w+32;
if (find(vowels.begin(),vowels.end(),w)!=vowels.end()) w=w+2;
out=ou... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("TEST") == "tgst");
assert (func0("Mudasir") == "mWDCSKR");
assert (func0("YES") == "ygs");
assert (func0("This is a message") == "tHKS KS C MGSSCGG");
assert (func0("I DoNt KnOw WhAt tO WrItE") == "k dQnT kNqW wHcT Tq wRkTg");
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
lea 0x10(%r13),%r15
push %rbp
push %rbx
sub $0xa8,%rsp
mov %rsi,0x8(%rsp)
lea 0x60(%rsp),%rdi
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
lea rdx, unk_200E
push r14
mov r14, rsi
lea rsi, [rdx-0Ah]
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
lea rdi, [... | void ** func0(void **a1, _QWORD *a2)
{
unsigned long long i; // rbp
char v4; // dl
long long v5; // rcx
char *v6; // rax
char *v7; // rdi
size_t v8; // r12
double *v9; // rax
double *v10; // rdi
size_t v11; // rdx
double v12; // rcx
size_t v14; // rdx
double *v15; // rdi
double *v16; // [rsp+0... | func0:
ENDBR64
PUSH R15
LEA RDX,[0x10200e]
PUSH R14
MOV R14,RSI
LEA RSI,[RDX + -0xa]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x40]
LEA RAX,[RSP + 0x50]
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RAX... | /* func0(std::string) */
ulong * func0(ulong *param_1,long *param_2)
{
ulong uVar1;
ulong uVar2;
long *plVar3;
ulong *puVar4;
long lVar5;
ulong uVar6;
long in_FS_OFFSET;
char local_89;
long *local_88;
long local_80;
long local_78 [2];
ulong *local_68;
size_t local_60;
ulong local_58 [3];
... |
375 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string message){
string vowels="aeiouAEIOU";
string out="";
for (int i=0;i<message.length();i++)
{
char w=message[i];
if (w>=97 and w<=122){w=w-32;}
else if (w>=65 and w<=90) w=w+32;
if (find(vowels.begin(),vowels.end(),w)!=vowels.end()) w=w+2;
out=ou... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("TEST") == "tgst");
assert (func0("Mudasir") == "mWDCSKR");
assert (func0("YES") == "ygs");
assert (func0("This is a message") == "tHKS KS C MGSSCGG");
assert (func0("I DoNt KnOw WhAt tO WrItE") == "k dQnT kNqW wHcT Tq wRkTg");
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
lea 0x10(%r13),%r15
push %rbp
push %rbx
sub $0xa8,%rsp
mov %rsi,0x8(%rsp)
lea 0x60(%rsp),%rdi
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
lea rdi, [rsp+0C8h+var_78]
mov qword ptr [rbx+8], 0
mov rax, 494... | long long func0(long long a1, char **a2)
{
_BYTE *v3; // rdi
bool v4; // zf
unsigned long long v6; // rbp
size_t v7; // r12
long long v8; // rdx
char v9; // al
_BYTE *v10; // rsi
long long v11; // rcx
_BYTE *v12; // rdx
double *v13; // rdi
size_t v14; // rdx
double v15; // rcx
size_t v17; // ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x50]
MOV qword ptr [RBX + 0x8],0x0
MOV RAX,0x494541756f696561
MOV qword ptr [RSP + 0x50],RAX
MOV EAX,0x554f
MOV word ptr [RSP + 0x58],AX
LE... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
ulong *puVar1;
long *plVar2;
long lVar3;
long lVar4;
ulong *__dest;
long *plVar5;
ulong uVar6;
long in_FS_OFFSET;
ulong *local_c8;
char local_89;
long *local_88;
long local_80;
long local_78;
int2 local_70;
int local_6e... |
376 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int largest=0;
for (int i=0;i<lst.size();i++)
if (lst[i]>largest)
{
bool prime=true;
for (int j=2;j*j<=lst[i];j++)
if (lst[i]%j==0) prime=false;
if (prime) largest=lst[i];
}
int sum=0;
string s;
s... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3}) == 10);
assert (func0({1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1}) == 25);
assert (func0({1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3}) == 13);
assert (func0({0,724,32,71,99,32,6,0,5,91... | 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 %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x74(%rbp)
movl $0x0,-0x70(%rbp)
mov -0x70(%rbp),%eax
movslq %eax,%rbx
mov -0x88(%rbp),%rax
mov ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_88], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_74], 0
mov [rbp+var_70], 0
jmp loc_143A
loc_1382:
mov eax, [rbp+var_70]
movsxd rdx, eax
mov rax, [rbp+va... | long long func0(long long a1)
{
char v2; // [rsp+1Bh] [rbp-75h]
int v3; // [rsp+1Ch] [rbp-74h]
int i; // [rsp+20h] [rbp-70h]
int j; // [rsp+24h] [rbp-6Ch]
unsigned int v6; // [rsp+28h] [rbp-68h]
int k; // [rsp+2Ch] [rbp-64h]
_BYTE v8[32]; // [rsp+30h] [rbp-60h] BYREF
_BYTE v9[40]; // [rsp+50h] [rbp-40h... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x74],0x0
MOV dword ptr [RBP + -0x70],0x0
JMP 0x0010143a
LAB_00101382:
MOV EAX,dword ptr [RBP + -0x70]
MOVSXD RDX,EAX
MOV RAX,qword ptr ... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
bool bVar1;
int *piVar2;
ulong uVar3;
char *pcVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_7c;
int local_78;
int local_74;
int local_70;
int local_6c;
strin... |
377 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int largest=0;
for (int i=0;i<lst.size();i++)
if (lst[i]>largest)
{
bool prime=true;
for (int j=2;j*j<=lst[i];j++)
if (lst[i]%j==0) prime=false;
if (prime) largest=lst[i];
}
int sum=0;
string s;
s... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3}) == 10);
assert (func0({1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1}) == 25);
assert (func0({1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3}) == 13);
assert (func0({0,724,32,71,99,32,6,0,5,91... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov (%rdi),%rax
mov 0x8(%rdi),%r11
sub %rax,%r11
mov %r11,%rbx
shr $0x2,%rbx
je 12ae <_Z5func0St6vectorIiSaIiEE+0x85>
mov %rax,%r9
add %rax,%r11
mov ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r12
push rbp
push rbx
sub rsp, 120h
mov rax, fs:28h
mov [rsp+138h+var_20], rax
xor eax, eax
mov rax, [rdi+8]
mov r10, [rdi]
mov r11, rax
sub r11, r10
sar r11, 2
cmp rax, r10
jz loc_19FB
mov r8d, 0
mov ebx, 0
mov r9... | long long func0(long long *a1, long long a2, long long a3, long long a4, unsigned long long a5, long long a6)
{
long long v6; // r10
unsigned long long v7; // r11
unsigned int v8; // ebx
int v9; // esi
char v10; // di
unsigned __int8 v11; // r12
unsigned int v12; // eax
unsigned int v13; // ebp
unsig... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x120
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x118],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RDI + 0x8]
MOV R10,qword ptr [RDI]
MOV R11,RAX
SUB R11,R10
SAR R11,0x2
CMP RAX,R10
JZ 0x001019fb
MOV R8D,0x0
MOV EBX,0x0
MOV R9D,0x0
JMP 0x00101283
LAB_00101278:
MOV EBX,ESI... | /* WARNING: Removing unreachable block (ram,0x00101573) */
/* WARNING: Removing unreachable block (ram,0x001019a7) */
/* WARNING: Removing unreachable block (ram,0x00101586) */
/* WARNING: Removing unreachable block (ram,0x001015ac) */
/* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
... |
378 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int largest=0;
for (int i=0;i<lst.size();i++)
if (lst[i]>largest)
{
bool prime=true;
for (int j=2;j*j<=lst[i];j++)
if (lst[i]%j==0) prime=false;
if (prime) largest=lst[i];
}
int sum=0;
string s;
s... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3}) == 10);
assert (func0({1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1}) == 25);
assert (func0({1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3}) == 13);
assert (func0({0,724,32,71,99,32,6,0,5,91... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
push %rbx
sub $0x58,%rsp
mov (%rdi),%r9
mov 0x8(%rdi),%r11
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
sub %r9,%r11
mov %r11,%rax
shr $0x2,%rax
je 1a80 <_Z5func0St6vectorIiSaIiEE+0x1f0>
add %r9,%r11
xor %r8... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 128h
mov r10, [rdi]
mov rax, fs:28h
mov [rsp+158h+var_40], rax
mov rax, [rdi+8]
mov r11, rax
sub r11, r10
sar r11, 2
cmp r10, rax
jz loc_1A32
xor r8d, r8d
xor ... | long long func0(long long *a1)
{
long long v1; // r10
unsigned long long v2; // r11
unsigned long long v3; // r8
unsigned int v4; // ebx
int v5; // esi
int v6; // ecx
char v7; // di
long long v8; // r15
int v9; // edx
unsigned int v10; // ebp
int v11; // eax
unsigned int v12; // r12d
__int8 *... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x128
MOV R10,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x118],RAX
MOV RAX,qword ptr [RDI + 0x8]
MOV R11,RAX
SUB R11,R10
SAR R11,0x2
CMP R10,RAX
JZ 0x00101a32
XOR R8D,R8D
XOR EBX,EBX
XOR R9D,R9D
JMP 0x001016d9
LAB_001016... | /* WARNING: Removing unreachable block (ram,0x00101946) */
/* WARNING: Removing unreachable block (ram,0x0010195d) */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
long lVar1;
uint uVar2;
long ... |
379 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
int largest=0;
for (int i=0;i<lst.size();i++)
if (lst[i]>largest)
{
bool prime=true;
for (int j=2;j*j<=lst[i];j++)
if (lst[i]%j==0) prime=false;
if (prime) largest=lst[i];
}
int sum=0;
string s;
s... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3}) == 10);
assert (func0({1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1}) == 25);
assert (func0({1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3}) == 13);
assert (func0({0,724,32,71,99,32,6,0,5,91... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
push %rbx
sub $0x58,%rsp
mov (%rdi),%r9
mov 0x8(%rdi),%r11
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
sub %r9,%r11
mov %r11,%rax
shr $0x2,%rax
je 1d20 <_Z5func0St6vectorIiSaIiEE+0x400>
add %r9,%r11
xor %r8... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 128h
mov r10, [rdi]
mov rax, fs:28h
mov [rsp+158h+var_40], rax
mov rax, [rdi+8]
mov r11, rax
sub r11, r10
sar r11, 2
cmp r10, rax
jz loc_1BFE
xor r8d, r8d
xor ... | long long func0(long long *a1)
{
long long v1; // r10
unsigned long long v2; // r11
unsigned long long v3; // r8
unsigned int v4; // ebx
int v5; // esi
int v6; // ecx
char v7; // di
long long v8; // rdi
long long v9; // rsi
long long v10; // r15
int v11; // eax
long long v12; // rdx
long long... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x128
MOV R10,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x118],RAX
MOV RAX,qword ptr [RDI + 0x8]
MOV R11,RAX
SUB R11,R10
SAR R11,0x2
CMP R10,RAX
JZ 0x00101bfe
XOR R8D,R8D
XOR EBX,EBX
XOR R9D,R9D
JMP 0x001016d9
LAB_001016... | /* WARNING: Removing unreachable block (ram,0x00101946) */
/* WARNING: Removing unreachable block (ram,0x0010195d) */
/* WARNING: Type propagation algorithm not settling */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >) */
int func0... |
380 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(map<string,string> dict){
map<string,string>::iterator it;
int islower=0,isupper=0;
if (dict.size()==0) return false;
for (it=dict.begin();it!=dict.end();it++)
{
string key=it->first;
for (int i=0;i<key.length();i++)
{
if (key[i]<65 or (key[i]>90 a... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({{"p","pineapple"}, {"b","banana"}}) == true);
assert (func0({{"p","pineapple"}, {"A","banana"}, {"B","banana"}}) == false);
assert (func0({{"p","pineapple"}, {"5","banana"}, {"a","apple"}}) == false);
assert (func0({{"Name","John"}, {"Age","36... | O0 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_strin... | _Z5func0St3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 60h
mov [rbp+var_68], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_50]
mov rdi, rax
call ... | long long func0(long long a1)
{
unsigned int v1; // r12d
long long v2; // rax
int v4; // ebx
int v8; // [rsp+14h] [rbp-5Ch]
int v9; // [rsp+18h] [rbp-58h]
int j; // [rsp+1Ch] [rbp-54h]
long long i; // [rsp+20h] [rbp-50h] BYREF
long long v12; // [rsp+28h] [rbp-48h] BYREF
_BYTE v13[40]; // [rsp+30h] [r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x60
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00104256
MOV dword ptr [RBP + -0x5c],0x0
MOV dword ptr [RBP + -0x58],0x0
MOV RAX,qword ptr [RBP + -0x68]
MOV... | /* func0(std::map<std::string, std::string, std::less<std::string >,
std::allocator<std::pair<std::string const, std::string > > >) */
int4 func0(map param_1)
{
bool bVar1;
char cVar2;
long lVar3;
string *psVar4;
char *pcVar5;
ulong uVar6;
int4 in_register_0000003c;
map<std::string,std::string,std:... |
381 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(map<string,string> dict){
map<string,string>::iterator it;
int islower=0,isupper=0;
if (dict.size()==0) return false;
for (it=dict.begin();it!=dict.end();it++)
{
string key=it->first;
for (int i=0;i<key.length();i++)
{
if (key[i]<65 or (key[i]>90 a... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({{"p","pineapple"}, {"b","banana"}}) == true);
assert (func0({{"p","pineapple"}, {"A","banana"}, {"B","banana"}}) == false);
assert (func0({{"p","pineapple"}, {"5","banana"}, {"a","apple"}}) == false);
assert (func0({{"Name","John"}, {"Age","36... | O1 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_strin... | _Z5func0St3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
cmp qword ptr [rdi+28h], 0
jz loc_1437
mov... | long long func0(long long a1)
{
long long result; // rax
long long v2; // r14
long long v3; // r13
int v4; // ebp
int v5; // ebx
void *v6; // rdi
char *v7; // rdx
char v8; // al
void *v9; // [rsp+10h] [rbp-68h] BYREF
long long v10; // [rsp+18h] [rbp-60h]
_QWORD v11[11]; // [rsp+20h] [rbp-58h] BYR... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
CMP qword ptr [RDI + 0x28],0x0
JZ 0x00101437
MOV R14,qword ptr [RDI + 0x18]
LEA R13,[RDI + 0x8]
CMP R14,R13
JZ 0x00101456
MOV EBP,0x0
MOV EBX,0x0
LEA RAX,[RSP + 0x10]
... | /* func0(std::map<std::string, std::string, std::less<std::string >,
std::allocator<std::pair<std::string const, std::string > > >) */
int8 func0(map param_1)
{
char cVar1;
_Rb_tree_node_base *p_Var2;
int8 uVar3;
long *plVar4;
int iVar5;
int iVar6;
int4 in_register_0000003c;
long lVar7;
long in_F... |
382 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(map<string,string> dict){
map<string,string>::iterator it;
int islower=0,isupper=0;
if (dict.size()==0) return false;
for (it=dict.begin();it!=dict.end();it++)
{
string key=it->first;
for (int i=0;i<key.length();i++)
{
if (key[i]<65 or (key[i]>90 a... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({{"p","pineapple"}, {"b","banana"}}) == true);
assert (func0({{"p","pineapple"}, {"A","banana"}, {"B","banana"}}) == false);
assert (func0({{"p","pineapple"}, {"5","banana"}, {"a","apple"}}) == false);
assert (func0({{"Name","John"}, {"Age","36... | O2 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_strin... | _Z5func0St3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
cmp qword ptr [rdi+28h], 0
jz loc_2113
mov... | long long func0(long long a1)
{
long long v1; // r15
int v2; // r13d
int v3; // r14d
long long v4; // rsi
long long v5; // rdx
char *v6; // rdx
char v7; // al
void *v9; // [rsp+0h] [rbp-68h] BYREF
long long v10; // [rsp+8h] [rbp-60h]
_QWORD v11[11]; // [rsp+10h] [rbp-58h] BYREF
v11[3] = __readfs... | func0:
ENDBR64
PUSH R15
PUSH R14
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 + 0x28],0x0
JZ 0x00102113
MOV R15,qword ptr [RDI + 0x18]
LEA RBX,[RDI + 0x8]
CMP R15,RBX
JZ 0x0010215f
XOR R13D,R13D
XOR R14D,R14D
LEA RBP,[RSP + 0x... | /* func0(std::map<std::string, std::string, std::less<std::string >,
std::allocator<std::pair<std::string const, std::string > > >) */
int8 func0(map param_1)
{
char cVar1;
bool bVar2;
bool bVar3;
_Rb_tree_node_base *p_Var4;
int8 uVar5;
long *plVar6;
int4 in_register_0000003c;
long lVar7;
long in... |
383 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(map<string,string> dict){
map<string,string>::iterator it;
int islower=0,isupper=0;
if (dict.size()==0) return false;
for (it=dict.begin();it!=dict.end();it++)
{
string key=it->first;
for (int i=0;i<key.length();i++)
{
if (key[i]<65 or (key[i]>90 a... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({{"p","pineapple"}, {"b","banana"}}) == true);
assert (func0({{"p","pineapple"}, {"A","banana"}, {"B","banana"}}) == false);
assert (func0({{"p","pineapple"}, {"5","banana"}, {"a","apple"}}) == false);
assert (func0({{"Name","John"}, {"Age","36... | O3 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_strin... | _Z5func0St3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
cmp qword ptr [rdi+28h], 0
jz loc_2403
mov... | long long func0(long long a1)
{
long long v1; // r14
long long v2; // rbx
int v3; // r12d
int v4; // r13d
size_t v5; // rcx
_BYTE *v6; // r8
_QWORD *v7; // rax
char *v8; // rdx
char v9; // al
_QWORD *v11; // rdi
void *v12; // rax
size_t v13; // [rsp+0h] [rbp-88h]
_BYTE *v14; // [rsp+8h] [rbp-... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
CMP qword ptr [RDI + 0x28],0x0
JZ 0x00102403
MOV R14,qword ptr [RDI + 0x18]
LEA RBX,[RDI + 0x8]
CMP R14,RBX
JZ 0x001024b7
XOR R12D,R12D
LEA RBP,[RSP + 0x20]
LEA R15,[R... | /* func0(std::map<std::string, std::string, std::less<std::string >,
std::allocator<std::pair<std::string const, std::string > > >) */
int8 func0(map param_1)
{
char cVar1;
ulong __n;
int *__src;
bool bVar2;
bool bVar3;
_Rb_tree_node_base *p_Var4;
int8 uVar5;
ulong *puVar6;
int4 in_register_00000... |
384 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
vector<int> out={};
int i,j;
for (i=2;i<n;i++)
if (out.size()==0) {out.push_back(i);}
else
{
bool isp=true;
for (j=0;out[j]*out[j]<=i;j++)
if (i%out[j]==0) isp=false;
if (isp) out.push_back(i);
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5) , {2,3}));
assert (issame(func0(6) , {2,3,5}));
assert (i... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
movq $0x0,0x10(%rax)
mov -0x38(%rbp),%rax
mov %rax,%rdi
ca... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
pxor xmm0, xmm0
movups xmmword ptr [rax], xmm0
movq qword ptr [rax+10h], xmm0
mov rax, [rbp... | long long func0(long long a1, int a2)
{
int v2; // ebx
int v3; // ebx
int v4; // ebx
char v6; // [rsp+1Fh] [rbp-21h]
int i; // [rsp+20h] [rbp-20h] BYREF
int j; // [rsp+24h] [rbp-1Ch]
unsigned long long v9; // [rsp+28h] [rbp-18h]
v9 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword ptr [RAX + 0x10],XMM0
MOV RAX,qword pt... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int iVar1;
bool bVar2;
int iVar3;
long lVar4;
int *piVar5;
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_28;
int local_24;
long local_20;
this = (vector<int... |
385 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
vector<int> out={};
int i,j;
for (i=2;i<n;i++)
if (out.size()==0) {out.push_back(i);}
else
{
bool isp=true;
for (j=0;out[j]*out[j]<=i;j++)
if (i%out[j]==0) isp=false;
if (isp) out.push_back(i);
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5) , {2,3}));
assert (issame(func0(6) , {2,3,5}));
assert (i... | O1 | cpp | func0(int):
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
movl $0x2,0x4(%rsp)
cmp $0x2,%esi
jle 138b <_Z5func0i+0x10b>
mov %esi,%ebp
mov $0x2,%esi
le... | _Z5func0i:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r12, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_34], 2
cmp esi, 2
jle loc_1398
mov r1... | long long func0(long long a1, int a2)
{
int i; // ebx
int *v5; // r8
int *v6; // rsi
int v7; // ecx
int *v8; // rsi
char v9; // di
int v11; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v12; // [rsp+8h] [rbp-30h]
v12 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v11... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x4],0x2
CMP ESI,0x2
JLE 0x00101398
MOV R13D,ESI
MOV EBX,0x2
MOV EBP,0x0
JMP ... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int *piVar1;
bool bVar2;
int iVar3;
int iVar4;
int in_ESI;
int *piVar5;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_34;
long local_30;
this = (vector<int,std::allocator... |
386 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
vector<int> out={};
int i,j;
for (i=2;i<n;i++)
if (out.size()==0) {out.push_back(i);}
else
{
bool isp=true;
for (j=0;out[j]*out[j]<=i;j++)
if (i%out[j]==0) isp=false;
if (isp) out.push_back(i);
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5) , {2,3}));
assert (issame(func0(6) , {2,3,5}));
assert (i... | O2 | cpp | func0(int):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
movl $0x2,0x4(%rsp)
cmp $0x2,%esi
jle 1d8e <_Z5func0i+0xde>
xor %r10d,%r10d
xor %edi,%edi
l... | _Z5func0i:
endbr64
push r13
pxor xmm0, xmm0
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_34], 2
movups xmmword ptr [rdi], xmm0
cmp esi, 2
jle loc_1A57
mov r1... | long long func0(long long a1, int a2)
{
_DWORD *v4; // r8
int v5; // ebx
int v6; // ecx
char v7; // di
int *v8; // rsi
int v9; // edx
int v10; // eax
int *v11; // rsi
int v13; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v14; // [rsp+4h] [rbp-30h]
v14 = __readfsqword(0x28u);
*(_QWORD *)(a1 +... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x4],0x2
MOVUPS xmmword ptr [RDI],XMM0
CMP ESI,0x2
JLE 0x00101a57
MOV R13D,ESI
XOR R8D,R8D
XOR ESI,ESI
MOV ... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
int in_ESI;
int *piVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int *piVar5;
long in_FS_OFFSET;
int local_34;
long local_30;
this = (vector<int,std::allocator... |
387 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int n){
vector<int> out={};
int i,j;
for (i=2;i<n;i++)
if (out.size()==0) {out.push_back(i);}
else
{
bool isp=true;
for (j=0;out[j]*out[j]<=i;j++)
if (i%out[j]==0) isp=false;
if (isp) out.push_back(i);
}
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5) , {2,3}));
assert (issame(func0(6) , {2,3,5}));
assert (i... | O3 | cpp | func0(int):
endbr64
push %r12
pxor %xmm0,%xmm0
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movl $0x2,0x4(%rsp)
movups %xmm0,(%rdi)
cmp $0x2,%esi
jle 1c5a <_Z5func0i+0xca>
xor %r10d,%r10d
xor %edi,%edi
lea... | _Z5func0i:
endbr64
push r13
pxor xmm0, xmm0
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_34], 2
movups xmmword ptr [rdi], xmm0
cmp esi, 2
jle loc_1C27
mov r1... | long long func0(long long a1, int a2)
{
_DWORD *v4; // r8
int v5; // ebx
int v6; // ecx
char v7; // di
int *v8; // rsi
int v9; // edx
int v10; // eax
int *v11; // rsi
int v13; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v14; // [rsp+4h] [rbp-30h]
v14 = __readfsqword(0x28u);
*(_QWORD *)(a1 +... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x4],0x2
MOVUPS xmmword ptr [RDI],XMM0
CMP ESI,0x2
JLE 0x00101c27
MOV R13D,ESI
XOR R8D,R8D
XOR ESI,ESI
MOV ... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
int in_ESI;
int *piVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int *piVar5;
long in_FS_OFFSET;
int local_34;
long local_30;
this = (vector<int,std::allocator... |
388 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int a,int b){
return (abs(a)%10)*(abs(b)%10);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(148, 412) == 16 );
assert (func0(19, 28) == 72 );
assert (func0(2020, 1851) == 0);
assert (func0(14,-15) == 20 );
assert (func0(76, 67) == 42 );
assert (func0(17, 27) == 49 );
assert (func0(0, 1) == 0... | O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
sar $0x1f,%eax
mov %eax,%edx
xor -0x4(%rbp),%edx
sub %eax,%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar ... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
mov edx, eax
neg edx
cmovs edx, eax
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
mov ecx, eax
sar ecx, 2
mov eax, edx
sar eax, 1Fh
sub ecx, eax
mov ea... | long long func0(int a1, int a2)
{
int v2; // edx
int v3; // eax
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = a2;
if ( a2 <= 0 )
v3 = -a2;
return (unsigned int)(v3 % 10 * (v2 % 10));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV ECX,EAX
SAR ECX,0x2
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = -param_1;
if (0 < param_1) {
iVar1 = param_1;
}
if (param_2 < 1) {
param_2 = -param_2;
}
return (iVar1 % 10) * (param_2 % 10);
} |
389 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int a,int b){
return (abs(a)%10)*(abs(b)%10);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(148, 412) == 16 );
assert (func0(19, 28) == 72 );
assert (func0(2020, 1851) == 0);
assert (func0(14,-15) == 20 );
assert (func0(76, 67) == 42 );
assert (func0(17, 27) == 49 );
assert (func0(0, 1) == 0... | O1 | cpp | func0(int, int):
endbr64
mov %edi,%eax
cltd
xor %edx,%eax
sub %edx,%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
mov %eax,%ecx
sar $0x1f,%ecx
sub %ecx,%edx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%eax
mov %esi,%edx
sar $0x1f,%edx
xor %edx,%esi
sub %edx... | _Z5func0ii:
endbr64
mov eax, edi
neg eax
cmovs eax, edi
movsxd rdx, eax
imul rdx, 66666667h
sar rdx, 22h
mov ecx, eax
sar ecx, 1Fh
sub edx, ecx
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
mov ecx, esi
neg ecx
cmovs ecx, esi
movsxd rdx, ecx
imul rdx, 66666667h
s... | long long func0(int a1, int a2)
{
int v2; // eax
int v3; // eax
int v4; // ecx
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = v2 % 10;
v4 = -a2;
if ( a2 > 0 )
v4 = a2;
return (unsigned int)(v4 % 10 * v3);
} | func0:
ENDBR64
MOV EAX,EDI
NEG EAX
CMOVS EAX,EDI
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
MOV ECX,EAX
SAR ECX,0x1f
SUB EDX,ECX
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
MOV ECX,ESI
NEG ECX
CMOVS ECX,ESI
MOVSXD RDX,ECX
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
MOV ESI,ECX
SAR ESI,0x1f
SUB EDX,ESI
LEA EDX,[RD... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
iVar1 = -param_1;
if (0 < param_1) {
iVar1 = param_1;
}
iVar2 = -param_2;
if (0 < param_2) {
iVar2 = param_2;
}
return (iVar1 % 10) * (iVar2 % 10);
} |
390 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int a,int b){
return (abs(a)%10)*(abs(b)%10);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(148, 412) == 16 );
assert (func0(19, 28) == 72 );
assert (func0(2020, 1851) == 0);
assert (func0(14,-15) == 20 );
assert (func0(76, 67) == 42 );
assert (func0(17, 27) == 49 );
assert (func0(0, 1) == 0... | O2 | cpp | func0(int, int):
endbr64
mov %edi,%edx
mov %esi,%eax
mov $0xcccccccd,%esi
sar $0x1f,%edx
xor %edx,%edi
sub %edx,%edi
cltd
xor %edx,%eax
mov %edi,%ecx
sub %edx,%eax
imul %rsi,%rcx
mov %eax,%edx
imul %rsi,%rdx
shr $0x23,%rcx
lea (%rcx,%rcx,4),%ecx
shr $0x23,%rdx
add %ecx,%ecx... | _Z5func0ii:
endbr64
mov eax, edi
neg eax
cmovs eax, edi
mov edi, 0CCCCCCCDh
mov edx, eax
imul rdx, rdi
shr rdx, 23h
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
mov edx, esi
neg edx
cmovs edx, esi
mov ecx, edx
imul rcx, rdi
shr rcx, 23h
lea ecx, [rcx+rcx*4... | long long func0(int a1, int a2)
{
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // edx
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = v2 % 0xA;
v4 = -a2;
if ( a2 > 0 )
v4 = a2;
return v4 % 0xA * v3;
} | func0:
ENDBR64
MOV EAX,EDI
NEG EAX
CMOVS EAX,EDI
MOV EDI,0xcccccccd
MOV EDX,EAX
IMUL RDX,RDI
SHR RDX,0x23
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
MOV EDX,ESI
NEG EDX
CMOVS EDX,ESI
MOV ECX,EDX
IMUL RCX,RDI
SHR RCX,0x23
LEA ECX,[RCX + RCX*0x4]
ADD ECX,ECX
SUB EDX,ECX
IMUL EAX,EDX
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
uint uVar1;
ulong uVar2;
uVar1 = -param_1;
if (0 < param_1) {
uVar1 = param_1;
}
uVar2 = (ulong)(uint)-param_2;
if (0 < param_2) {
uVar2 = (ulong)(uint)param_2;
}
return (uVar1 % 10) * ((int)uVar2 + (int)(uVar2 / 10) * -10);
} |
391 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int a,int b){
return (abs(a)%10)*(abs(b)%10);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(148, 412) == 16 );
assert (func0(19, 28) == 72 );
assert (func0(2020, 1851) == 0);
assert (func0(14,-15) == 20 );
assert (func0(76, 67) == 42 );
assert (func0(17, 27) == 49 );
assert (func0(0, 1) == 0... | O3 | cpp | func0(int, int):
endbr64
mov %edi,%edx
mov %esi,%eax
mov $0xcccccccd,%esi
sar $0x1f,%edx
xor %edx,%edi
sub %edx,%edi
cltd
xor %edx,%eax
mov %edi,%ecx
sub %edx,%eax
imul %rsi,%rcx
mov %eax,%edx
imul %rsi,%rdx
shr $0x23,%rcx
lea (%rcx,%rcx,4),%ecx
shr $0x23,%rdx
add %ecx,%ecx... | _Z5func0ii:
endbr64
mov eax, edi
neg eax
cmovs eax, edi
mov edi, 0CCCCCCCDh
mov edx, eax
imul rdx, rdi
shr rdx, 23h
lea edx, [rdx+rdx*4]
add edx, edx
sub eax, edx
mov edx, esi
neg edx
cmovs edx, esi
mov ecx, edx
imul rcx, rdi
shr rcx, 23h
lea ecx, [rcx+rcx*4... | long long func0(int a1, int a2)
{
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // edx
v2 = -a1;
if ( a1 > 0 )
v2 = a1;
v3 = v2 % 0xA;
v4 = -a2;
if ( a2 > 0 )
v4 = a2;
return v4 % 0xA * v3;
} | func0:
ENDBR64
MOV EAX,EDI
NEG EAX
CMOVS EAX,EDI
MOV EDI,0xcccccccd
MOV EDX,EAX
IMUL RDX,RDI
SHR RDX,0x23
LEA EDX,[RDX + RDX*0x4]
ADD EDX,EDX
SUB EAX,EDX
MOV EDX,ESI
NEG EDX
CMOVS EDX,ESI
MOV ECX,EDX
IMUL RCX,RDI
SHR RCX,0x23
LEA ECX,[RCX + RCX*0x4]
ADD ECX,ECX
SUB EDX,ECX
IMUL EAX,EDX
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
uint uVar1;
ulong uVar2;
uVar1 = -param_1;
if (0 < param_1) {
uVar1 = param_1;
}
uVar2 = (ulong)(uint)-param_2;
if (0 < param_2) {
uVar2 = (ulong)(uint)param_2;
}
return (uVar1 % 10) * ((int)uVar2 + (int)(uVar2 / 10) * -10);
} |
392 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string s){
string uvowel="AEIOU";
int count=0;
for (int i=0;i*2<s.length();i++)
if (find(uvowel.begin(),uvowel.end(),s[i*2])!=uvowel.end())
count+=1;
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("aBCdEf") == 1);
assert (func0("abcdefg") == 0);
assert (func0("dBBE") == 0);
assert (func0("B") == 0);
assert (func0("U") == 1);
assert (func0("") == 0);
assert (func0("EEEE") == 2);
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x60,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x48(%rbp),%rax
mov %rax,%rdi
callq 2300 <_ZNSaIcEC1Ev@... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 60h
mov [rbp+var_68], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_50]
mov [rbp+var_48], rax
nop
nop
lea rdx, [rbp+var_50]
lea ... | long long func0(long long a1)
{
long long v1; // r12
long long v2; // rbx
long long v3; // rax
unsigned int v5; // [rsp+10h] [rbp-60h]
int i; // [rsp+14h] [rbp-5Ch]
long long v7; // [rsp+18h] [rbp-58h] BYREF
_QWORD v8[2]; // [rsp+20h] [rbp-50h] BYREF
_BYTE v9[40]; // [rsp+30h] [rbp-40h] BYREF
unsigne... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x60
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV qword ptr [RBP + -0x48],RAX
NOP
NOP
LEA RDX,[RBP + -0x50]
LEA RAX,[RBP + -0x40]
LEA RCX,[0x103008]
MOV RSI,RCX
MOV RDI,RAX
... | /* func0(std::string) */
int func0(ulong param_1)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
char *pcVar4;
int4 extraout_var;
ulong uVar5;
long in_FS_OFFSET;
int local_68;
int local_64;
int8 local_60;
int8 local_58;
int8 *local_50;
string local_48 [40];
long local_20;
... |
393 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string s){
string uvowel="AEIOU";
int count=0;
for (int i=0;i*2<s.length();i++)
if (find(uvowel.begin(),uvowel.end(),s[i*2])!=uvowel.end())
count+=1;
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("aBCdEf") == 1);
assert (func0("abcdefg") == 0);
assert (func0("dBBE") == 0);
assert (func0("B") == 0);
assert (func0("U") == 1);
assert (func0("") == 0);
assert (func0("EEEE") == 2);
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %rsp,%rdi
lea 0x10(%rsp),%rax
mov %rax,(%rsp)
lea 0xdfe(%rip),%rdx
lea -0x5(%rdx),%rs... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbx
sub rsp, 30h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+38h+var_10], rax
xor eax, eax
mov rdi, rsp
lea rax, [rsp+38h+var_28]
mov [rsp+38h+var_38], rax
lea rdx, aAeiou+5; ""
lea rsi, [rdx-5]
call _ZNSt... | long long func0(long long a1)
{
long long v1; // rax
char *v2; // r8
char *v3; // rsi
unsigned long long v4; // r9
unsigned int v5; // ebx
char *v6; // rax
char v7; // dl
long long v8; // rdx
void *v10; // [rsp+0h] [rbp-38h] BYREF
long long v11; // [rsp+8h] [rbp-30h]
_QWORD v12[5]; // [rsp+10h] [... | func0:
ENDBR64
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RDI,RSP
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
LEA RDX,[0x102066]
LEA RSI,[RDX + -0x5]
CALL 0x00101732
MOV RAX,qword ptr [RBX + 0x8]
TEST RAX,RAX
JZ 0x0010134f
MOV RDI,qword ptr [RSP]
MOV RC... | /* func0(std::string) */
int func0(int8 *param_1)
{
char *pcVar1;
char cVar2;
long *plVar3;
long *plVar4;
long *plVar5;
long lVar6;
int iVar7;
char *pcVar8;
long in_FS_OFFSET;
long *local_38;
ulong local_30;
long local_28 [3];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
... |
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.