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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
94 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string str){
return str.length();
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("x") == 1);
assert (func0("asdasnakj") == 9);
assert (func0("abc") == 3);
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
retq
nopl 0x0(%rax)
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov eax, [rdi+8]
retn | long long func0(long long a1)
{
return *(unsigned int *)(a1 + 8);
} | func0:
ENDBR64
MOV EAX,dword ptr [RDI + 0x8]
RET | /* func0(std::string) */
int4 func0(long param_1)
{
return *(int4 *)(param_1 + 8);
} |
95 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string str){
return str.length();
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("x") == 1);
assert (func0("asdasnakj") == 9);
assert (func0("abc") == 3);
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
retq
nopl 0x0(%rax)
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov eax, [rdi+8]
retn | long long func0(long long a1)
{
return *(unsigned int *)(a1 + 8);
} | func0:
ENDBR64
MOV EAX,dword ptr [RDI + 0x8]
RET | /* func0(std::string) */
int4 func0(long param_1)
{
return *(int4 *)(param_1 + 8);
} |
96 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
for (int i=2;i*i<=n;i++)
if (n%i==0) return n/i;
return 1;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3) == 1);
assert (func0(7) == 1);
assert (func0(10) == 5);
assert (func0(100) == 50);
assert (func0(49) == 7);
assert (func0(15) == 5);
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x2,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
jl 1182 <_Z5func0i+0x39>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 117c <_Z5func0i+0x33>
mov -0x14(%rbp),%e... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 2
jmp short loc_1177
loc_115D:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1173
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
jmp short loc_1187
loc_1173:
... | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
for ( i = 2; a1 >= i * i; ++i )
{
if ( !(a1 % i) )
return (unsigned int)(a1 / i);
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00101177
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101173
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
JMP 0x00101187
LAB_00101... | /* func0(int) */
ulong func0(int param_1)
{
int local_c;
local_c = 2;
while( true ) {
if (param_1 < local_c * local_c) {
return 1;
}
if (param_1 % local_c == 0) break;
local_c = local_c + 1;
}
return (long)param_1 / (long)local_c & 0xffffffff;
} |
97 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
for (int i=2;i*i<=n;i++)
if (n%i==0) return n/i;
return 1;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3) == 1);
assert (func0(7) == 1);
assert (func0(10) == 5);
assert (func0(100) == 50);
assert (func0(49) == 7);
assert (func0(15) == 5);
}
| O1 | cpp | func0(int):
endbr64
cmp $0x3,%edi
jle 1185 <_Z5func0i+0x3c>
test $0x1,%dil
je 1178 <_Z5func0i+0x2f>
mov $0x2,%ecx
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 117f <_Z5func0i+0x36>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 115d <_Z5func0i+0x14>
mov %edi,%e... | _Z5func0i:
endbr64
cmp edi, 3
jle short loc_1184
mov esi, edi
and esi, 1
jz short loc_117D
mov ecx, 2
loc_115E:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jg short loc_117A
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_115E
loc_1173:
mov eax... | long long func0(int a1)
{
unsigned int v1; // esi
int v2; // ecx
if ( a1 <= 3 )
{
return 1;
}
else
{
v1 = a1 & 1;
if ( (a1 & 1) != 0 )
{
v2 = 2;
while ( 1 )
{
++v2;
if ( v2 * v2 > a1 )
break;
if ( !(a1 % v2) )
return (unsigned... | func0:
ENDBR64
CMP EDI,0x3
JLE 0x00101184
MOV ESI,EDI
AND ESI,0x1
JZ 0x0010117d
MOV ECX,0x2
LAB_0010115e:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x0010117a
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010115e
LAB_00101173:
MOV EAX,EDI
CDQ
IDIV ECX
MOV ESI,EAX
LAB_0010117a:
MOV EAX,ESI
RET
LAB_0010117d:
MOV... | /* func0(int) */
uint func0(int param_1)
{
uint uVar1;
int iVar2;
if (param_1 < 4) {
uVar1 = 1;
}
else {
if ((param_1 & 1U) == 0) {
iVar2 = 2;
}
else {
iVar2 = 2;
do {
iVar2 = iVar2 + 1;
if (param_1 < iVar2 * iVar2) {
return param_1 & 1U;
... |
98 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
for (int i=2;i*i<=n;i++)
if (n%i==0) return n/i;
return 1;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3) == 1);
assert (func0(7) == 1);
assert (func0(10) == 5);
assert (func0(100) == 50);
assert (func0(49) == 7);
assert (func0(15) == 5);
}
| O2 | cpp | func0(int):
endbr64
cmp $0x3,%edi
jle 1175 <_Z5func0i+0x35>
mov $0x2,%ecx
test $0x1,%dil
jne 1169 <_Z5func0i+0x29>
jmp 1180 <_Z5func0i+0x40>
nopw %cs:0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1180 <_Z5func0i+0x40>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp... | _Z5func0i:
endbr64
cmp edi, 3
jle short loc_118A
mov esi, edi
mov ecx, 2
and esi, 1
jnz short loc_1169
jmp short loc_1180
loc_1160:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1180
loc_1169:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle sho... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 3 )
return 1;
v1 = 2;
v2 = a1 & 1;
if ( (a1 & 1) != 0 )
{
while ( 1 )
{
++v1;
if ( v1 * v1 > a1 )
break;
if ( !(a1 % v1) )
return (unsigned int)(a1 / v1);
}
return v2;
}
... | func0:
ENDBR64
CMP EDI,0x3
JLE 0x0010118a
MOV ESI,EDI
MOV ECX,0x2
AND ESI,0x1
JNZ 0x00101169
JMP 0x00101180
LAB_00101160:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101169:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JLE 0x00101160
LAB_00101175:
MOV EAX,ESI
RET
LAB_00101180:
MOV EAX,EDI
CDQ
IDIV ECX... | /* func0(int) */
int [16] func0(int param_1)
{
int iVar1;
uint uVar2;
ulong in_RDX;
uint uVar3;
int auVar4 [16];
int auVar5 [16];
if (param_1 < 4) {
uVar3 = 1;
}
else {
iVar1 = 2;
uVar3 = param_1 & 1;
uVar2 = uVar3;
while( true ) {
if (uVar2 == 0) {
auVar5._8_8_... |
99 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
for (int i=2;i*i<=n;i++)
if (n%i==0) return n/i;
return 1;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3) == 1);
assert (func0(7) == 1);
assert (func0(10) == 5);
assert (func0(100) == 50);
assert (func0(49) == 7);
assert (func0(15) == 5);
}
| O3 | cpp | func0(int):
endbr64
cmp $0x3,%edi
jle 1175 <_Z5func0i+0x35>
mov $0x2,%ecx
test $0x1,%dil
jne 1169 <_Z5func0i+0x29>
jmp 1180 <_Z5func0i+0x40>
nopw %cs:0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1180 <_Z5func0i+0x40>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp... | _Z5func0i:
endbr64
cmp edi, 3
jle short loc_118A
mov esi, edi
mov ecx, 2
and esi, 1
jnz short loc_1169
jmp short loc_1180
loc_1160:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1180
loc_1169:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jle sho... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 3 )
return 1;
v1 = 2;
v2 = a1 & 1;
if ( (a1 & 1) != 0 )
{
while ( 1 )
{
++v1;
if ( v1 * v1 > a1 )
break;
if ( !(a1 % v1) )
return (unsigned int)(a1 / v1);
}
return v2;
}
... | func0:
ENDBR64
CMP EDI,0x3
JLE 0x0010118a
MOV ESI,EDI
MOV ECX,0x2
AND ESI,0x1
JNZ 0x00101169
JMP 0x00101180
LAB_00101160:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101169:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JLE 0x00101160
LAB_00101175:
MOV EAX,ESI
RET
LAB_00101180:
MOV EAX,EDI
CDQ
IDIV ECX... | /* func0(int) */
int [16] func0(int param_1)
{
int iVar1;
uint uVar2;
ulong in_RDX;
uint uVar3;
int auVar4 [16];
int auVar5 [16];
if (param_1 < 4) {
uVar3 = 1;
}
else {
iVar1 = 2;
uVar3 = param_1 & 1;
uVar2 = uVar3;
while( true ) {
if (uVar2 == 0) {
auVar5._8_8_... |
100 | 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={};
for (int i=2;i*i<=n;i++)
if (n%i==0)
{
n=n/i;
out.push_back(i);
i-=1;
}
out.push_back(n);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(2) , {2}));
assert (issame(func0(4) , {2, 2}));
assert (... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x28(%rbp),%rax
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
movq $0x0,0x10(%rax)
mov -0x28(%rbp),%rax
mov %rax,%rdi
ca... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_28]
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 v3; // [rsp+4h] [rbp-2Ch] BYREF
long long v4; // [rsp+8h] [rbp-28h]
int i; // [rsp+14h] [rbp-1Ch] BYREF
unsigned long long v6; // [rsp+18h] [rbp-18h]
v4 = a1;
v3 = a2;
v6 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
std::vecto... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x28]
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 in_ESI;
int4 in_register_0000003c;
long in_FS_OFFSET;
int local_34;
vector<int,std::allocator<int>> *local_30;
int local_24;
long local_20;
local_30 = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1... |
101 | 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={};
for (int i=2;i*i<=n;i++)
if (n%i==0)
{
n=n/i;
out.push_back(i);
i-=1;
}
out.push_back(n);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(2) , {2}));
assert (issame(func0(4) , {2, 2}));
assert (... | O1 | cpp | func0(int):
endbr64
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rbx
mov %esi,0xc(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
movl $0x2,0x14(%rsp)
cmp $0x3,%esi
jle 131e <_Z5func0i+0x9e>
mov $0x2,%ecx
lea 0... | _Z5func0i:
endbr64
push rbp
push rbx
sub rsp, 28h
mov rbp, rdi
mov ecx, esi
mov [rsp+38h+var_2C], esi
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_24], 2
cmp esi, 3
jle ... | long long func0(long long a1, int a2)
{
int v2; // ecx
int v3; // ebx
int *v4; // rsi
int *v5; // rsi
int v7; // [rsp+Ch] [rbp-2Ch] BYREF
int v8; // [rsp+14h] [rbp-24h] BYREF
unsigned long long v9; // [rsp+18h] [rbp-20h]
v2 = a2;
v7 = a2;
v9 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
*(_QWOR... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBP,RDI
MOV ECX,ESI
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x14],0x2
CMP ESI,0x3
JLE 0x0010131a
MOV EBX,0x2
JMP... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int *piVar1;
int iVar2;
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_2c [2];
int local_24;
long local_20;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_r... |
102 | 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={};
for (int i=2;i*i<=n;i++)
if (n%i==0)
{
n=n/i;
out.push_back(i);
i-=1;
}
out.push_back(n);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(2) , {2}));
assert (issame(func0(4) , {2, 2}));
assert (... | O2 | cpp | func0(int):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %esi,0xc(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
movl $0x2,0x14(%rsp)
cmp $0x3,%esi
jle 1b88 <_Z5func0i+0xf8>
xor %r9d,%... | _Z5func0i:
endbr64
push r12
pxor xmm0, xmm0
mov r12, rdi
push rbp
push rbx
sub rsp, 20h
mov [rsp+38h+var_2C], esi
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_24], 2
movups xmmword ptr [rdi], xmm0
cmp esi, 3
jle l... | long long func0(long long a1, int a2)
{
int v2; // ebp
int *v3; // rcx
int *v4; // rsi
int v5; // ebx
int v6; // eax
int v7; // edx
int v9; // [rsp+4h] [rbp-2Ch] BYREF
int v10; // [rsp+Ch] [rbp-24h] BYREF
unsigned long long v11; // [rsp+10h] [rbp-20h]
v9 = a2;
v11 = __readfsqword(0x28u);
*(_QW... | func0:
ENDBR64
PUSH R12
PXOR XMM0,XMM0
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x14],0x2
MOVUPS xmmword ptr [RDI],XMM0
CMP ESI,0x3
JLE 0x00101900
MOV EBP,ESI
XOR EC... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
uint *puVar4;
ulong uVar5;
uint in_ESI;
uint *puVar6;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
uint local_2c [2];
uint local_24;
long local_2... |
103 | 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={};
for (int i=2;i*i<=n;i++)
if (n%i==0)
{
n=n/i;
out.push_back(i);
i-=1;
}
out.push_back(n);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(2) , {2}));
assert (issame(func0(4) , {2, 2}));
assert (... | O3 | cpp | func0(int):
endbr64
push %r12
pxor %xmm0,%xmm0
mov %rdi,%r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %esi,0xc(%rsp)
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movl $0x2,0x14(%rsp)
movups %xmm0,(%rdi)
cmp $0x3,%esi
jle 1b58 <_Z5func0i+0xf8>
mov $0x2,%ed... | _Z5func0i:
endbr64
push r12
pxor xmm0, xmm0
mov r12, rdi
push rbp
push rbx
sub rsp, 20h
mov [rsp+38h+var_2C], esi
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_24], 2
movups xmmword ptr [rdi], xmm0
cmp esi, 3
jle l... | long long func0(long long a1, int a2)
{
int v2; // ebp
int *v3; // rcx
int *v4; // rsi
int v5; // ebx
int v6; // eax
int v8; // [rsp+4h] [rbp-2Ch] BYREF
int v9; // [rsp+Ch] [rbp-24h] BYREF
unsigned long long v10; // [rsp+10h] [rbp-20h]
v8 = a2;
v10 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = ... | func0:
ENDBR64
PUSH R12
PXOR XMM0,XMM0
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x14],0x2
MOVUPS xmmword ptr [RDI],XMM0
CMP ESI,0x3
JLE 0x00101ae0
MOV EBP,ESI
XOR EC... | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
ulong uVar1;
uint uVar2;
uint *puVar3;
uint uVar4;
ulong uVar5;
uint in_ESI;
uint *puVar6;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
uint local_2c [2];
uint local_24;
long local... |
104 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
vector<int> out={};
vector<int> has1={};
vector<int> has2={};
for (int i=0;i<numbers.size();i++)
{
if (find(has2.begin(),has2.end(),numbers[i])!=has2.end()) continue;
if (find(has1.begin(),has1.end(),numbers[i])!=has1.end())
{
... | #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({1, 2, 3, 4}) , {1, 2, 3, ... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
add $0xffffffffffffff80,%rsp
mov %rdi,-0x88(%rbp)
mov %rsi,-0x90(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x88(%rbp),%rax
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
movq ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 70h
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_78]
pxor xmm0, xmm0
movups xmmword ptr [rax], xmm0
movq qword ptr [rax+... | long long func0(long long a1, long long a2)
{
long long v2; // r12
long long v3; // rbx
long long v4; // rax
long long v5; // r12
long long v6; // rbx
long long v7; // rax
long long v8; // rax
long long v9; // rax
long long v10; // r12
long long v11; // rbx
long long v12; // rax
long long v13; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x70
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword ptr [RAX + 0x10],XMM0
MOV RAX... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int4 extraout_var;
int4 extraout_var_00;
ulong uVar4;
int *piVar5;
int4 extraout_var_01;
vector<int,std::allocator<int>> *in_RSI... |
105 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
vector<int> out={};
vector<int> has1={};
vector<int> has2={};
for (int i=0;i<numbers.size();i++)
{
if (find(has2.begin(),has2.end(),numbers[i])!=has2.end()) continue;
if (find(has1.begin(),has1.end(),numbers[i])!=has1.end())
{
... | #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({1, 2, 3, 4}) , {1, 2, 3, ... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%r14
mov %rsi,%rbx
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
movq $0x0,(%rs... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r12, rdi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov [rsp+78h+var_78], 0
mo... | long long func0(long long a1, long long *a2)
{
long long v2; // rax
unsigned long long v4; // r13
char *v5; // rbp
_DWORD *v6; // r14
char *v7; // r15
unsigned long long v8; // rbp
char *v9; // r13
_DWORD *v10; // r14
_DWORD *v11; // rsi
void *v13; // [rsp+0h] [rbp-78h] BYREF
char *v14; // [rsp+8... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int *piVar1;
int *piVar2;
int *piVar3;
__normal_iterator _Var4;
int4 extraout_var;
int4 extraout_var_00;
long lVar5;
int4 extraout_var_01;
random_access_iterator_tag rVar6;
long in_RCX;
... |
106 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
vector<int> out={};
vector<int> has1={};
vector<int> has2={};
for (int i=0;i<numbers.size();i++)
{
if (find(has2.begin(),has2.end(),numbers[i])!=has2.end()) continue;
if (find(has1.begin(),has1.end(),numbers[i])!=has1.end())
{
... | #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({1, 2, 3, 4}) , {1, 2, 3, ... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rcx
movq $0x0,(%rsp)
movq $0x0,0x8(%rs... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
pxor xmm0, xmm0
mov qword ptr [rdi+10h], 0
mov rdi... | long long func0(long long a1, long long *a2)
{
long long v3; // rdi
long long v5; // rbp
char *v6; // r8
char *v7; // rbx
int *v8; // rcx
long long v9; // rdx
long long v10; // rax
int v11; // eax
char *v12; // rsi
char *v13; // rdx
long long v14; // rsi
int v15; // eax
char *v16; // rax
si... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
PXOR XMM0,XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDI,qword ptr [RSI]
MOV qword ptr [RSP + 0x30],0x0
MOV qword... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int *piVar1;
int8 uVar2;
int iVar3;
int *piVar4;
int *piVar5;
long lVar6;
long lVar7;
int *piVar8;
ulong uVar9;
long *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>>... |
107 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
vector<int> out={};
vector<int> has1={};
vector<int> has2={};
for (int i=0;i<numbers.size();i++)
{
if (find(has2.begin(),has2.end(),numbers[i])!=has2.end()) continue;
if (find(has1.begin(),has1.end(),numbers[i])!=has1.end())
{
... | #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({1, 2, 3, 4}) , {1, 2, 3, ... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rcx
mov 0x8(%rsi),%r8
movq $0x0,0x10(%r... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rsi
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
pxor xmm0, xmm0
mov qword ptr [rdi+10... | long long func0(long long a1, long long *a2)
{
long long v4; // rdi
long long v5; // rsi
long long v6; // rbp
char *v7; // r8
char *v8; // rbx
unsigned int *v9; // r9
long long v10; // rcx
long long v11; // rdx
unsigned int v12; // edx
char *v13; // rax
unsigned int v14; // edx
unsigned int *v1... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV R15,RSI
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
PXOR XMM0,XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDI,qword ptr [RSI + 0x8]
MOV RSI,qword ptr [RSI... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int *piVar1;
int8 uVar2;
int *piVar3;
int *piVar4;
int iVar5;
long lVar6;
long lVar7;
int iVar8;
int *piVar9;
ulong uVar10;
long *in_RSI;
long lVar11;
int4 in_register_0000003c;
ve... |
108 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string str){
string out="";
for (int i=0;i<str.length();i++)
{
char w=str[i];
if (w>=97 and w<=122) {w-=32;}
else
if (w>=65 and w<=90){ w+=32;}
out=out+w;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("Hello!") == "hELLO!");
assert (func0("These violent delights have violent ends") == "tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS");
assert (func0("Hello") == "hELLO");
}
| 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
lea -0x46(%rbp),%rax
mov %rax,%rdi
callq 2340 <_... | _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
lea rax, [rbp+var_4E]
mov [rbp+var_48], rax
nop
nop
lea rdx, [rbp... | long long func0(long long a1, long long a2)
{
unsigned long long v2; // rbx
char v4; // [rsp+12h] [rbp-4Eh] BYREF
char v5; // [rsp+13h] [rbp-4Dh]
int i; // [rsp+14h] [rbp-4Ch]
char *v7; // [rsp+18h] [rbp-48h]
_BYTE v8[40]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v9; // [rsp+48h] [rbp-18h]
v9 =... | 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
LEA RAX,[RBP + -0x4e]
MOV qword ptr [RBP + -0x48],RAX
NOP
NOP
LEA RDX,[RBP + -0x4e]
MOV RAX,qword ptr [RBP + -0x58]
LEA RCX,[0... | /* func0(std::string) */
string * func0(string *param_1,ulong param_2)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
long in_FS_OFFSET;
allocator local_56;
char local_55;
int local_54;
allocator *local_50;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_50 ... |
109 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string str){
string out="";
for (int i=0;i<str.length();i++)
{
char w=str[i];
if (w>=97 and w<=122) {w-=32;}
else
if (w>=65 and w<=90){ w+=32;}
out=out+w;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("Hello!") == "hELLO!");
assert (func0("These violent delights have violent ends") == "tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS");
assert (func0("Hello") == "hELLO");
}
| 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 %rsi,%r15
mov %fs:0x28,%rax
mov %rax,0x48(%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, 58h
mov rbx, rdi
mov r13, rsi
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rsp+88h+var_80], rax
mov ... | void ** func0(void **a1, _QWORD *a2)
{
long long v4; // rbp
char v5; // al
_BYTE *v6; // rax
void *v7; // rcx
unsigned long long v8; // r12
_BYTE *v9; // r15
char *v10; // rdx
unsigned long long v11; // rdi
_BYTE *v12; // rax
char *v13; // rsi
unsigned int v14; // ecx
unsigned int v15; // eax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV R13,RSI
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
LEA RSI,[0x102165]
MOV RDX,RSI
LAB_00101307:
CALL 0x001018ea
CMP qwo... | /* func0(std::string) */
ulong * func0(ulong *param_1,long *param_2)
{
ulong *puVar1;
ulong uVar2;
uint uVar3;
int8 uVar4;
long lVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
long in_FS_OFFSET;
char local_69;
ulong *local_68;
int8 local_60;
ulong local_58 [5];
local_58[3] = *(long *)(in_F... |
110 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string str){
string out="";
for (int i=0;i<str.length();i++)
{
char w=str[i];
if (w>=97 and w<=122) {w-=32;}
else
if (w>=65 and w<=90){ w+=32;}
out=out+w;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("Hello!") == "hELLO!");
assert (func0("These violent delights have violent ends") == "tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS");
assert (func0("Hello") == "hELLO");
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
lea 0x10(%rdi),%r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rsi,(%rsp)
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
cmpq $0x0,0x... | _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
char v6; // al
double *v7; // rdi
size_t v8; // rdx
double v9; // rcx
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;
ulong uVar3;
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_OFFSE... |
111 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string str){
string out="";
for (int i=0;i<str.length();i++)
{
char w=str[i];
if (w>=97 and w<=122) {w-=32;}
else
if (w>=65 and w<=90){ w+=32;}
out=out+w;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("Hello!") == "hELLO!");
assert (func0("These violent delights have violent ends") == "tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS");
assert (func0("Hello") == "hELLO");
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
lea 0x10(%rdi),%r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rsi,(%rsp)
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
cmpq $0x0,0x... | _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
char v6; // al
double *v7; // rdi
size_t v8; // rdx
double v9; // rcx
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;
long lVar2;
ulong *__dest;
ulong uVar3;
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 + 0x28);
pu... |
112 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<string> strings){
string out="";
for (int i=0;i<strings.size();i++)
out=out+strings[i];
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == "");
assert (func0({"x", "y", "z"}) == "xyz");
assert (func0({"x", "y", "z", "w", "k"}) == "xyzwk");
assert (func0({"a", "b", "c"}) == "abc");
}
| O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
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
lea rax, [rbp+var_4D]
mov [rbp+var_48], rax
nop
nop... | long long func0(long long a1, long long a2)
{
long long v2; // rax
unsigned long long v3; // rbx
char v5; // [rsp+13h] [rbp-4Dh] BYREF
int i; // [rsp+14h] [rbp-4Ch]
char *v7; // [rsp+18h] [rbp-48h]
_BYTE v8[40]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v9; // [rsp+48h] [rbp-18h]
v9 = __readfsqw... | 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
LEA RAX,[RBP + -0x4d]
MOV qword ptr [RBP + -0x48],RAX
NOP
NOP
LEA RDX,[RBP + -0x4d]
MOV RAX,qword ptr [RBP + -0x58]
LEA RCX,[0... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
string * func0(vector param_1)
{
int8 uVar1;
ulong uVar2;
ulong uVar3;
vector<std::string,std::allocator<std::string>> *in_RSI;
int4 in_register_0000003c;
string *this;
long in_FS_OFFSET;
allocator local_55;
int local_54;
allocat... |
113 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<string> strings){
string out="";
for (int i=0;i<strings.size();i++)
out=out+strings[i];
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == "");
assert (func0({"x", "y", "z"}) == "xyz");
assert (func0({"x", "y", "z", "w", "k"}) == "xyzwk");
assert (func0({"a", "b", "c"}) == "abc");
}
| O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%rbx
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rsp+88h+va... | void ** func0(void **a1, long long *a2)
{
long long v4; // rax
long long v5; // rbp
_BYTE *v6; // rax
void *v7; // rcx
long long *v8; // rax
unsigned long long v9; // r13
unsigned long long v10; // r12
char *v11; // rdx
unsigned long long v12; // rdi
_BYTE *v13; // rax
char *v14; // rsi
unsigned... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RDI],RAX
LEA RSI,[0x102033]
MOV RDX,RSI
LAB_00101387:
CALL 0x00101a5e
MOV RA... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
ulong * func0(vector param_1)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
uint uVar4;
int8 uVar5;
ulong *puVar6;
long lVar7;
uint uVar8;
ulong uVar9;
ulong uVar10;
long *in_RSI;
int4 in_register_0000003c;
ulong *puVar11;
lon... |
114 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<string> strings){
string out="";
for (int i=0;i<strings.size();i++)
out=out+strings[i];
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == "");
assert (func0({"x", "y", "z"}) == "xyz");
assert (func0({"x", "y", "z", "w", "k"}) == "xyzwk");
assert (func0({"a", "b", "c"}) == "abc");
}
| O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
mov %rsi,%r14
lea 0x10(%rdi),%rsi
push %r13
push %r12
mov %rdi,%r12
push ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
mov r15, rsi
lea rsi, assertion+0Fh; ""
push r14
mov rdx, rsi
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax... | void ** func0(void **a1, long long *a2)
{
long long v3; // rax
long long v4; // rbp
double v5; // rcx
size_t v6; // r12
long long *v7; // rax
size_t v8; // r13
long long v9; // rcx
double *v10; // rdi
size_t v11; // rdx
size_t v13; // rdx
double *v14; // rdi
double *v15; // [rsp+10h] [rbp-88h]
... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
LEA RSI,[0x102037]
PUSH R14
MOV RDX,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
LEA R14,[RSP + 0x40]
MOV qword ptr [RDI],RAX
MOV qword ptr [RSP + 0x20],RAX
LAB_00101773:
C... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
ulong * func0(vector param_1)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
ulong *puVar6;
ulong uVar7;
long *in_RSI;
int4 in_register_0000003c;
ulong *puVar8;
long in_FS_OFFSET;
ulong *local_68;
size_t ... |
115 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(vector<string> strings){
string out="";
for (int i=0;i<strings.size();i++)
out=out+strings[i];
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == "");
assert (func0({"x", "y", "z"}) == "xyz");
assert (func0({"x", "y", "z", "w", "k"}) == "xyzwk");
assert (func0({"a", "b", "c"}) == "abc");
}
| O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
lea 0x10(%rdi),%r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
lea rcx, [rdi+10h]
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
mov byte ptr [rdi+10h], 0
mov ... | long long func0(long long a1, long long *a2)
{
long long v3; // rax
long long v4; // rbp
size_t v5; // r12
double v6; // rcx
long long *v7; // rax
size_t v8; // r13
long long v9; // rax
double *v10; // rdi
size_t v11; // rdx
size_t v13; // rdx
double *v14; // rdi
long long v15; // [rsp+8h] [rbp... | func0:
ENDBR64
PUSH R15
LEA RCX,[RDI + 0x10]
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV byte ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI]
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RDI],RCX
MOV qword ptr [RDI + 0x8]... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
long * func0(vector param_1)
{
ulong *puVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
ulong *puVar5;
ulong uVar6;
long *in_RSI;
int4 in_register_0000003c;
long *plVar7;
ulong uVar8;
long in_FS_OFFSET;
ulong *local_88;
ulong *... |
116 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<string> strings, string prefix){
vector<string> out={};
for (int i=0;i<strings.size();i++)
if (strings[i].substr(0,prefix.length())==prefix) out.push_back(strings[i]);
return out;
}
| #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({}, "john") , {}));
assert (issame(func0({"xxx", "asd", "x... | 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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
pu... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_58]
pxor... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rbx
long long v4; // rax
long long v5; // rax
int i; // [rsp+2Ch] [rbp-44h]
_BYTE v9[40]; // [rsp+30h] [rbp-40h] BYREF
unsigned long long v10; // [rsp+58h] [rbp-18h]
v10 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
*(_QWORD... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x58]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword ptr [R... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,
vector<std::string,std::allocator<std::string>> *param_2,string *param_3)
{
bool bVar1;
string *psVar2;
ulong u... |
117 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<string> strings, string prefix){
vector<string> out={};
for (int i=0;i<strings.size();i++)
if (strings[i].substr(0,prefix.length())==prefix) out.push_back(strings[i]);
return out;
}
| #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({}, "john") , {}));
assert (issame(func0({"xxx", "asd", "x... | 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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r15, rdi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov ... | long long func0(long long a1, long long *a2, long long a3)
{
long long v4; // rax
long long v7; // rbx
bool v8; // r14
void *v9; // rdi
long long *v10; // rax
unsigned long long v11; // rdx
long long v12; // rsi
unsigned long long v13; // rax
_QWORD *v14; // rbp
_QWORD *v15; // rdi
void *s1; // [... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R15,RDI
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 RAX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RAX
JZ 0x0010152c
MOV R12,RSI... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2,int8 *param_3)
{
char *pcVar1;
ulong uVar2;
long *plVar3;
int iVar4;
long lVar5;
int8 *puVar6;
... |
118 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<string> strings, string prefix){
vector<string> out={};
for (int i=0;i<strings.size();i++)
if (strings[i].substr(0,prefix.length())==prefix) out.push_back(strings[i]);
return out;
}
| #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({}, "john") , {}));
assert (issame(func0({"xxx", "asd", "x... | 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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
mov %rdi,%r15
pu... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rdi
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
lea rcx, [rsp+78h+s1]
movups xmm... | long long func0(long long a1, long long *a2, long long a3)
{
long long v4; // rax
unsigned long long v7; // rbx
unsigned long long v8; // rdx
long long *v9; // rax
long long v10; // rsi
unsigned long long v11; // rax
_QWORD *v12; // rdi
_QWORD *v13; // rdi
_QWORD *v14; // rbp
long long v15; // rdx
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV R15,RDI
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
LEA RCX,[RSP + 0x10]
MOVUPS xmmword ptr [RDI],XMM0
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RSP],RCX
CMP RAX,qw... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2,int8 *param_3)
{
char *pcVar1;
ulong uVar2;
long *plVar3;
int8 uVar4;
int iVar5;
long lVar6;
in... |
119 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<string> func0(vector<string> strings, string prefix){
vector<string> out={};
for (int i=0;i<strings.size();i++)
if (strings[i].substr(0,prefix.length())==prefix) out.push_back(strings[i]);
return out;
}
| #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({}, "john") , {}));
assert (issame(func0({"xxx", "asd", "x... | 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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_90], rdi
lea rcx, [rsp+98h+s1]
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, ea... | long long func0(long long a1, long long *a2, long long a3)
{
long long v3; // rax
unsigned long long i; // rbp
size_t v6; // rbx
long long v7; // rax
_BYTE *v8; // rcx
size_t v9; // rax
_QWORD *v10; // rax
_QWORD *v11; // rbx
_QWORD *v12; // rdi
long long v13; // r12
long long *v14; // rbx
void... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x8],RDI
LEA RCX,[RSP + 0x30]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x10],RCX
LEA RCX,[RSP + 0x28]
MOVUPS xmmword ptr [RDI],XMM0
MOV RAX,qword ptr [... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2,int8 *param_3)
{
int *puVar1;
ulong uVar2;
ulong *puVar3;
int iVar4;
long lVar5;
int8 *puVar6;
... |
120 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> l){
vector<float> out={};
for (int i=0;i<l.size();i++)
if (l[i]>0) out.push_back(l[i]);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({-1, -2, 4, 5, 6}) , {4, 5, 6} ));
assert (issa... | O0 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x28(%rbp),%rax
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
movq $0x0,0x10(%rax)
mov ... | _Z5func0St6vectorIfSaIfEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, [rbp+var_28]
pxor xmm0, xmm0
movups xmmword ptr [rax], xmm0
movq qword ptr [rax+10h], xmm0
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorI... | long long func0(long long a1, long long a2)
{
long long v2; // rax
int i; // [rsp+1Ch] [rbp-14h]
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
std::vector<float>::vector(a1);
for ( i = 0; i < (unsigned long long)std::vector<float>::size(a2); ++i )
{
if ( *(float *)std::vector<float>::operator[](a... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x28]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword ptr [RAX + 0x10],XMM0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x0010216e
MOV dword ptr [RBP + -0x14],... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
float *pfVar1;
ulong uVar2;
vector<float,std::allocator<float>> *in_RSI;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
int local_1c;
this = (vector<float,std::... |
121 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> l){
vector<float> out={};
for (int i=0;i<l.size();i++)
if (l[i]>0) out.push_back(l[i]);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({-1, -2, 4, 5, 6}) , {4, 5, 6} ));
assert (issa... | O1 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
je 133a <_Z5func0St6vectorIfSaIfEE+0x9b>
mov %rsi,%rbp
mov $0x0,%ebx
jmp 12f4 <_Z5func0St6... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r12
push rbp
push rbx
mov r12, rdi
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp [rsi+8], rdx
jz short loc_132F
mov rbp, rsi
mov ebx, 0
jmp short loc_12EF
loc_12CF:
mov rdi, r12
call ... | long long func0(long long a1, long long *a2)
{
long long v2; // rdx
unsigned long long v4; // rbx
float v5; // xmm0_4
float *v6; // rsi
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v2 = *a2;
if ( a2[1] != *a2 )
{
v4 = 0LL;
do
{
v5 = *(float *)(v2 + 4 * v4);
if ( v5 > 0.0 ... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDX
JZ 0x0010132f
MOV RBP,RSI
MOV EBX,0x0
JMP 0x001012ef
LAB_001012cf:
MOV RDI,R12
LAB_001012d2:
CALL 0x00101bb4
LAB_001012d7:
MOV RDX,qword... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
float *pfVar1;
float fVar2;
float *pfVar3;
long lVar4;
ulong uVar5;
long *in_RSI;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
this = (vector<float,std::a... |
122 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> l){
vector<float> out={};
for (int i=0;i<l.size();i++)
if (l[i]>0) out.push_back(l[i]);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({-1, -2, 4, 5, 6}) , {4, 5, 6} ));
assert (issa... | O2 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
je 19f0 <_Z5func0St6vectorIfSaIfEE+0x80>
mov %rsi,%rbp
xor %ebx,%ebx
jmp 19bc <_Z5func0St6... | _Z5func0St6vectorIfSaIfEE:
endbr64
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rdx
jz short loc_18C0
mov r12, rsi
xor ebx, ebx
jmp short loc_1895
loc_1880:
mov rax, [r12+8]... | long long func0(long long a1, long long *a2)
{
long long v2; // rdx
unsigned long long v4; // rbx
float v5; // xmm0_4
float *v6; // rsi
*(_OWORD *)a1 = 0LL;
v2 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if ( a2[1] != v2 )
{
v4 = 0LL;
do
{
v5 = *(float *)(v2 + 4 * v4);
if ( v5 > 0.0 )... | func0:
ENDBR64
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001018c0
MOV R12,RSI
XOR EBX,EBX
JMP 0x00101895
LAB_00101880:
MOV RAX,qword ptr [R12 + 0x8]
ADD RBX,0x1
SUB RAX,RDX
SAR RAX,0x2
CMP... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
float *pfVar1;
float fVar2;
float *pfVar3;
long lVar4;
ulong uVar5;
long *in_RSI;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
this = (vector<float,std::a... |
123 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> l){
vector<float> out={};
for (int i=0;i<l.size();i++)
if (l[i]>0) out.push_back(l[i]);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({-1, -2, 4, 5, 6}) , {4, 5, 6} ));
assert (issa... | O3 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rdx
mov 0x8(%rsi),%rcx
cmp %rdx,%rcx
je 1970 <_Z5func0St6vectorIfSaIfEE+0x70>
mov %rsi,%rbp
xor %ebx,%ebx
jmp 19... | _Z5func0St6vectorIfSaIfEE:
endbr64
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi+8]
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp rcx, rdx
jz short loc_18C8
mov r12, rsi
xor ebx, ebx
jmp short loc_1893
loc_1880:
mov... | long long func0(long long a1, long long *a2)
{
long long v2; // rcx
long long v3; // rdx
unsigned long long v5; // rbx
float v6; // xmm0_4
float *v7; // rsi
*(_OWORD *)a1 = 0LL;
v2 = a2[1];
v3 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if ( v2 != v3 )
{
v5 = 0LL;
do
{
v6 = *(float *)(v... | func0:
ENDBR64
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOVUPS xmmword ptr [RDI],XMM0
MOV RCX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP RCX,RDX
JZ 0x001018c8
MOV R12,RSI
XOR EBX,EBX
JMP 0x00101893
LAB_00101880:
MOV RAX,RCX
ADD RBX,0x1
SUB RAX,RDX
SAR RAX,0x2
CMP RBX,R... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
float *pfVar1;
float fVar2;
float *pfVar3;
long lVar4;
long lVar5;
ulong uVar6;
long *in_RSI;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
this = (vecto... |
124 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(long long n){
if (n<2) return false;
for (long long i=2;i*i<=n;i++)
if (n%i==0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(6) == false);
assert (func0(101) == true);
assert (func0(11) == true);
assert (func0(13441) == true);
assert (func0(61) == true);
assert (func0(4) == false);
assert (func0(1) == false);
assert (func0(5) == true);
assert (fun... | O0 | cpp | func0(long long):
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
cmpq $0x1,-0x18(%rbp)
jg 1163 <_Z5func0x+0x1a>
mov $0x0,%eax
jmp 119e <_Z5func0x+0x55>
movq $0x2,-0x8(%rbp)
mov -0x8(%rbp),%rax
imul %rax,%rax
cmp %rax,-0x18(%rbp)
jl 1199 <_Z5func0x+0x50>
mov -0x18(%rbp),%rax
cq... | _Z5func0x:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
cmp [rbp+var_18], 1
jg short loc_1163
mov eax, 0
jmp short loc_119E
loc_1163:
mov [rbp+var_8], 2
jmp short loc_118B
loc_116D:
mov rax, [rbp+var_18]
cqo
idiv [rbp+var_8]
mov rax, rdx
test rax, rax
jnz sho... | long long func0(long long a1)
{
long long i; // [rsp+10h] [rbp-8h]
if ( a1 <= 1 )
return 0LL;
for ( i = 2LL; a1 >= i * i; ++i )
{
if ( !(a1 % i) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
CMP qword ptr [RBP + -0x18],0x1
JG 0x00101163
MOV EAX,0x0
JMP 0x0010119e
LAB_00101163:
MOV qword ptr [RBP + -0x8],0x2
JMP 0x0010118b
LAB_0010116d:
MOV RAX,qword ptr [RBP + -0x18]
CQO
IDIV qword ptr [RBP + -0x8]
MOV RAX,RDX
TEST RAX,RAX
JNZ 0x00101186
M... | /* func0(long long) */
int8 func0(longlong param_1)
{
int8 uVar1;
long local_10;
if (param_1 < 2) {
uVar1 = 0;
}
else {
for (local_10 = 2; local_10 * local_10 <= param_1; local_10 = local_10 + 1) {
if (param_1 % local_10 == 0) {
return 0;
}
}
uVar1 = 1;
}
return uV... |
125 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(long long n){
if (n<2) return false;
for (long long i=2;i*i<=n;i++)
if (n%i==0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(6) == false);
assert (func0(101) == true);
assert (func0(11) == true);
assert (func0(13441) == true);
assert (func0(61) == true);
assert (func0(4) == false);
assert (func0(1) == false);
assert (func0(5) == true);
assert (fun... | O1 | cpp | func0(long long):
endbr64
mov $0x0,%eax
cmp $0x1,%rdi
jle 118b <_Z5func0x+0x42>
cmp $0x3,%rdi
jle 1192 <_Z5func0x+0x49>
test $0x1,%dil
je 1198 <_Z5func0x+0x4f>
mov $0x2,%ecx
add $0x1,%rcx
mov %rcx,%rax
imul %rcx,%rax
cmp %rdi,%rax
jg 118c <_Z5func0x+0x43>
mov %rdi,%rax
cqto
idi... | _Z5func0x:
endbr64
mov eax, 0
cmp rdi, 1
jle short locret_118B
cmp rdi, 3
jle short loc_1192
test dil, 1
jz short loc_1198
mov ecx, 2
loc_1169:
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rax, rdi
jg short loc_118C
mov rax, rdi
cqo
idiv rcx
test rdx, rdx
jnz ... | long long func0(long long a1)
{
long long result; // rax
long long v2; // rcx
result = 0LL;
if ( a1 > 1 )
{
if ( a1 <= 3 )
{
return 1LL;
}
else if ( (a1 & 1) != 0 )
{
v2 = 2LL;
while ( 1 )
{
++v2;
if ( v2 * v2 > a1 )
break;
if ( !... | func0:
ENDBR64
MOV EAX,0x0
CMP RDI,0x1
JLE 0x0010118b
CMP RDI,0x3
JLE 0x00101192
TEST DIL,0x1
JZ 0x00101198
MOV ECX,0x2
LAB_00101169:
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RAX,RDI
JG 0x0010118c
MOV RAX,RDI
CQO
IDIV RCX
TEST RDX,RDX
JNZ 0x00101169
MOV EAX,0x0
LAB_0010118b:
RET
LAB_0010118c:
MOV EAX,0x1
RET
LAB_001011... | /* func0(long long) */
int8 func0(longlong param_1)
{
long lVar1;
if (1 < param_1) {
if (param_1 < 4) {
return 1;
}
if ((param_1 & 1U) == 0) {
return 0;
}
lVar1 = 2;
do {
lVar1 = lVar1 + 1;
if (lVar1 * lVar1 - param_1 != 0 && param_1 <= lVar1 * lVar1) {
r... |
126 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(long long n){
if (n<2) return false;
for (long long i=2;i*i<=n;i++)
if (n%i==0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(6) == false);
assert (func0(101) == true);
assert (func0(11) == true);
assert (func0(13441) == true);
assert (func0(61) == true);
assert (func0(4) == false);
assert (func0(1) == false);
assert (func0(5) == true);
assert (fun... | O2 | cpp | func0(long long) [clone .part.0]:
cmp $0x3,%rdi
jle 13b5 <_Z5func0x.part.0+0x35>
test $0x1,%dil
je 13c0 <_Z5func0x.part.0+0x40>
mov $0x2,%ecx
jmp 13a5 <_Z5func0x.part.0+0x25>
nopl 0x0(%rax,%rax,1)
mov %rdi,%rax
cqto
idiv %rcx
test %rdx,%rdx
je 13c0 <_Z5func0x.part.0+0x40>
add $0x1,%rcx... | _Z5func0x_part_0:
cmp rdi, 3
jle short loc_13B5
test dil, 1
jz short loc_13C0
mov ecx, 2
jmp short loc_13A5
loc_1398:
mov rax, rdi
cqo
idiv rcx
test rdx, rdx
jz short loc_13C0
loc_13A5:
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rdi, rax
jge short loc_1398
loc_13... | long long func0(long long a1)
{
long long v1; // rcx
if ( a1 <= 3 )
return 1LL;
if ( (a1 & 1) != 0 )
{
v1 = 2LL;
while ( 1 )
{
++v1;
if ( a1 < v1 * v1 )
break;
if ( !(a1 % v1) )
return 0LL;
}
return 1LL;
}
return 0LL;
} | func0:
CMP RDI,0x3
JLE 0x001013b5
TEST DIL,0x1
JZ 0x001013c0
MOV ECX,0x2
JMP 0x001013a5
LAB_00101398:
MOV RAX,RDI
CQO
IDIV RCX
TEST RDX,RDX
JZ 0x001013c0
LAB_001013a5:
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RDI,RAX
JGE 0x00101398
LAB_001013b5:
MOV EAX,0x1
RET
LAB_001013c0:
XOR EAX,EAX
RET | /* func0(long long) [clone .part.0] */
int8 func0(longlong param_1)
{
long lVar1;
if (param_1 < 4) {
return 1;
}
if ((param_1 & 1U) != 0) {
lVar1 = 2;
do {
lVar1 = lVar1 + 1;
if (param_1 < lVar1 * lVar1) {
return 1;
}
} while (param_1 % lVar1 != 0);
}
return 0;... |
127 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(long long n){
if (n<2) return false;
for (long long i=2;i*i<=n;i++)
if (n%i==0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(6) == false);
assert (func0(101) == true);
assert (func0(11) == true);
assert (func0(13441) == true);
assert (func0(61) == true);
assert (func0(4) == false);
assert (func0(1) == false);
assert (func0(5) == true);
assert (fun... | O3 | cpp | func0(long long) [clone .part.0]:
cmp $0x3,%rdi
jle 13b5 <_Z5func0x.part.0+0x35>
test $0x1,%dil
je 13c0 <_Z5func0x.part.0+0x40>
mov $0x2,%ecx
jmp 13a5 <_Z5func0x.part.0+0x25>
nopl 0x0(%rax,%rax,1)
mov %rdi,%rax
cqto
idiv %rcx
test %rdx,%rdx
je 13c0 <_Z5func0x.part.0+0x40>
add $0x1,%rcx... | _Z5func0x_part_0:
cmp rdi, 3
jle short loc_13B5
test dil, 1
jz short loc_13C0
mov ecx, 2
jmp short loc_13A5
loc_1398:
mov rax, rdi
cqo
idiv rcx
test rdx, rdx
jz short loc_13C0
loc_13A5:
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rdi, rax
jge short loc_1398
loc_13... | long long func0(long long a1)
{
long long v1; // rcx
if ( a1 <= 3 )
return 1LL;
if ( (a1 & 1) != 0 )
{
v1 = 2LL;
while ( 1 )
{
++v1;
if ( a1 < v1 * v1 )
break;
if ( !(a1 % v1) )
return 0LL;
}
return 1LL;
}
return 0LL;
} | func0:
CMP RDI,0x3
JLE 0x001013b5
TEST DIL,0x1
JZ 0x001013c0
MOV ECX,0x2
JMP 0x001013a5
LAB_00101398:
MOV RAX,RDI
CQO
IDIV RCX
TEST RDX,RDX
JZ 0x001013c0
LAB_001013a5:
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RDI,RAX
JGE 0x00101398
LAB_001013b5:
MOV EAX,0x1
RET
LAB_001013c0:
XOR EAX,EAX
RET | /* func0(long long) [clone .part.0] */
int8 func0(longlong param_1)
{
long lVar1;
if (param_1 < 4) {
return 1;
}
if ((param_1 & 1U) != 0) {
lVar1 = 2;
do {
lVar1 = lVar1 + 1;
if (param_1 < lVar1 * lVar1) {
return 1;
}
} while (param_1 % lVar1 != 0);
}
return 0;... |
128 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
double poly(vector<double> xs, double x){
double sum=0;
int i;
for (i=0;i<xs.size();i++)
{
sum+=xs[i]*pow(x,i);
}
return sum;
}
| double func0(vector<double> xs){
double ans=0;
double value;
value=poly(xs,ans);
while (abs(value)>1e-6)
{
double driv=0;
for (int i=1;i<xs.size();i++)
{
driv+=xs[i]*pow(ans,i-1)*i;
}
ans=ans-value/driv;
value=poly(xs,ans);
}
return... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2})+0.5<1e-4);
assert (func0({-6,11,-6,1})-1<1e-4);
}
| O0 | cpp | func0(std::vector<double, std::allocator<double> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
pxor %xmm0,%xmm0
movsd %xmm0,-0x48(%rbp)
mov -0x58(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov ... | _Z5func0St6vectorIdSaIdEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
pxor xmm0, xmm0
movsd [rbp+var_48], xmm0
mov rdx, [rbp+var_58]
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call ... | unsigned long long func0(long long a1)
{
double v2; // [rsp+0h] [rbp-60h]
int i; // [rsp+14h] [rbp-4Ch]
double v4; // [rsp+18h] [rbp-48h]
double v5; // [rsp+20h] [rbp-40h]
double v6; // [rsp+28h] [rbp-38h]
_BYTE v7[24]; // [rsp+30h] [rbp-30h] BYREF
unsigned long long v8; // [rsp+48h] [rbp-18h]
v8 = __... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x48],XMM0
MOV RDX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001017ba
MOV RDX,qword ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<double, std::allocator<double> >) */
double func0(vector param_1)
{
double *pdVar1;
ulong uVar2;
int4 in_register_0000003c;
vector<double,std::allocator<double>> *this;
long in_FS_OFFSET;
double extra... |
129 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
double poly(vector<double> xs, double x){
double sum=0;
int i;
for (i=0;i<xs.size();i++)
{
sum+=xs[i]*pow(x,i);
}
return sum;
}
| double func0(vector<double> xs){
double ans=0;
double value;
value=poly(xs,ans);
while (abs(value)>1e-6)
{
double driv=0;
for (int i=1;i<xs.size();i++)
{
driv+=xs[i]*pow(ans,i-1)*i;
}
ans=ans-value/driv;
value=poly(xs,ans);
}
return... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2})+0.5<1e-4);
assert (func0({-6,11,-6,1})-1<1e-4);
}
| O1 | cpp | func0(std::vector<double, std::allocator<double> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x40,%rsp
mov %rdi,%r12
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
mov 0x8(%rdi),%rbx
sub (%rdi),%rbx
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
movq $0x0,0x30... | _Z5func0St6vectorIdSaIdEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r15, rdi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov r12, [rdi+8]
sub r12, [rdi]
jz loc_13FE
mov rax, 7FFFFFFFFFFFFFF8h
cmp rax, r12
jb ... | double func0(_QWORD *a1)
{
unsigned long long v1; // r12
_QWORD *v2; // rbp
_QWORD *v3; // rsi
long long v4; // rbx
_QWORD *v6; // rbp
_QWORD *v7; // rsi
long long v8; // rbx
_QWORD *v9; // r12
unsigned long long v10; // r14
unsigned long long v11; // r13
unsigned long long v12; // rbx
double v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV R12,qword ptr [RDI + 0x8]
SUB R12,qword ptr [RDI]
JZ 0x001013fe
MOV RAX,0x7ffffffffffffff8
CMP RAX,R12
JC 0x001013e4
MOV RDI,R12
CALL 0x00101120
MOV RB... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<double, std::allocator<double> >) */
double func0(vector param_1)
{
int8 *puVar1;
long lVar2;
double dVar3;
int8 *puVar4;
size_t sVar5;
int4 in_register_0000003c;
long *plVar6;
ulong uVar7;
ulon... |
130 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
double poly(vector<double> xs, double x){
double sum=0;
int i;
for (i=0;i<xs.size();i++)
{
sum+=xs[i]*pow(x,i);
}
return sum;
}
| double func0(vector<double> xs){
double ans=0;
double value;
value=poly(xs,ans);
while (abs(value)>1e-6)
{
double driv=0;
for (int i=1;i<xs.size();i++)
{
driv+=xs[i]*pow(ans,i-1)*i;
}
ans=ans-value/driv;
value=poly(xs,ans);
}
return... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2})+0.5<1e-4);
assert (func0({-6,11,-6,1})-1<1e-4);
}
| O2 | cpp | func0(std::vector<double, std::allocator<double> >):
endbr64
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x40,%rsp
mov (%rdi),%rsi
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
mov 0x8(%rdi),%rax
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
movq $0x0,0x30... | _Z5func0St6vectorIdSaIdEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, [rdi+8]
sub rax, [rdi]
jz loc_16E0
mov r14, rax
mov rax, 7FFFFFFFFFFFFFF8h
cmp rax, r14
jb loc_16E5
mov r13, rdi
mov rdi, r14; unsigned __int64
call ... | double func0(double **a1, double *a2)
{
double *v2; // rbp
unsigned long long v3; // r12
double **v4; // r13
unsigned long long v5; // rax
unsigned long long v6; // r14
double *v7; // rax
signed long long v8; // rdx
unsigned long long v9; // rbx
double v10; // xmm7_8
double v11; // xmm1_8
double ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,qword ptr [RDI]
JZ 0x001016e0
MOV R14,RAX
MOV RAX,0x7ffffffffffffff8
CMP RAX,R14
JC 0x001016e5
MOV R13,RDI
MOV RDI,R14
CALL 0x00101120
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV RBP,RAX... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<double, std::allocator<double> >) */
double func0(vector param_1)
{
long lVar1;
ulong uVar2;
int8 *puVar3;
int8 *__dest;
size_t sVar4;
int iVar5;
ulong uVar6;
int8 *unaff_RBP;
int8 *in_RSI;
in... |
131 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
double poly(vector<double> xs, double x){
double sum=0;
int i;
for (i=0;i<xs.size();i++)
{
sum+=xs[i]*pow(x,i);
}
return sum;
}
| double func0(vector<double> xs){
double ans=0;
double value;
value=poly(xs,ans);
while (abs(value)>1e-6)
{
double driv=0;
for (int i=1;i<xs.size();i++)
{
driv+=xs[i]*pow(ans,i-1)*i;
}
ans=ans-value/driv;
value=poly(xs,ans);
}
return... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2})+0.5<1e-4);
assert (func0({-6,11,-6,1})-1<1e-4);
}
| O3 | cpp | func0(std::vector<double, std::allocator<double> >):
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x28,%rsp
mov 0x8(%rdi),%rax
mov (%rdi),%rsi
mov %rax,%rdi
sub %rsi,%rdi
mov %rdi,%rdx
sar $0x3,%rdx
je 16f9 <_Z5func0St6vectorIdSaIdEE+0x2a9>
movabs $0xfffffffffff... | _Z5func0St6vectorIdSaIdEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, [rdi+8]
sub rax, [rdi]
jz loc_16E0
mov r14, rax
mov rax, 7FFFFFFFFFFFFFF8h
cmp rax, r14
jb loc_16E5
mov r13, rdi
mov rdi, r14; unsigned __int64
call ... | double func0(double **a1, double *a2)
{
double *v2; // rbp
unsigned long long v3; // r12
double **v4; // r13
unsigned long long v5; // rax
unsigned long long v6; // r14
double *v7; // rax
signed long long v8; // rdx
unsigned long long v9; // rbx
double v10; // xmm7_8
double v11; // xmm1_8
double ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,qword ptr [RDI]
JZ 0x001016e0
MOV R14,RAX
MOV RAX,0x7ffffffffffffff8
CMP RAX,R14
JC 0x001016e5
MOV R13,RDI
MOV RDI,R14
CALL 0x00101120
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV RBP,RAX... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<double, std::allocator<double> >) */
double func0(vector param_1)
{
long lVar1;
ulong uVar2;
int8 *puVar3;
int8 *__dest;
size_t sVar4;
int iVar5;
ulong uVar6;
int8 *unaff_RBP;
int8 *in_RSI;
in... |
132 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l){
vector<int> third={};
int i;
for (i=0;i*3<l.size();i++)
third.push_back(l[i*3]);
sort(third.begin(),third.end());
vector<int> out={};
for (i=0;i<l.size();i++)
{
if (i%3==0) {out.push_back(third[i/3]);}
else out.push_back(l[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({1, 2, 3}) , func0({1, 2, 3})));
assert (issame(func0({5, 3,... | 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
movq $0x0,-0x30(%rbp)
movq $0x0,-0x28(%rbp)
movq $0x0,-0x20(%rbp)
lea -0x30(%rbp),%rax
... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
pxor xmm0, xmm0
movaps [rbp+var_30], xmm0
movq [rbp+var_20], xmm0
lea rax, [rbp+var_30]
mov rdi, ... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rbx
long long v4; // rax
long long v5; // rax
int i; // [rsp+1Ch] [rbp-34h]
int j; // [rsp+1Ch] [rbp-34h]
__int128 v9; // [rsp+20h] [rbp-30h] BYREF
long long v10; // [rsp+30h] [rbp-20h]
unsigned long long v11; // [rsp... | 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
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x30],XMM0
MOVQ qword ptr [RBP + -0x20],XMM0
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL ... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
ulong uVar3;
int *piVar4;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_F... |
133 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l){
vector<int> third={};
int i;
for (i=0;i*3<l.size();i++)
third.push_back(l[i*3]);
sort(third.begin(),third.end());
vector<int> out={};
for (i=0;i<l.size();i++)
{
if (i%3==0) {out.push_back(third[i/3]);}
else out.push_back(l[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({1, 2, 3}) , func0({1, 2, 3})));
assert (issame(func0({5, 3,... | 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,%r12
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
mov (%rsi),%rdx
cmp %r... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 20h
mov rbp, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov [rsp+48h+src], 0
mov [rsp+48h+var_40], 0
mov [rsp+48h+var_38], 0
mov rdx, [rsi]
cmp ... | long long func0(long long a1, long long *a2)
{
long long v3; // rdx
unsigned long long v4; // r12
_DWORD *v5; // rdx
char *v6; // rsi
char *v7; // r14
char *v8; // r13
long long v9; // r12
int v10; // eax
unsigned long long v11; // rax
char *v12; // r12
int v13; // ecx
int *v14; // rax
int v1... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV RBP,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001013dc... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> *
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 *piVar2;
long lVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar7;
i... |
134 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l){
vector<int> third={};
int i;
for (i=0;i*3<l.size();i++)
third.push_back(l[i*3]);
sort(third.begin(),third.end());
vector<int> out={};
for (i=0;i<l.size();i++)
{
if (i%3==0) {out.push_back(third[i/3]);}
else out.push_back(l[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({1, 2, 3}) , func0({1, 2, 3})));
assert (issame(func0({5, 3,... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x20,%rsp
mov (%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
cmp %r... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 28h
mov rdx, [rsi]
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
movaps xmmword ptr [rsp+58h+src], xmm0
mov [rsp+58h+... | long long func0(long long a1, long long *a2)
{
long long v3; // rdx
int *v4; // rax
unsigned long long v5; // r12
int *v6; // r14
int *v7; // r12
long long v8; // rdx
long long v9; // r13
unsigned long long v10; // rax
int *v11; // r13
int v12; // ecx
int v13; // edx
int *v14; // rax
int *v15... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x28
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x00102147... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> *
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 *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
_Iter_less_iter extraout_EDX;... |
135 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l){
vector<int> third={};
int i;
for (i=0;i*3<l.size();i++)
third.push_back(l[i*3]);
sort(third.begin(),third.end());
vector<int> out={};
for (i=0;i<l.size();i++)
{
if (i%3==0) {out.push_back(third[i/3]);}
else out.push_back(l[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({1, 2, 3}) , func0({1, 2, 3})));
assert (issame(func0({5, 3,... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x38,%rsp
mov (%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movaps %xmm0,0x10(%rsp)
movq $0x0,0x20(%... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
mov rbx, rdi
sub rsp, 38h
mov rsi, [rsi+8]
mov rdx, [r12]
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
movaps xmmword ptr [rsp+68h+src], x... | long long func0(long long a1, long long *a2)
{
long long v3; // rsi
long long v4; // rdx
int *v5; // rax
unsigned long long v6; // rbp
int *v7; // r13
int *v8; // rbp
int *v9; // r15
long long v10; // r14
unsigned long long v11; // rdx
int *v12; // r14
int v13; // ecx
int *v14; // rsi
int v15... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x38
MOV RSI,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [R12]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
CMP RD... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> *
func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,int param_10,
int4 param_11,int8 param_12,int8 param_13)
{
int iVar1;
int *piVar2;
int *piVar3;
... |
136 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l){
vector<int> out={};
for (int i=0;i<l.size();i++)
if (find(out.begin(),out.end(),l[i])==out.end())
out.push_back(l[i]);
sort(out.begin(),out.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({5, 3, 5, 2, 3, 3, 9, 0, 123}) , {0, 2, 3, 5, 9, 123}));
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x30,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
movq $0x0,0x10(%r... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 30h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
pxor xmm0, xmm0
movups xmmword ptr [rax], xmm0
movq qword ptr [rax+... | long long func0(long long a1, long long a2)
{
long long v2; // r12
long long v3; // rbx
long long v4; // rax
long long v5; // rax
long long v6; // rbx
long long v7; // rax
int i; // [rsp+14h] [rbp-2Ch]
long long v10; // [rsp+18h] [rbp-28h] BYREF
_QWORD v11[4]; // [rsp+20h] [rbp-20h] BYREF
v11[1] =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword ptr [RAX + 0x10],XMM0
MOV RAX... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int *piVar4;
int4 extraout_var;
ulong uVar5;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
vector<int,std:... |
137 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l){
vector<int> out={};
for (int i=0;i<l.size();i++)
if (find(out.begin(),out.end(),l[i])==out.end())
out.push_back(l[i]);
sort(out.begin(),out.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({5, 3, 5, 2, 3, 3, 9, 0, 123}) , {0, 2, 3, 5, 9, 123}));
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
je 13a3 <_Z5func0St6vectorIiSaIiEE+0x123>
mov %rsi,%r12
mov $0x0,%eb... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp [rsi+8], rdx
jz loc_13B0
mov r12, rsi
mov ebx, 0
jmp short loc_12E4
loc_12BA:
a... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v3; // rdx
long long v5; // rbx
char *v6; // rax
char *v7; // rsi
int *v8; // rdi
long long v9; // rcx
int v10; // edx
char *v11; // rcx
signed long long v12; // rax
char *v13; // rbx
char *v14; // r13
int v15; // eax
unsigned long long v16... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001013b0
MOV R12,RSI
MOV EBX,0x0
JMP 0x001012e4
LAB_001012ba:
ADD RAX,0x4
LAB_001012be:
CMP RSI,RAX
JZ 0x00101... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int iVar1;
int iVar2;
int *piVar3;
uint uVar4;
int *piVar5;
_Iter_less_iter in_ECX;
long lVar6;
int *piVar7;
_Iter_less_iter extraout_EDX;
ulong uVar8;
long *in_RSI;
int *piVar9;
__n... |
138 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l){
vector<int> out={};
for (int i=0;i<l.size();i++)
if (find(out.begin(),out.end(),l[i])==out.end())
out.push_back(l[i]);
sort(out.begin(),out.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({5, 3, 5, 2, 3, 3, 9, 0, 123}) , {0, 2, 3, 5, 9, 123}));
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rsi
cmp 0x8(%rbp),%rsi
je 15bc <_Z5func0St6vectorIiSaIiEE+0x13c>
xor %ebx,%ebx
xor... | _Z5func0St6vectorIiSaIiEE:
endbr64
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rdi, [rsi]
cmp rdi, [rsi+8]
jz loc_18F4
mov rbp, rsi
xor ebx, ebx
xor r13d, r13d
xor r14d, r1... | long long func0(long long a1, long long *a2)
{
long long v3; // rdi
unsigned long long v5; // rbx
char *v6; // r13
char *v7; // r14
int *v8; // rsi
long long v9; // rcx
long long v10; // rdx
int v11; // edx
char *v12; // rax
long long v13; // rdx
unsigned long long v14; // rax
char *v15; // rbx... | func0:
ENDBR64
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,qword ptr [RSI]
CMP RDI,qword ptr [RSI + 0x8]
JZ 0x001018f4
MOV RBP,RSI
XOR EBX,EBX
XOR R13D,R13D
XOR R14D,R14D
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001017f0:
MOV RC... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int *piVar1;
int *piVar2;
_Iter_less_iter _Var3;
long lVar4;
int *piVar5;
_Iter_less_iter extraout_EDX;
int iVar6;
int iVar7;
long lVar8;
ulong uVar9;
int *piVar10;
long *in_RSI;
__n... |
139 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l){
vector<int> out={};
for (int i=0;i<l.size();i++)
if (find(out.begin(),out.end(),l[i])==out.end())
out.push_back(l[i]);
sort(out.begin(),out.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({5, 3, 5, 2, 3, 3, 9, 0, 123}) , {0, 2, 3, 5, 9, 123}));
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x8,%rsp
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rsi
mov 0x8(%rbp),%rdi
cmp %rdi,%rsi
je 15fc <_Z5func0S... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rdi, [rsi+8]
mov rsi, [rsi]
cmp rsi, rdi
jz loc_18AC
xor ... | long long func0(long long a1, long long *a2)
{
long long v4; // rdi
long long v5; // rsi
unsigned long long v6; // rbx
char *v7; // r13
char *v8; // r14
int *v9; // r8
long long v10; // rcx
long long v11; // rdx
int v12; // edx
char *v13; // rax
char *v14; // rbx
unsigned long long v15; // rdx
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDI,qword ptr [RSI + 0x8]
MOV RSI,qword ptr [RSI]
CMP RSI,RDI
JZ 0x001018ac
XOR EBX,EBX
XOR R13D,R13D
XOR R14D,R14D
NOP
LAB_00101740:
M... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int *piVar1;
_Iter_less_iter _Var2;
long lVar3;
int *piVar4;
int iVar5;
int iVar6;
size_t sVar7;
ulong uVar8;
int *piVar9;
long *in_RSI;
long lVar10;
int4 in_register_0000003c;
vecto... |
140 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| float func0(vector<float> l){
float max=-10000;
for (int i=0;i<l.size();i++)
if (max<l[i]) max=l[i];
return max;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({1, 2, 3})- 3)<1e-4);
assert (abs(func0({5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10})- 124)<1e-4);
assert (abs(func0({5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10})- 123)<1e-4);
}
| O0 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movss 0x1f0e(%rip),%xmm0
movss %xmm0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1734 <_ZNKSt6v... | _Z5func0St6vectorIfSaIfEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
movss xmm0, cs:dword_3130
movss [rbp+var_18], xmm0
mov [rbp+var_14], 0
jmp short loc_12B6
loc_1270:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov... | float func0(long long a1)
{
float v2; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = -10000.0;
for ( i = 0; i < (unsigned long long)std::vector<float>::size(a1); ++i )
{
if ( *(float *)std::vector<float>::operator[](a1, i) > v2 )
v2 = *(float *)std::vector<float>::operator[](a1, i);
}... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOVSS XMM0,dword ptr [0x00103130]
MOVSS dword ptr [RBP + -0x18],XMM0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012b6
LAB_00101270:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,R... | /* func0(std::vector<float, std::allocator<float> >) */
float func0(vector param_1)
{
float *pfVar1;
ulong uVar2;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
int4 local_20;
int4 local_1c;
this = (vector<float,std::allocator<float>> *)CONCAT44(in_register_0000003c,param_1);
... |
141 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| float func0(vector<float> l){
float max=-10000;
for (int i=0;i<l.size();i++)
if (max<l[i]) max=l[i];
return max;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({1, 2, 3})- 3)<1e-4);
assert (abs(func0({5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10})- 124)<1e-4);
assert (abs(func0({5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10})- 123)<1e-4);
}
| O1 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
mov %rdx,%rax
shr $0x2,%rax
je 1243 <_Z5func0St6vectorIfSaIfEE+0x3a>
mov %rcx,%rax
add %rcx,%rdx
movss 0xf02(%rip),%xmm0
movss (%rax),%xmm1
maxss %xmm0,%xmm1
movaps %xmm1,%xmm0
add ... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_1246
mov eax, 0
movss xmm0, cs:dword_2004
loc_1230:
movss xmm1, dword ptr [rdx+rax*4]
maxss xmm1, xmm0
movaps xmm0, xmm1
add rax, 1
cmp rax, r... | float func0(_QWORD *a1)
{
unsigned long long v1; // rax
float result; // xmm0_4
if ( a1[1] == *a1 )
return -10000.0;
v1 = 0LL;
result = -10000.0;
do
result = fmaxf(*(float *)(*a1 + 4 * v1++), result);
while ( v1 < (long long)(a1[1] - *a1) >> 2 );
return result;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RCX,RAX
SUB RCX,RDX
SAR RCX,0x2
CMP RAX,RDX
JZ 0x00101246
MOV EAX,0x0
MOVSS XMM0,dword ptr [0x00102004]
LAB_00101230:
MOVSS XMM1,dword ptr [RDX + RAX*0x4]
MAXSS XMM1,XMM0
MOVAPS XMM0,XMM1
ADD RAX,0x1
CMP RAX,RCX
JC 0x00101230
RET
LAB_00101246:
MOV... | /* func0(std::vector<float, std::allocator<float> >) */
float func0(vector param_1)
{
float fVar1;
long lVar2;
long lVar3;
ulong uVar4;
int4 in_register_0000003c;
float fVar5;
lVar2 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
i... |
142 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| float func0(vector<float> l){
float max=-10000;
for (int i=0;i<l.size();i++)
if (max<l[i]) max=l[i];
return max;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({1, 2, 3})- 3)<1e-4);
assert (abs(func0({5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10})- 124)<1e-4);
assert (abs(func0({5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10})- 123)<1e-4);
}
| O2 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
sub %rax,%rdx
mov %rdx,%rcx
shr $0x2,%rcx
je 1530 <_Z5func0St6vectorIfSaIfEE+0x40>
movss 0xc21(%rip),%xmm0
add %rax,%rdx
nopw 0x0(%rax,%rax,1)
movss (%rax),%xmm1
add $0x4,%rax
maxss %xmm0,%xmm1
mo... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_1430
movss xmm0, cs:dword_2004
xor eax, eax
nop dword ptr [rax+00h]
loc_1418:
movss xmm1, dword ptr [rdx+rax*4]
add rax, 1
maxss xmm1, xmm0
mov... | float func0(_QWORD *a1)
{
float result; // xmm0_4
unsigned long long v2; // rax
float v3; // xmm1_4
if ( a1[1] == *a1 )
return -10000.0;
result = -10000.0;
v2 = 0LL;
do
{
v3 = *(float *)(*a1 + 4 * v2++);
result = fmaxf(v3, result);
}
while ( v2 < (long long)(a1[1] - *a1) >> 2 );
retu... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RCX,RAX
SUB RCX,RDX
SAR RCX,0x2
CMP RAX,RDX
JZ 0x00101430
MOVSS XMM0,dword ptr [0x00102004]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101418:
MOVSS XMM1,dword ptr [RDX + RAX*0x4]
ADD RAX,0x1
MAXSS XMM1,XMM0
MOVAPS XMM0,XMM1
CMP RAX,RCX
JC 0x00101418
R... | /* func0(std::vector<float, std::allocator<float> >) */
float func0(vector param_1)
{
float fVar1;
long lVar2;
long lVar3;
ulong uVar4;
int4 in_register_0000003c;
float fVar5;
lVar2 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
i... |
143 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| float func0(vector<float> l){
float max=-10000;
for (int i=0;i<l.size();i++)
if (max<l[i]) max=l[i];
return max;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({1, 2, 3})- 3)<1e-4);
assert (abs(func0({5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10})- 124)<1e-4);
assert (abs(func0({5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10})- 123)<1e-4);
}
| O3 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
sub %rax,%rdx
mov %rdx,%rcx
shr $0x2,%rcx
je 14f0 <_Z5func0St6vectorIfSaIfEE+0x40>
movss 0xc61(%rip),%xmm0
add %rax,%rdx
nopw 0x0(%rax,%rax,1)
movss (%rax),%xmm1
add $0x4,%rax
maxss %xmm0,%xmm1
mo... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_14F0
movss xmm0, cs:dword_2004
xor eax, eax
nop dword ptr [rax+00h]
loc_14D8:
movss xmm1, dword ptr [rdx+rax*4]
add rax, 1
maxss xmm1, xmm0
mov... | float func0(_QWORD *a1)
{
float result; // xmm0_4
unsigned long long v2; // rax
float v3; // xmm1_4
if ( a1[1] == *a1 )
return -10000.0;
result = -10000.0;
v2 = 0LL;
do
{
v3 = *(float *)(*a1 + 4 * v2++);
result = fmaxf(v3, result);
}
while ( v2 < (long long)(a1[1] - *a1) >> 2 );
retu... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RCX,RAX
SUB RCX,RDX
SAR RCX,0x2
CMP RAX,RDX
JZ 0x001014f0
MOVSS XMM0,dword ptr [0x00102004]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001014d8:
MOVSS XMM1,dword ptr [RDX + RAX*0x4]
ADD RAX,0x1
MAXSS XMM1,XMM0
MOVAPS XMM0,XMM1
CMP RAX,RCX
JC 0x001014d8
R... | /* func0(std::vector<float, std::allocator<float> >) */
float func0(vector param_1)
{
float fVar1;
long lVar2;
long lVar3;
ulong uVar4;
int4 in_register_0000003c;
float fVar5;
lVar2 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
i... |
144 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int count=0;
for (int i=0;i<n;i++)
if (i%11==0 or i%13==0)
{
int q=i;
while (q>0)
{
if (q%10==7) count+=1;
q=q/10;
}
}
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(50) == 0);
assert (func0(78) == 2);
assert (func0(79) == 3);
assert (func0(100) == 3);
assert (func0(200) == 6);
assert (func0(4000) == 192);
assert (func0(10000) == 639);
assert (func0(100000) == 8026);
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jge 1235 <_Z5func0i+0xec>
mov -0x8(%rbp),%ecx
movslq %ecx,%rax
imul $0x2e8ba2e9,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar %edx
mov %e... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp loc_1229
loc_1167:
mov ecx, [rbp+var_8]
movsxd rax, ecx
imul rax, 2E8BA2E9h
shr rax, 20h
mov edx, eax
sar edx, 1
mov eax, ecx
sar eax, 1Fh
sub edx, eax
mov ... | long long func0(int a1)
{
unsigned int v2; // [rsp+8h] [rbp-Ch]
int i; // [rsp+Ch] [rbp-8h]
int j; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 0; i < a1; ++i )
{
if ( !(i % 11) || !(i % 13) )
{
for ( j = i; j > 0; j /= 10 )
{
if ( j % 10 == 7 )
++v2;
}
}
}
r... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x00101229
LAB_00101167:
MOV ECX,dword ptr [RBP + -0x8]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x2e8ba2e9
SHR RAX,0x20
MOV EDX,EAX
SAR EDX,0x1
MOV EAX,ECX
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
SHL E... | /* func0(int) */
int func0(int param_1)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_10 < param_1; local_10 = local_10 + 1) {
if ((local_10 % 0xb == 0) || (local_10 % 0xd == 0)) {
for (local_c = local_10; 0 < local_c; local_c = local_c / 10) {
if ... |
145 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int count=0;
for (int i=0;i<n;i++)
if (i%11==0 or i%13==0)
{
int q=i;
while (q>0)
{
if (q%10==7) count+=1;
q=q/10;
}
}
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(50) == 0);
assert (func0(78) == 2);
assert (func0(79) == 3);
assert (func0(100) == 3);
assert (func0(200) == 6);
assert (func0(4000) == 192);
assert (func0(10000) == 639);
assert (func0(100000) == 8026);
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
jle 1204 <_Z5func0i+0xbb>
mov $0x0,%ecx
mov $0x0,%esi
jmp 116c <_Z5func0i+0x23>
add $0x1,%ecx
cmp %ecx,%edi
je 1209 <_Z5func0i+0xc0>
movslq %ecx,%rax
imul $0x2e8ba2e9,%rax,%rax
sar $0x21,%rax
mov %ecx,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax... | _Z5func0i:
endbr64
test edi, edi
jle loc_1200
mov ecx, 0
mov esi, 0
jmp short loc_11B6
loc_1161:
mov edx, eax
loc_1163:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov r8d, edx
sar r8d, 1Fh
sub eax, r8d
lea eax, [rax+rax*4]
add eax, eax
mov r8d, edx
sub r8... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
int v3; // edx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = 0;
v2 = 0;
do
{
if ( v1 == 11 * (v1 / 11) || v1 == 13 * (v1 / 13) )
{
v3 = v1;
if ( v1 > 0 )
{
while ( 1 )
... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101200
MOV ECX,0x0
MOV ESI,0x0
JMP 0x001011b6
LAB_00101161:
MOV EDX,EAX
LAB_00101163:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV R8D,EDX
SAR R8D,0x1f
SUB EAX,R8D
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
MOV R8D,EDX
SUB R8D,EAX
CMP R8D,0x7
SETZ AL
MOVZX EAX,AL
ADD ESI,EAX
MOVS... | /* func0(int) */
int func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_1 < 1) {
iVar4 = 0;
}
else {
iVar2 = 0;
iVar4 = 0;
do {
if (((iVar2 == (iVar2 / 0xb) * 0xb) || (iVar2 == (iVar2 / 0xd) * 0xd)) &&
(iVar3 = iVar2, 0 < iVar2)) {
do {
... |
146 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int count=0;
for (int i=0;i<n;i++)
if (i%11==0 or i%13==0)
{
int q=i;
while (q>0)
{
if (q%10==7) count+=1;
q=q/10;
}
}
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(50) == 0);
assert (func0(78) == 2);
assert (func0(79) == 3);
assert (func0(100) == 3);
assert (func0(200) == 6);
assert (func0(4000) == 192);
assert (func0(10000) == 639);
assert (func0(100000) == 8026);
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
jle 167c <_Z5func0i+0x7c>
xor %esi,%esi
xor %r8d,%r8d
mov $0xcccccccd,%r9d
jmp 162c <_Z5func0i+0x2c>
nopl (%rax)
imul $0xc4ec4ec5,%esi,%eax
cmp $0x13b13b13,%eax
jbe 1639 <_Z5func0i+0x39>
add $0x1,%esi
cmp %esi,%edi
je 1678 <_Z5func0i+0x78>
imul $... | _Z5func0i:
endbr64
xor r8d, r8d
xor esi, esi
mov r9d, 0CCCCCCCDh
test edi, edi
jle short loc_135B
nop dword ptr [rax+rax+00h]
loc_1308:
add r8d, 1
cmp edi, r8d
jz short loc_135B
loc_1311:
imul eax, r8d, 0BA2E8BA3h
cmp eax, 1745D174h
jbe short loc_132D
imul eax, r8d, 0C4... | long long func0(int a1)
{
unsigned int v1; // r8d
unsigned int v2; // esi
unsigned int v3; // edx
v1 = 0;
v2 = 0;
if ( a1 > 0 )
{
while ( a1 != ++v1 )
{
while ( -1171354717 * v1 <= 0x1745D174 || -991146299 * v1 <= 0x13B13B13 )
{
v3 = v1;
do
{
v2 += v... | func0:
ENDBR64
XOR R8D,R8D
XOR ESI,ESI
MOV R9D,0xcccccccd
TEST EDI,EDI
JLE 0x0010135b
NOP dword ptr [RAX + RAX*0x1]
LAB_00101308:
ADD R8D,0x1
CMP EDI,R8D
JZ 0x0010135b
LAB_00101311:
IMUL EAX,R8D,-0x45d1745d
CMP EAX,0x1745d174
JBE 0x0010132d
IMUL EAX,R8D,-0x3b13b13b
CMP EAX,0x13b13b13
JA 0x00101308
LAB_0010132d:
MOV EDX... | /* func0(int) */
int func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
uVar3 = 0;
iVar2 = 0;
if (0 < param_1) {
while (uVar3 = uVar3 + 1, param_1 != uVar3) {
while ((uVar1 = uVar3, uVar3 * -0x45d1745d < 0x1745d175 || (uVar3 * -0x3b13b13b < 0x13b13b14))
) {
do {
... |
147 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int count=0;
for (int i=0;i<n;i++)
if (i%11==0 or i%13==0)
{
int q=i;
while (q>0)
{
if (q%10==7) count+=1;
q=q/10;
}
}
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(50) == 0);
assert (func0(78) == 2);
assert (func0(79) == 3);
assert (func0(100) == 3);
assert (func0(200) == 6);
assert (func0(4000) == 192);
assert (func0(10000) == 639);
assert (func0(100000) == 8026);
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
jle 167c <_Z5func0i+0x7c>
mov $0x1,%esi
xor %r8d,%r8d
mov $0xcccccccd,%r9d
cmp $0x1,%edi
jne 1634 <_Z5func0i+0x34>
jmp 1678 <_Z5func0i+0x78>
nopl (%rax)
imul $0xc4ec4ec5,%esi,%eax
cmp $0x13b13b13,%eax
jbe 1641 <_Z5func0i+0x41>
add $0x1,%esi
cmp %... | _Z5func0i:
endbr64
xor r8d, r8d
xor esi, esi
mov r9d, 0CCCCCCCDh
test edi, edi
jle short loc_168B
nop dword ptr [rax+rax+00h]
loc_1638:
add r8d, 1
cmp edi, r8d
jz short loc_168B
loc_1641:
imul eax, r8d, 0BA2E8BA3h
cmp eax, 1745D174h
jbe short loc_165D
imul eax, r8d, 0C4... | long long func0(int a1)
{
unsigned int v1; // r8d
unsigned int v2; // esi
unsigned int v3; // edx
v1 = 0;
v2 = 0;
if ( a1 > 0 )
{
while ( a1 != ++v1 )
{
while ( -1171354717 * v1 <= 0x1745D174 || -991146299 * v1 <= 0x13B13B13 )
{
v3 = v1;
do
{
v2 += v... | func0:
ENDBR64
XOR R8D,R8D
XOR ESI,ESI
MOV R9D,0xcccccccd
TEST EDI,EDI
JLE 0x0010168b
NOP dword ptr [RAX + RAX*0x1]
LAB_00101638:
ADD R8D,0x1
CMP EDI,R8D
JZ 0x0010168b
LAB_00101641:
IMUL EAX,R8D,-0x45d1745d
CMP EAX,0x1745d174
JBE 0x0010165d
IMUL EAX,R8D,-0x3b13b13b
CMP EAX,0x13b13b13
JA 0x00101638
LAB_0010165d:
MOV EDX... | /* func0(int) */
int func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
uVar3 = 0;
iVar2 = 0;
if (0 < param_1) {
while (uVar3 = uVar3 + 1, param_1 != uVar3) {
while ((uVar1 = uVar3, uVar3 * -0x45d1745d < 0x1745d175 || (uVar3 * -0x3b13b13b < 0x13b13b14))
) {
do {
... |
148 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<float> func0(vector<float> l){
vector<float> out={};
vector<float> even={};
for (int i=0;i*2<l.size();i++)
even.push_back(l[i*2]);
sort(even.begin(),even.end());
for (int i=0;i<l.size();i++)
{
if (i%2==0) out.push_back(even[i/2]);
if (i%2==1) out.push_back(l[i]);
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({1, 2, 3}), {1, 2, 3}));
assert (issame(func0({... | O0 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
movq $0x0,0x10(%rax)
mov ... | _Z5func0St6vectorIfSaIfEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
pxor xmm0, xmm0
movups xmmword ptr [rax], xmm0
movq qword ptr [rax+10h], xmm0
m... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rbx
long long v4; // rax
long long v5; // rax
long long v6; // rax
int i; // [rsp+18h] [rbp-38h]
int j; // [rsp+1Ch] [rbp-34h]
__int128 v10; // [rsp+20h] [rbp-30h] BYREF
long long v11; // [rsp+30h] [rbp-20h]
unsigne... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword ptr [RAX + 0x10],XMM0
MOV RAX,qword pt... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
ulong uVar3;
float *pfVar4;
vector<float,std::allocator<float>> *in_RSI;
int4 in_register_0000003c;
vector<float,std::allocator<float>> ... |
149 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<float> func0(vector<float> l){
vector<float> out={};
vector<float> even={};
for (int i=0;i*2<l.size();i++)
even.push_back(l[i*2]);
sort(even.begin(),even.end());
for (int i=0;i<l.size();i++)
{
if (i%2==0) out.push_back(even[i/2]);
if (i%2==1) out.push_back(l[i]);
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({1, 2, 3}), {1, 2, 3}));
assert (issame(func0({... | O1 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %rdi,%r13
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
movq $0x0,(%rsp)
movq ... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 20h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov [rsp+48h+src], 0
mov [rsp+48h+... | long long func0(long long a1, long long *a2)
{
long long v2; // rdx
unsigned long long v4; // r12
_DWORD *v5; // rdx
char *v6; // rsi
float *v7; // r14
float *v8; // r13
long long v9; // r12
int v10; // eax
unsigned long long v11; // rax
float *v12; // r12
float v13; // xmm1_4
float *v14; // ra... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> *
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)
{
float fVar1;
float fVar2;
float *pfVar3;
long lVar4;
float *pfVar5;
float *pfVar6;
... |
150 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<float> func0(vector<float> l){
vector<float> out={};
vector<float> even={};
for (int i=0;i*2<l.size();i++)
even.push_back(l[i*2]);
sort(even.begin(),even.end());
for (int i=0;i<l.size();i++)
{
if (i%2==0) out.push_back(even[i/2]);
if (i%2==1) out.push_back(l[i]);
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({1, 2, 3}), {1, 2, 3}));
assert (issame(func0({... | O2 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x20,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
movq $0x0,(%rsp)
mov... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
pxor xmm0, xmm0
mov rdx, [rsi]
mov qword ptr [rdi+... | long long func0(long long a1, long long *a2)
{
float *v2; // rax
long long v3; // rdx
float *v5; // r13
unsigned long long v6; // r12
long long v7; // rcx
float *v9; // r12
long long v10; // rdx
long long v11; // r14
unsigned long long v12; // rax
float *v13; // r14
float v14; // xmm1_4
float v... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
PXOR XMM0,XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RSP + 0x10],0x0
MOVAPS xm... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> *
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)
{
float fVar1;
float fVar2;
int8 uVar3;
float *pfVar4;
long lVar5;
float *pfVar6;
_I... |
151 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<float> func0(vector<float> l){
vector<float> out={};
vector<float> even={};
for (int i=0;i*2<l.size();i++)
even.push_back(l[i*2]);
sort(even.begin(),even.end());
for (int i=0;i<l.size();i++)
{
if (i%2==0) out.push_back(even[i/2]);
if (i%2==1) out.push_back(l[i]);
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({1, 2, 3}), {1, 2, 3}));
assert (issame(func0({... | O3 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rdx
movq $0x0,... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov r8, [rsi+8]
mov r14, [rsi]
pxor xmm0, xmm0
mov... | long long func0(long long a1, long long *a2)
{
long long v2; // r8
long long j; // r14
float *v5; // r13
float *v6; // rsi
unsigned long long v7; // rbp
float *v8; // rdx
float *v10; // rbp
long long v11; // r15
unsigned long long v12; // rdx
float *v13; // rcx
float *v14; // r15
float *v15; //... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV R8,qword ptr [RSI + 0x8]
MOV R14,qword ptr [RSI]
PXOR XMM0,XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV qword p... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> *
func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7,int1 param_8,int param_9,int8 param_10,
int8 param_11)
{
float fVar1;
float fVar2;
long lVar3;
int8 __src;
fl... |
152 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string encode_cyclic(string s){
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
x=s.substr(i*3,3);
if (x.length()==3) x=x.substr(1)+x[... | string func0(string s){
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
x=s.substr(i*3,3);
if (x.length()==3) x=x[2]+x.substr(0,2);
ou... | #undef NDEBUG
#include<assert.h>
int main(){
for (int i=0;i<100;i++)
{
int l=10+rand()%11;
string str="";
for (int j=0;j<l;j++)
{
char chr=97+rand()%26;
str+=chr;
}
string encoded_str = encode_cyclic(str);
assert (func0(encod... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x128,%rsp
mov %rdi,-0x128(%rbp)
mov %rsi,-0x130(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x130(%rbp),%rax
mov %rax,%rdi
callq 241... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 108h
mov [rbp+var_108], rdi
mov [rbp+var_110], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_110]
mov rdi, rax
call __ZNKSt7__cxx1112basic... | long long func0(long long a1, long long a2)
{
char *v2; // rax
int v3; // ebx
int i; // [rsp+18h] [rbp-F8h]
int v6; // [rsp+1Ch] [rbp-F4h]
int v7; // [rsp+28h] [rbp-E8h]
_BYTE v8[32]; // [rsp+30h] [rbp-E0h] BYREF
_BYTE v9[32]; // [rsp+50h] [rbp-C0h] BYREF
_BYTE v10[32]; // [rsp+70h] [rbp-A0h] BYREF
_... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x108
MOV qword ptr [RBP + -0x108],RDI
MOV qword ptr [RBP + -0x110],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x110]
MOV RDI,RAX
CALL 0x00102400
MOV dword ptr [RBP + -0xf4],EAX
MOV EAX,dword ptr [RBP + -0xf4... | /* func0(std::string) */
string * func0(string *param_1,ulong param_2)
{
code *pcVar1;
bool bVar2;
int iVar3;
long lVar4;
char *pcVar5;
long in_FS_OFFSET;
int local_100;
string local_e8 [32];
string local_c8 [32];
string local_a8 [32];
string local_88 [32];
string local_68 [32];
string local... |
153 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string encode_cyclic(string s){
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
x=s.substr(i*3,3);
if (x.length()==3) x=x.substr(1)+x[... | string func0(string s){
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
x=s.substr(i*3,3);
if (x.length()==3) x=x[2]+x.substr(0,2);
ou... | #undef NDEBUG
#include<assert.h>
int main(){
for (int i=0;i<100;i++)
{
int l=10+rand()%11;
string str="";
for (int j=0;j<l;j++)
{
char chr=97+rand()%26;
str+=chr;
}
string encoded_str = encode_cyclic(str);
assert (func0(encod... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xd0,%rsp
mov %rdi,%r14
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0xc8(%rsp)
xor %eax,%eax
mov 0x8(%rsi),%rcx
mov %ecx,%r13d
lea 0x10... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0F8h
mov [rsp+128h+var_110], rdi
mov rax, fs:28h
mov [rsp+128h+var_40], rax
xor eax, eax
mov rax, [rsi+8]
mov [rsp+128h+var_114], eax
lea ... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
unsigned long long v3; // rbx
char *v4; // rax
long long v5; // rcx
unsigned long long v6; // r12
unsigned long long v7; // rbp
_QWORD *v8; // r15
unsigned int v9; // edx
unsigned long long v10; // r8
char *v11; // rax
char *v12; // rcx
unsigned int v13; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xf8
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xe8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI + 0x8]
MOV dword ptr [RSP + 0x14],EAX
LEA RDX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x... | /* WARNING: Removing unreachable block (ram,0x00101cec) */
/* WARNING: Removing unreachable block (ram,0x00101ccf) */
/* func0(std::string) */
int8 * func0(int8 *param_1,long *param_2)
{
ulong *puVar1;
ulong *puVar2;
uint uVar3;
int8 *puVar4;
int8 uVar5;
long lVar6;
long lVar7;
ulong *puVar8;
ulong ... |
154 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string encode_cyclic(string s){
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
x=s.substr(i*3,3);
if (x.length()==3) x=x.substr(1)+x[... | string func0(string s){
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
x=s.substr(i*3,3);
if (x.length()==3) x=x[2]+x.substr(0,2);
ou... | #undef NDEBUG
#include<assert.h>
int main(){
for (int i=0;i<100;i++)
{
int l=10+rand()%11;
string str="";
for (int j=0;j<l;j++)
{
char chr=97+rand()%26;
str+=chr;
}
string encoded_str = encode_cyclic(str);
assert (func0(encod... | 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
xor %r12d,%r12d
push %rbp
push %rbx
sub $0x118,%rsp
mov 0x8(%rsi),%rcx
mov %rdi,0x18(%rsp)
lea 0xd0(%rsp),%rbx
lea 0x90(%rsp),%r15
lea ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 148h
mov rcx, [rsi+8]
mov [rsp+178h+var_138], rdi
mov rax, fs:28h
mov [rsp+178h+var_40], rax
xor eax, eax
lea rax, [rsp+178h+var_108]
mov ... | void ** func0(void **a1, long long *a2)
{
unsigned long long v2; // rcx
unsigned long long v4; // rbp
unsigned long long v5; // r13
long long *v6; // rdi
long long v7; // rdx
__m128 v8; // xmm0
long long v9; // rdx
long long v10; // rsi
unsigned long long v11; // rcx
long long v12; // rsi
long lon... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x148
MOV RCX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x40],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x138],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x70]
MOV dword ptr [RSP + 0x24],ECX
MOV qword ptr [RSP + 0x60],RAX
LEA RAX,[RSP + 0x80]
... | /* WARNING: Removing unreachable block (ram,0x0010255c) */
/* WARNING: Removing unreachable block (ram,0x0010253c) */
/* WARNING: Restarted to delay deadcode elimination for space: stack */
/* func0(std::string) */
int8 * func0(int8 *param_1,long *param_2)
{
ulong *puVar1;
ulong *puVar2;
int8 *puVar3;
int iVa... |
155 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string encode_cyclic(string s){
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
x=s.substr(i*3,3);
if (x.length()==3) x=x.substr(1)+x[... | string func0(string s){
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
int l=s.length();
int num=(l+2)/3;
string x,output;
int i;
for (i=0;i*3<l;i++)
{
x=s.substr(i*3,3);
if (x.length()==3) x=x[2]+x.substr(0,2);
ou... | #undef NDEBUG
#include<assert.h>
int main(){
for (int i=0;i<100;i++)
{
int l=10+rand()%11;
string str="";
for (int j=0;j<l;j++)
{
char chr=97+rand()%26;
str+=chr;
}
string encoded_str = encode_cyclic(str);
assert (func0(encod... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
xor %r13d,%r13d
push %r12
push %rbp
push %rbx
sub $0x138,%rsp
mov 0x8(%rsi),%rcx
mov %rdi,0x28(%rsp)
lea 0x70(%rsp),%rax
lea 0xf0(%rsp),%rbp
mov %rsi,0x8(%rsp)
m... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 148h
mov rcx, [rsi+8]
mov [rsp+178h+var_138], rdi
mov rax, fs:28h
mov [rsp+178h+var_40], rax
xor eax, eax
lea rax, [rsp+178h+var_108]
mov ... | void ** func0(void **a1, long long *a2)
{
unsigned long long v2; // rcx
unsigned long long v4; // r14
long long v5; // rsi
unsigned long long v6; // rcx
long long v7; // rax
__int8 *v8; // rsi
unsigned int v9; // edx
long long v10; // rcx
long long *v11; // rax
long long *v12; // rcx
__m128i v13; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x148
MOV RCX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x40],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x138],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x70]
MOV dword ptr [RSP + 0x24],ECX
MOV qword ptr [RSP + 0x68],RAX
LEA RAX,[RSP + 0x80]
... | /* WARNING: Removing unreachable block (ram,0x0010276c) */
/* WARNING: Removing unreachable block (ram,0x0010274c) */
/* WARNING: Restarted to delay deadcode elimination for space: stack */
/* func0(std::string) */
int8 * func0(int8 *param_1,long *param_2)
{
ulong *puVar1;
ulong *puVar2;
ulong uVar3;
int8 *pu... |
156 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f1,f2,m;
f1=1;f2=2;
int count=0;
while (count<n)
{
f1=f1+f2;
m=f1;f1=f2;f2=m;
bool isprime=true;
for (int w=2;w*w<=f1;w++)
if (f1%w==0)
{
isprime=false; break;
}
if (isprime) count+=1;
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 2);
assert (func0(2) == 3);
assert (func0(3) == 5);
assert (func0(4) == 13);
assert (func0(5) == 89);
assert (func0(6) == 233);
assert (func0(7) == 1597);
assert (func0(8) == 28657);
assert (func0(9) == 514229);
as... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
movl $0x1,-0x14(%rbp)
movl $0x2,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x24(%rbp),%eax
jge 11cf <_Z5func0i+0x86>
mov -0x10(%rbp),%eax
add %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
mov ... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov [rbp+var_14], 1
mov [rbp+var_10], 2
mov [rbp+var_C], 0
jmp short loc_11C9
loc_116B:
mov eax, [rbp+var_10]
add [rbp+var_14], eax
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
mov eax, [rbp+var_10]
mov [rbp+... | long long func0(int a1)
{
char v2; // [rsp+Fh] [rbp-15h]
int v3; // [rsp+10h] [rbp-14h]
int v4; // [rsp+14h] [rbp-10h]
int v5; // [rsp+18h] [rbp-Ch]
int i; // [rsp+1Ch] [rbp-8h]
int v7; // [rsp+20h] [rbp-4h]
v3 = 1;
v4 = 2;
v5 = 0;
do
{
if ( v5 >= a1 )
BUG();
v7 = v4 + v3;
v3 =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x14],0x1
MOV dword ptr [RBP + -0x10],0x2
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011c9
LAB_0010116b:
MOV EAX,dword ptr [RBP + -0x10]
ADD dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
M... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
code *pcVar2;
bool bVar3;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
local_1c = 1;
local_18 = 2;
local_14 = 0;
iVar1 = local_18;
do {
local_18 = iVar1;
if (param_1 <= local_14) {
/* WARNING: Do... |
157 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f1,f2,m;
f1=1;f2=2;
int count=0;
while (count<n)
{
f1=f1+f2;
m=f1;f1=f2;f2=m;
bool isprime=true;
for (int w=2;w*w<=f1;w++)
if (f1%w==0)
{
isprime=false; break;
}
if (isprime) count+=1;
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 2);
assert (func0(2) == 3);
assert (func0(3) == 5);
assert (func0(4) == 13);
assert (func0(5) == 89);
assert (func0(6) == 233);
assert (func0(7) == 1597);
assert (func0(8) == 28657);
assert (func0(9) == 514229);
as... | O1 | cpp | func0(int):
endbr64
mov $0x0,%r9d
mov $0x2,%esi
mov $0x1,%eax
jmp 116d <_Z5func0i+0x24>
add $0x1,%r9d
cmp %r9d,%edi
je 1198 <_Z5func0i+0x4f>
mov %esi,%eax
mov %r8d,%esi
lea (%rax,%rsi,1),%r8d
cmp $0x3,%esi
jle 115f <_Z5func0i+0x16>
test $0x1,%sil
je 1168 <_Z5func0i+0x1f>
mov ... | _Z5func0i:
endbr64
mov r9d, 0
mov esi, 2
mov eax, 1
jmp short loc_116D
loc_115F:
add r9d, 1
cmp edi, r9d
jz short loc_1198
loc_1168:
mov eax, esi
mov esi, r8d
loc_116D:
lea r8d, [rax+rsi]
cmp esi, 3
jle short loc_115F
test sil, 1
jz short loc_1168
mov ecx, 2
... | long long func0(int a1)
{
int v1; // r9d
int v2; // esi
int v3; // eax
int v4; // r8d
int v5; // ecx
v1 = 0;
v2 = 2;
v3 = 1;
while ( 1 )
{
v4 = v3 + v2;
if ( v2 <= 3 )
break;
if ( (v2 & 1) != 0 )
{
v5 = 2;
do
{
++v5;
if ( v5 * v5 > v2 )
... | func0:
ENDBR64
MOV R9D,0x0
MOV ESI,0x2
MOV EAX,0x1
JMP 0x0010116d
LAB_0010115f:
ADD R9D,0x1
CMP EDI,R9D
JZ 0x00101198
LAB_00101168:
MOV EAX,ESI
MOV ESI,R8D
LAB_0010116d:
LEA R8D,[RAX + RSI*0x1]
CMP ESI,0x3
JLE 0x0010115f
TEST SIL,0x1
JZ 0x00101168
MOV ECX,0x2
LAB_00101181:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,E... | /* func0(int) */
uint func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
uint uVar4;
int iVar5;
iVar5 = 0;
uVar4 = 2;
uVar1 = 1;
do {
do {
while (uVar3 = uVar4, uVar4 = uVar1 + uVar3, uVar1 = uVar3, (int)uVar3 < 4) {
LAB_0010115f:
iVar5 = iVar5 + 1;
if (param_1 == i... |
158 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f1,f2,m;
f1=1;f2=2;
int count=0;
while (count<n)
{
f1=f1+f2;
m=f1;f1=f2;f2=m;
bool isprime=true;
for (int w=2;w*w<=f1;w++)
if (f1%w==0)
{
isprime=false; break;
}
if (isprime) count+=1;
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 2);
assert (func0(2) == 3);
assert (func0(3) == 5);
assert (func0(4) == 13);
assert (func0(5) == 89);
assert (func0(6) == 233);
assert (func0(7) == 1597);
assert (func0(8) == 28657);
assert (func0(9) == 514229);
as... | O2 | cpp | func0(int):
endbr64
xor %r9d,%r9d
mov $0x2,%r8d
mov $0x1,%eax
nopw 0x0(%rax,%rax,1)
lea (%rax,%r8,1),%esi
cmp $0x3,%r8d
jle 1697 <_Z5func0i+0x47>
test $0x1,%r8b
je 16a0 <_Z5func0i+0x50>
mov $0x2,%ecx
jmp 168a <_Z5func0i+0x3a>
mov %r8d,%eax
cltd
idiv %ecx
test %edx,%edx
je 16a0... | _Z5func0i:
endbr64
xor r9d, r9d
mov esi, 2
mov eax, 1
nop dword ptr [rax+00000000h]
loc_1378:
lea r8d, [rax+rsi]
cmp esi, 3
jle short loc_13A5
test sil, 1
jz short loc_13AE
mov ecx, 2
jmp short loc_1399
loc_1390:
mov eax, esi
cdq
idiv ecx
test edx, edx
jz short... | long long func0(int a1)
{
int v1; // r9d
int v2; // esi
int v3; // eax
int v4; // r8d
int v5; // ecx
v1 = 0;
v2 = 2;
v3 = 1;
while ( 1 )
{
v4 = v3 + v2;
if ( v2 > 3 )
{
if ( (v2 & 1) == 0 )
goto LABEL_8;
v5 = 2;
while ( 1 )
{
++v5;
if ( v... | func0:
ENDBR64
XOR R9D,R9D
MOV ESI,0x2
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101378:
LEA R8D,[RAX + RSI*0x1]
CMP ESI,0x3
JLE 0x001013a5
TEST SIL,0x1
JZ 0x001013ae
MOV ECX,0x2
JMP 0x00101399
LAB_00101390:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001013ae
LAB_00101399:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
J... | /* func0(int) */
uint func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
uint uVar4;
int iVar5;
iVar5 = 0;
uVar1 = 1;
uVar4 = 2;
do {
do {
while (uVar3 = uVar4, uVar4 = uVar1 + uVar3, uVar1 = uVar3, (int)uVar3 < 4) {
LAB_001013a5:
iVar5 = iVar5 + 1;
if (param_1 == i... |
159 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f1,f2,m;
f1=1;f2=2;
int count=0;
while (count<n)
{
f1=f1+f2;
m=f1;f1=f2;f2=m;
bool isprime=true;
for (int w=2;w*w<=f1;w++)
if (f1%w==0)
{
isprime=false; break;
}
if (isprime) count+=1;
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 2);
assert (func0(2) == 3);
assert (func0(3) == 5);
assert (func0(4) == 13);
assert (func0(5) == 89);
assert (func0(6) == 233);
assert (func0(7) == 1597);
assert (func0(8) == 28657);
assert (func0(9) == 514229);
as... | O3 | cpp | func0(int):
endbr64
xor %r9d,%r9d
mov $0x2,%r8d
mov $0x1,%eax
nopw 0x0(%rax,%rax,1)
lea (%rax,%r8,1),%esi
cmp $0x3,%r8d
jle 1697 <_Z5func0i+0x47>
test $0x1,%r8b
je 16a0 <_Z5func0i+0x50>
mov $0x2,%ecx
jmp 168a <_Z5func0i+0x3a>
mov %r8d,%eax
cltd
idiv %ecx
test %edx,%edx
je 16a0... | _Z5func0i:
endbr64
xor r9d, r9d
mov esi, 2
mov eax, 1
nop dword ptr [rax+00000000h]
loc_15E8:
lea r8d, [rax+rsi]
cmp esi, 3
jle short loc_1615
test sil, 1
jz short loc_161E
mov ecx, 2
jmp short loc_1609
loc_1600:
mov eax, esi
cdq
idiv ecx
test edx, edx
jz short... | long long func0(int a1)
{
int v1; // r9d
int v2; // esi
int v3; // eax
int v4; // r8d
int v5; // ecx
v1 = 0;
v2 = 2;
v3 = 1;
while ( 1 )
{
v4 = v3 + v2;
if ( v2 > 3 )
{
if ( (v2 & 1) == 0 )
goto LABEL_8;
v5 = 2;
while ( 1 )
{
++v5;
if ( v... | func0:
ENDBR64
XOR R9D,R9D
MOV ESI,0x2
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_001015e8:
LEA R8D,[RAX + RSI*0x1]
CMP ESI,0x3
JLE 0x00101615
TEST SIL,0x1
JZ 0x0010161e
MOV ECX,0x2
JMP 0x00101609
LAB_00101600:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x0010161e
LAB_00101609:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
J... | /* func0(int) */
uint func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
uint uVar4;
int iVar5;
iVar5 = 0;
uVar1 = 1;
uVar4 = 2;
do {
do {
while (uVar3 = uVar4, uVar4 = uVar1 + uVar3, uVar1 = uVar3, (int)uVar3 < 4) {
LAB_00101615:
iVar5 = iVar5 + 1;
if (param_1 == i... |
160 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(vector<int> l){
for (int i=0;i<l.size();i++)
for (int j=i+1;j<l.size();j++)
for (int k=j+1;k<l.size();k++)
if (l[i]+l[j]+l[k]==0) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 3, 5, 0}) == false);
assert (func0({1, 3, 5, -1}) == false);
assert (func0({1, 3, -2, 1}) == true);
assert (func0({1, 2, 3, 7}) == false);
assert (func0({1, 2, 5, 7}) == false);
assert (func0({2, 4, -5, 3, 9, 7}) == true);
asser... | 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,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1afa <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,%rbx
setb %al
test ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_1C], 0
jmp loc_1320
loc_1266:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_18], eax
jmp loc_12FC
loc_1274:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+va... | long long func0(long long a1)
{
int v1; // ebx
int v2; // ebx
int i; // [rsp+14h] [rbp-1Ch]
int j; // [rsp+18h] [rbp-18h]
int k; // [rsp+1Ch] [rbp-14h]
for ( i = 0; i < (unsigned long long)std::vector<int>::size(a1); ++i )
{
for ( j = i + 1; j < (unsigned long long)std::vector<int>::size(a1); ++j )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101320
LAB_00101266:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
JMP 0x001012fc
LAB_00101274:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP +... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int iVar1;
int iVar2;
int *piVar3;
ulong uVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int local_24;
int local_20;
int local_1c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_regi... |
161 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(vector<int> l){
for (int i=0;i<l.size();i++)
for (int j=i+1;j<l.size();j++)
for (int k=j+1;k<l.size();k++)
if (l[i]+l[j]+l[k]==0) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 3, 5, 0}) == false);
assert (func0({1, 3, 5, -1}) == false);
assert (func0({1, 3, -2, 1}) == true);
assert (func0({1, 2, 3, 7}) == false);
assert (func0({1, 2, 5, 7}) == false);
assert (func0({2, 4, -5, 3, 9, 7}) == true);
asser... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rax
sub %rdx,%rax
sar $0x2,%rax
mov %rax,%rsi
je 1274 <_Z5func0St6vectorIiSaIiEE+0x6b>
mov $0x1,%r8d
mov $0x0,%r9d
mov %r8,%rdi
cmp %rsi,%r8
jae 125c <_Z5func0St6vectorIiSaIiEE+0x53>
add $0x1,%rdi
... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rsi, rax
sub rsi, rdx
sar rsi, 2
cmp rax, rdx
jz short loc_125D
mov r9d, 0
loc_1229:
add r9, 1
cmp r9, rsi
jnb short loc_1263
mov r8, r9
loc_1235:
add r8, 1
cmp r8, rsi
jnb short loc_1229
... | long long func0(_QWORD *a1)
{
unsigned long long v1; // rsi
unsigned long long v2; // r9
unsigned long long v3; // r8
unsigned long long v4; // rax
v1 = (long long)(a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 0LL;
v2 = 0LL;
do
{
if ( ++v2 >= v1 )
return 0LL;
v3 = v2;
LABEL_5:
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RSI,RAX
SUB RSI,RDX
SAR RSI,0x2
CMP RAX,RDX
JZ 0x0010125d
MOV R9D,0x0
LAB_00101229:
ADD R9,0x1
CMP R9,RSI
JNC 0x00101263
MOV R8,R9
LAB_00101235:
ADD R8,0x1
CMP R8,RSI
JNC 0x00101229
MOV ECX,dword ptr [RDX + R8*0x4 + -0x4]
ADD ECX,dword ptr [RDX + ... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int4 in_register_0000003c;
ulong uVar5;
ulong uVar6;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_register_0000003c,param... |
162 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(vector<int> l){
for (int i=0;i<l.size();i++)
for (int j=i+1;j<l.size();j++)
for (int k=j+1;k<l.size();k++)
if (l[i]+l[j]+l[k]==0) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 3, 5, 0}) == false);
assert (func0({1, 3, 5, -1}) == false);
assert (func0({1, 3, -2, 1}) == true);
assert (func0({1, 2, 3, 7}) == false);
assert (func0({1, 2, 5, 7}) == false);
assert (func0({2, 4, -5, 3, 9, 7}) == true);
asser... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
je 169a <_Z5func0St6vectorIiSaIiEE+0x6a>
mov $0x1,%r8d
xor %r9d,%r9d
mov %r8,%rdi
cmp %r8,%rdx
jbe 1688 <_Z5func0St6vectorIiSaIiEE+0x58>
add $0x1,%rdi
cmp %rdx,%rdi
... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
xor r9d, r9d
mov rsi, rax
sub rsi, rdx
sar rsi, 2
cmp rax, rdx
jz short loc_15CE
loc_158D:
add r9, 1
cmp r9, rsi
jnb short loc_15CE
mov r8, r9
loc_1599:
add r8, 1
cmp r8, rsi
jnb short loc_158... | long long func0(_QWORD *a1)
{
long long v1; // r9
unsigned long long v2; // rsi
long long v3; // r8
long long v4; // rax
v1 = 0LL;
v2 = (long long)(a1[1] - *a1) >> 2;
if ( a1[1] != *a1 )
{
while ( ++v1 < v2 )
{
v3 = v1;
LABEL_4:
if ( ++v3 < v2 )
{
v4 = v3;
whi... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
XOR R9D,R9D
MOV RSI,RAX
SUB RSI,RDX
SAR RSI,0x2
CMP RAX,RDX
JZ 0x001015ce
LAB_0010158d:
ADD R9,0x1
CMP R9,RSI
JNC 0x001015ce
MOV R8,R9
LAB_00101599:
ADD R8,0x1
CMP R8,RSI
JNC 0x0010158d
MOV ECX,dword ptr [RDX + R8*0x4 + -0x4]
MOV RAX,R8
ADD ECX,dword ... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int4 in_register_0000003c;
ulong uVar5;
ulong uVar6;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_register_0000003c,param... |
163 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(vector<int> l){
for (int i=0;i<l.size();i++)
for (int j=i+1;j<l.size();j++)
for (int k=j+1;k<l.size();k++)
if (l[i]+l[j]+l[k]==0) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 3, 5, 0}) == false);
assert (func0({1, 3, 5, -1}) == false);
assert (func0({1, 3, -2, 1}) == true);
assert (func0({1, 2, 3, 7}) == false);
assert (func0({1, 2, 5, 7}) == false);
assert (func0({2, 4, -5, 3, 9, 7}) == true);
asser... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
je 16ba <_Z5func0St6vectorIiSaIiEE+0x6a>
mov $0x1,%r8d
xor %r9d,%r9d
mov %r8,%rdi
cmp %rdx,%r8
jae 16a8 <_Z5func0St6vectorIiSaIiEE+0x58>
add $0x1,%rdi
cmp %rdi,%rdx
... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
xor r9d, r9d
mov rsi, rax
sub rsi, rdx
sar rsi, 2
cmp rax, rdx
jz short loc_15CE
loc_158D:
add r9, 1
cmp r9, rsi
jnb short loc_15CE
mov r8, r9
loc_1599:
add r8, 1
cmp r8, rsi
jnb short loc_158... | long long func0(_QWORD *a1)
{
long long v1; // r9
unsigned long long v2; // rsi
long long v3; // r8
long long v4; // rax
v1 = 0LL;
v2 = (long long)(a1[1] - *a1) >> 2;
if ( a1[1] != *a1 )
{
while ( ++v1 < v2 )
{
v3 = v1;
LABEL_4:
if ( ++v3 < v2 )
{
v4 = v3;
whi... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
XOR R9D,R9D
MOV RSI,RAX
SUB RSI,RDX
SAR RSI,0x2
CMP RAX,RDX
JZ 0x001015ce
LAB_0010158d:
ADD R9,0x1
CMP R9,RSI
JNC 0x001015ce
MOV R8,R9
LAB_00101599:
ADD R8,0x1
CMP R8,RSI
JNC 0x0010158d
MOV ECX,dword ptr [RDX + R8*0x4 + -0x4]
MOV RAX,R8
ADD ECX,dword ... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int4 in_register_0000003c;
ulong uVar5;
ulong uVar6;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_register_0000003c,param... |
164 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
return n*n;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2) == 4);
assert (func0(3) == 9);
assert (func0(4) == 16);
assert (func0(8) == 64);
assert (func0(10) == 100);
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
imul eax, eax
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1;
} |
165 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
return n*n;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2) == 4);
assert (func0(3) == 9);
assert (func0(4) == 16);
assert (func0(8) == 64);
assert (func0(10) == 100);
}
| O1 | cpp | func0(int):
endbr64
imul %edi,%edi
mov %edi,%eax
retq
| _Z5func0i:
endbr64
imul edi, edi
mov eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
MOV EAX,EDI
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1;
} |
166 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
return n*n;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2) == 4);
assert (func0(3) == 9);
assert (func0(4) == 16);
assert (func0(8) == 64);
assert (func0(10) == 100);
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%eax
imul %edi,%eax
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
imul edi, edi
mov eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
MOV EAX,EDI
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1;
} |
167 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
return n*n;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2) == 4);
assert (func0(3) == 9);
assert (func0(4) == 16);
assert (func0(8) == 64);
assert (func0(10) == 100);
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%eax
imul %edi,%eax
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
imul edi, edi
mov eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
MOV EAX,EDI
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1;
} |
168 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> l){
for (int i=0;i<l.size();i++)
l[i]+=1;
return l;
}
| #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({3, 2, 1}) , {4, 3, 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)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 1b14 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %r... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_14], 0
jmp short loc_1287
loc_1267:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6v... | long long func0(long long a1, long long a2)
{
_DWORD *v2; // rax
int i; // [rsp+1Ch] [rbp-14h]
for ( i = 0; i < (unsigned long long)std::vector<int>::size(a2); ++i )
{
v2 = (_DWORD *)std::vector<int>::operator[](a2, i);
++*v2;
}
std::vector<int>::vector(a1, a2);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101287
LAB_00101267:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101b8a
MOV EDX,dword ptr ... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int *piVar1;
ulong uVar2;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
int4 local_1c;
local_1c = 0;
while( true ) {
uVar2 = std::vector<int,std::allocator<int>>::si... |
169 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> l){
for (int i=0;i<l.size();i++)
l[i]+=1;
return l;
}
| #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({3, 2, 1}) , {4, 3, 2}));
... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov %rdi,%rax
mov (%rsi),%rcx
mov 0x8(%rsi),%rdi
sub %rcx,%rdi
mov %rdi,%rdx
shr $0x2,%rdx
je 1235 <_Z5func0St6vectorIiSaIiEE+0x2c>
mov %rcx,%rdx
add %rdi,%rcx
addl $0x1,(%rdx)
add $0x4,%rdx
cmp %rcx,%rdx
jne 1229 <_Z5func0St6... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, rdi
mov rcx, [rsi]
cmp [rsi+8], rcx
jz short loc_1263
mov edx, 0
loc_121E:
add dword ptr [rcx+rdx*4], 1
mov r9, [rsi+8]
mov rcx, [rsi]
add rdx, 1
mov r8, r9
sub r8, rcx
sar r8, 2
cmp rdx, r8
jb short loc_121E
loc_123C:... | _QWORD * func0(_QWORD *a1, long long *a2)
{
_QWORD *result; // rax
long long v3; // rcx
unsigned long long v4; // rdx
long long v5; // r9
result = a1;
v3 = *a2;
if ( a2[1] == *a2 )
{
v5 = *a2;
}
else
{
v4 = 0LL;
do
{
++*(_DWORD *)(v3 + 4 * v4);
v5 = a2[1];
v3 = *... | func0:
ENDBR64
MOV RAX,RDI
MOV RCX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RCX
JZ 0x00101263
MOV EDX,0x0
LAB_0010121e:
ADD dword ptr [RCX + RDX*0x4],0x1
MOV R9,qword ptr [RSI + 0x8]
MOV RCX,qword ptr [RSI]
ADD RDX,0x1
MOV R8,R9
SUB R8,RCX
SAR R8,0x2
CMP RDX,R8
JC 0x0010121e
LAB_0010123c:
MOV qword ptr [RAX],RCX
MOV q... | /* func0(std::vector<int, std::allocator<int> >) */
void func0(vector param_1)
{
int *piVar1;
long *plVar2;
long lVar3;
ulong uVar4;
long *in_RSI;
int4 in_register_0000003c;
long lVar5;
plVar2 = (long *)CONCAT44(in_register_0000003c,param_1);
lVar3 = *in_RSI;
lVar5 = lVar3;
if (in_RSI[1] != l... |
170 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> l){
for (int i=0;i<l.size();i++)
l[i]+=1;
return l;
}
| #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({3, 2, 1}) , {4, 3, 2}));
... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov 0x8(%rsi),%r8
mov %rdi,%rax
mov (%rsi),%rdi
mov %r8,%rcx
sub %rdi,%rcx
mov %rcx,%rdx
shr $0x2,%rdx
je 1704 <_Z5func0St6vectorIiSaIiEE+0x34>
mov %rdi,%rdx
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
addl $0x1,(%rdx)
add $0x4,%rdx
cm... | _Z5func0St6vectorIiSaIiEE:
endbr64
movdqu xmm0, xmmword ptr [rsi]
mov rax, rdi
xor ecx, ecx
movhlps xmm1, xmm0
movq rdx, xmm0
movq rdi, xmm1
mov r8, rdi
sub r8, rdx
sar r8, 2
cmp rdi, rdx
jz short loc_15D0
nop dword ptr [rax+00000000h]
loc_15C0:
add rcx, 1
add dword ptr [... | __m128 * func0(__m128 *a1, const __m128i *a2, double a3, __m128 a4)
{
__m128 v4; // xmm0
__m128 *result; // rax
unsigned long long v6; // rcx
_DWORD *v7; // rdx
unsigned long long v8; // rdi
long long v9; // rdx
v4 = (__m128)_mm_loadu_si128(a2);
result = a1;
v6 = 0LL;
v7 = (_DWORD *)v4.m128_u64[0];... | func0:
ENDBR64
MOVDQU XMM0,xmmword ptr [RSI]
MOV RAX,RDI
XOR ECX,ECX
MOVHLPS XMM1,XMM0
MOVQ RDX,XMM0
MOVQ RDI,XMM1
MOV R8,RDI
SUB R8,RDX
SAR R8,0x2
CMP RDI,RDX
JZ 0x001015d0
NOP dword ptr [RAX]
LAB_001015c0:
ADD RCX,0x1
ADD dword ptr [RDX],0x1
ADD RDX,0x4
CMP RCX,R8
JC 0x001015c0
LAB_001015d0:
MOV RDX,qword ptr [RSI + ... | /* func0(std::vector<int, std::allocator<int> >) */
void func0(vector param_1)
{
int8 uVar1;
int *piVar2;
int *piVar3;
ulong uVar4;
int *piVar5;
int (*in_RSI) [16];
int4 in_register_0000003c;
int8 *puVar6;
puVar6 = (int8 *)CONCAT44(in_register_0000003c,param_1);
piVar2 = *(int **)*in_RSI;
piV... |
171 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> l){
for (int i=0;i<l.size();i++)
l[i]+=1;
return l;
}
| #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({3, 2, 1}) , {4, 3, 2}));
... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov 0x8(%rsi),%r10
mov (%rsi),%rcx
mov %rdi,%rax
mov %r10,%r9
sub %rcx,%r9
sar $0x2,%r9
je 182d <_Z5func0St6vectorIiSaIiEE+0x8d>
lea -0x1(%r9),%rdx
cmp $0x2,%rdx
jbe 1856 <_Z5func0St6vectorIiSaIiEE+0xb6>
mov %r9,%r8
movdqa 0x95d(%r... | _Z5func0St6vectorIiSaIiEE:
endbr64
movdqu xmm2, xmmword ptr [rsi]
mov r8, rdi
mov rdi, rsi
movhlps xmm3, xmm2
movq rcx, xmm2
movq rsi, xmm3
mov rax, rcx
mov rdx, rsi
sub rdx, rcx
mov r9, rdx
sar r9, 2
cmp rcx, rsi
jz short loc_1857
test rdx, rdx
mov esi, 1
cmovnz rsi,... | __m128 * func0(__m128 *a1, const __m128i *a2, double a3, double a4, double a5, __m128 a6)
{
__m128 v6; // xmm2
unsigned long long v9; // xmm3_8
const __m128i *v10; // rax
unsigned long long v11; // rdx
unsigned long long v12; // r9
unsigned long long v13; // rsi
__m128i si128; // xmm1
__m128i v15; // xm... | func0:
ENDBR64
MOVDQU XMM2,xmmword ptr [RSI]
MOV R8,RDI
MOV RDI,RSI
MOVHLPS XMM3,XMM2
MOVQ RCX,XMM2
MOVQ RSI,XMM3
MOV RAX,RCX
MOV RDX,RSI
SUB RDX,RCX
MOV R9,RDX
SAR R9,0x2
CMP RCX,RSI
JZ 0x00101857
TEST RDX,RDX
MOV ESI,0x1
CMOVNZ RSI,R9
CMP RDX,0xc
JBE 0x00101876
MOV RDX,RSI
MOVDQA XMM1,xmmword ptr [0x00102110]
SHR RDX... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >) */
long * func0(vector param_1)
{
long lVar1;
int *piVar2;
int *piVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int *piVar8;
int *piVar9;
uint uVar10;
ulong u... |
172 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> l){
for (int i=0;i<l.size();i++)
for (int j=i+1;j<l.size();j++)
if (l[i]+l[j]==0) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 3, 5, 0}) == false);
assert (func0({1, 3, -2, 1}) == false);
assert (func0({1, 2, 3, 7}) == false);
assert (func0({2, 4, -5, 3, 5, 7}) == true);
assert (func0({1}) == false);
assert (func0({-3, 9, -1, 3, 2, 30}) == true);
assert... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
mov -0x18(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1ae4 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,%rbx
setb %al
test ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_18], 0
jmp short loc_12D2
loc_1263:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_12B2
loc_126E:
mov eax, [rbp+var_18]
movsxd rdx, eax
m... | long long func0(long long a1)
{
int v1; // ebx
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
for ( i = 0; i < (unsigned long long)std::vector<int>::size(a1); ++i )
{
for ( j = i + 1; j < (unsigned long long)std::vector<int>::size(a1); ++j )
{
v1 = *(_DWORD *)std::vector<int>::ope... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001012d2
LAB_00101263:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001012b2
LAB_0010126e:
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int iVar1;
int *piVar2;
ulong uVar3;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int local_20;
int local_1c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
loc... |
173 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> l){
for (int i=0;i<l.size();i++)
for (int j=i+1;j<l.size();j++)
if (l[i]+l[j]==0) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 3, 5, 0}) == false);
assert (func0({1, 3, -2, 1}) == false);
assert (func0({1, 2, 3, 7}) == false);
assert (func0({2, 4, -5, 3, 5, 7}) == true);
assert (func0({1}) == false);
assert (func0({-3, 9, -1, 3, 2, 30}) == true);
assert... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rax
sub %rdx,%rax
sar $0x2,%rax
mov %rax,%rcx
je 1257 <_Z5func0St6vectorIiSaIiEE+0x4e>
mov $0x1,%edi
cmp %rcx,%rdi
jae 1243 <_Z5func0St6vectorIiSaIiEE+0x3a>
mov -0x4(%rdx,%rdi,4),%esi
movslq %edi,%rax
mo... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_124C
mov r8d, 0
loc_1229:
add r8, 1
cmp r8, rcx
jnb short loc_1252
mov esi, [rdx+r8*4-4]
movsxd rax, r8d
loc_123A:
mov edi, esi
add ... | long long func0(_QWORD *a1)
{
unsigned long long v1; // rcx
long long v2; // r8
long long v3; // rax
v1 = (long long)(a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 0LL;
v2 = 0LL;
LABEL_3:
if ( ++v2 >= v1 )
{
return 0LL;
}
else
{
v3 = (int)v2;
while ( *(_DWORD *)(*a1 + 4 * v3) + *... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RCX,RAX
SUB RCX,RDX
SAR RCX,0x2
CMP RAX,RDX
JZ 0x0010124c
MOV R8D,0x0
LAB_00101229:
ADD R8,0x1
CMP R8,RCX
JNC 0x00101252
MOV ESI,dword ptr [RDX + R8*0x4 + -0x4]
MOVSXD RAX,R8D
LAB_0010123a:
MOV EDI,ESI
ADD EDI,dword ptr [RDX + RAX*0x4]
JZ 0x001012... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int4 in_register_0000003c;
ulong uVar5;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar4 = ... |
174 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> l){
for (int i=0;i<l.size();i++)
for (int j=i+1;j<l.size();j++)
if (l[i]+l[j]==0) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 3, 5, 0}) == false);
assert (func0({1, 3, -2, 1}) == false);
assert (func0({1, 2, 3, 7}) == false);
assert (func0({2, 4, -5, 3, 5, 7}) == true);
assert (func0({1}) == false);
assert (func0({-3, 9, -1, 3, 2, 30}) == true);
assert... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
je 16ce <_Z5func0St6vectorIiSaIiEE+0x5e>
mov $0x1,%edi
cmp %rdx,%rdi
jae 16c0 <_Z5func0St6vectorIiSaIiEE+0x50>
mov -0x4(%rcx,%rdi,4),%esi
mov %rdi,%rax
jmp 16a9 <_Z5fun... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_15E6
xor r8d, r8d
loc_15BD:
add r8, 1
cmp r8, rcx
jnb short loc_15E6
mov esi, [rdx+r8*4-4]
mov rax, r8
jmp short loc_15D9
loc_15D0:
a... | long long func0(_QWORD *a1)
{
unsigned long long v1; // rcx
long long v2; // r8
long long v3; // rax
v1 = (long long)(a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 0LL;
v2 = 0LL;
LABEL_3:
if ( ++v2 >= v1 )
return 0LL;
v3 = v2;
while ( *(_DWORD *)(*a1 + 4 * v3) + *(_DWORD *)(*a1 + 4 * v2 - 4)... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RCX,RAX
SUB RCX,RDX
SAR RCX,0x2
CMP RAX,RDX
JZ 0x001015e6
XOR R8D,R8D
LAB_001015bd:
ADD R8,0x1
CMP R8,RCX
JNC 0x001015e6
MOV ESI,dword ptr [RDX + R8*0x4 + -0x4]
MOV RAX,R8
JMP 0x001015d9
LAB_001015d0:
ADD RAX,0x1
CMP RAX,RCX
JNC 0x001015bd
LAB_001... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int4 in_register_0000003c;
ulong uVar5;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar4 = ... |
175 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> l){
for (int i=0;i<l.size();i++)
for (int j=i+1;j<l.size();j++)
if (l[i]+l[j]==0) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 3, 5, 0}) == false);
assert (func0({1, 3, -2, 1}) == false);
assert (func0({1, 2, 3, 7}) == false);
assert (func0({2, 4, -5, 3, 5, 7}) == true);
assert (func0({1}) == false);
assert (func0({-3, 9, -1, 3, 2, 30}) == true);
assert... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
je 16de <_Z5func0St6vectorIiSaIiEE+0x5e>
mov $0x1,%edi
cmp %rdi,%rdx
jbe 16d0 <_Z5func0St6vectorIiSaIiEE+0x50>
mov -0x4(%rcx,%rdi,4),%esi
mov %rdi,%rax
jmp 16b9 <_Z5fun... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_15E6
xor r8d, r8d
loc_15BD:
add r8, 1
cmp r8, rcx
jnb short loc_15E6
mov esi, [rdx+r8*4-4]
mov rax, r8
jmp short loc_15D9
loc_15D0:
a... | long long func0(_QWORD *a1)
{
unsigned long long v1; // rcx
long long v2; // r8
long long v3; // rax
v1 = (long long)(a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 0LL;
v2 = 0LL;
LABEL_3:
if ( ++v2 >= v1 )
return 0LL;
v3 = v2;
while ( *(_DWORD *)(*a1 + 4 * v3) + *(_DWORD *)(*a1 + 4 * v2 - 4)... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RCX,RAX
SUB RCX,RDX
SAR RCX,0x2
CMP RAX,RDX
JZ 0x001015e6
XOR R8D,R8D
LAB_001015bd:
ADD R8,0x1
CMP R8,RCX
JNC 0x001015e6
MOV ESI,dword ptr [RDX + R8*0x4 + -0x4]
MOV RAX,R8
JMP 0x001015d9
LAB_001015d0:
ADD RAX,0x1
CMP RAX,RCX
JNC 0x001015bd
LAB_001... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int4 in_register_0000003c;
ulong uVar5;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar4 = ... |
176 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int x,int base){
string out="";
while (x>0)
{
out=to_string(x%base)+out;
x=x/base;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(8, 3) == "22");
assert (func0(9, 3) == "100");
assert (func0(234, 2) == "11101010");
assert (func0(16, 2) == "10000");
assert (func0(8, 2) == "1000");
assert (func0(7, 2) == "111");
for (int x=2;x<8;x++)
assert (func0(x, x +... | O0 | cpp | func0[abi:cxx11](int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %edx,-0x80(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x61(%rbp),%rax
mov %rax,%rdi
callq 2380 <_ZNSaIcEC1Ev@plt>
lea -0x61(%rbp),... | _Z5func0B5cxx11ii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_7C], esi
mov [rbp+var_80], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_69]
mov [rbp+var_68], rax
nop
nop
lea rdx, [rbp+var_69]
mov ... | long long func0[abi:cxx11](long long a1, int a2, int a3)
{
char v6; // [rsp+17h] [rbp-69h] BYREF
char *v7; // [rsp+18h] [rbp-68h]
_BYTE v8[32]; // [rsp+20h] [rbp-60h] BYREF
_BYTE v9[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v10; // [rsp+68h] [rbp-18h]
v10 = __readfsqword(0x28u);
v7 = &v6;
s... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV dword ptr [RBP + -0x7c],ESI
MOV dword ptr [RBP + -0x80],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x69]
MOV qword ptr [RBP + -0x68],RAX
NOP
NOP
LEA RDX,[RBP + -0x69]... | /* func0[abi:cxx11](int, int) */
string * func0_abi_cxx11_(int param_1,int param_2)
{
int in_EDX;
int4 in_register_0000003c;
string *this;
long in_FS_OFFSET;
int local_84;
allocator local_71;
allocator *local_70;
string local_68 [32];
string local_48 [40];
long local_20;
this = (string *)CONC... |
177 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int x,int base){
string out="";
while (x>0)
{
out=to_string(x%base)+out;
x=x/base;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(8, 3) == "22");
assert (func0(9, 3) == "100");
assert (func0(234, 2) == "11101010");
assert (func0(16, 2) == "10000");
assert (func0(8, 2) == "1000");
assert (func0(7, 2) == "111");
for (int x=2;x<8;x++)
assert (func0(x, x +... | O1 | cpp | func0[abi:cxx11](int, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%r14
mov %r14,(%rdi)
movq $0x0,0x8(%rdi)
movb $0x0,0x10(%rdi)
test %esi,%esi
jle 1447 <_Z5func0B5c... | _Z5func0B5cxx11ii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r12, rdi
mov [rsp+0A8h+var_9C], esi
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rsp+0A8h+var_90], rax
mov [rdi], rax
mov qword p... | long long func0[abi:cxx11](long long a1, int a2, int a3)
{
unsigned int v5; // ebx
long long v6; // rax
long long v7; // rdx
_BYTE *v8; // rax
long long v9; // rcx
unsigned int v10; // edx
unsigned int v11; // eax
unsigned int v12; // esi
_DWORD *v13; // r9
_DWORD *v14; // rcx
long long v15; // r... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R12,RDI
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte... | /* func0[abi:cxx11](int, int) */
ulong * func0_abi_cxx11_(int param_1,int param_2)
{
ulong *puVar1;
int8 *puVar2;
int8 uVar3;
long lVar4;
uint uVar5;
ulong *puVar6;
int in_EDX;
uint uVar7;
ulong uVar8;
uint uVar9;
int4 in_register_0000003c;
ulong *puVar10;
ulong *puVar11;
long in_FS_OFFSET... |
178 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int x,int base){
string out="";
while (x>0)
{
out=to_string(x%base)+out;
x=x/base;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(8, 3) == "22");
assert (func0(9, 3) == "100");
assert (func0(234, 2) == "11101010");
assert (func0(16, 2) == "10000");
assert (func0(8, 2) == "1000");
assert (func0(7, 2) == "111");
for (int x=2;x<8;x++)
assert (func0(x, x +... | O2 | cpp | func0[abi:cxx11](int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x0,0x8(%rdi)
mov %rax,0x8(%rsp)
mov %rax,(%rdi)
movb $0x0,0x10(%rdi)
test ... | _Z5func0B5cxx11ii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 138h
mov [rsp+168h+var_15C], edx
mov rax, fs:28h
mov [rsp+168h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov qword ptr [rdi+8], 0
mov [rsp+168h+var_168], rax
mo... | void ** func0[abi:cxx11](void **a1, int a2, int a3)
{
int v4; // ebp
int v5; // edx
unsigned int v6; // r12d
unsigned int v7; // r8d
unsigned int v8; // r15d
long long v9; // rsi
__int8 *v10; // rsi
unsigned int v11; // eax
unsigned int v12; // edi
long long v13; // rax
long long v14; // r9
long... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x138
MOV dword ptr [RSP + 0xc],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RSP],RAX
MOV qword ptr [RDI],RAX
MOV byte ptr ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int, int) */
ulong * func0_abi_cxx11_(int param_1,int param_2)
{
uint uVar1;
ulong uVar2;
uint uVar3;
uint uVar4;
int8 *puVar5;
ulong uVar6;
ulong *puVar7;
long lVar8;
char cVar9;
ulong uVar10;... |
179 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int x,int base){
string out="";
while (x>0)
{
out=to_string(x%base)+out;
x=x/base;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(8, 3) == "22");
assert (func0(9, 3) == "100");
assert (func0(234, 2) == "11101010");
assert (func0(16, 2) == "10000");
assert (func0(8, 2) == "1000");
assert (func0(7, 2) == "111");
for (int x=2;x<8;x++)
assert (func0(x, x +... | O3 | cpp | func0[abi:cxx11](int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x0,0x8(%rdi)
mov %rax,0x8(%rsp)
mov %rax,(%rdi)
movb $0x0,0x10(%rdi)
test ... | _Z5func0B5cxx11ii:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov ebp, esi
push rbx
mov rbx, rdi
sub rsp, 138h
mov [rsp+168h+var_15C], edx
lea r13, [rsp+168h+var_158]
lea r14, [rsp+168h+var_148]
mov rax, fs:28h
mov [rsp+168h+var_40], rax
xor eax, eax
lea ... | void ** func0[abi:cxx11](void **a1, int a2, int a3)
{
int v3; // ebp
int v5; // edx
unsigned int v6; // r12d
unsigned int v7; // r8d
unsigned int v8; // r15d
long long v9; // rsi
__int8 *v10; // rsi
unsigned int v11; // eax
unsigned int v12; // edi
long long v13; // rax
long long v14; // r9
long... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x138
MOV dword ptr [RSP + 0xc],EDX
LEA R13,[RSP + 0x10]
LEA R14,[RSP + 0x20]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI + 0x8],0x0
MOV qwo... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int, int) */
ulong * func0_abi_cxx11_(int param_1,int param_2)
{
uint uVar1;
ulong uVar2;
uint uVar3;
uint uVar4;
int8 *puVar5;
ulong uVar6;
ulong *puVar7;
long lVar8;
char cVar9;
ulong uVar10;... |
180 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float a,float h){
return (a*h)*0.5;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0(5, 3) - 7.5)<1e-4);
assert (abs(func0(2, 2) - 2.0)<1e-4);
assert (abs(func0(10, 8) - 40.0)<1e-4);
}
| O0 | cpp | func0(float, float):
endbr64
push %rbp
mov %rsp,%rbp
movss %xmm0,-0x4(%rbp)
movss %xmm1,-0x8(%rbp)
movss -0x4(%rbp),%xmm0
movaps %xmm0,%xmm1
mulss -0x8(%rbp),%xmm1
movss 0xf60(%rip),%xmm0
mulss %xmm1,%xmm0
pop %rbp
retq
| _Z5func0ff:
endbr64
push rbp
mov rbp, rsp
movss [rbp+var_4], xmm0
movss [rbp+var_8], xmm1
movss xmm0, [rbp+var_4]
movaps xmm1, xmm0
mulss xmm1, [rbp+var_8]
movss xmm0, cs:dword_20B0
mulss xmm0, xmm1
pop rbp
retn | float func0(float a1, float a2)
{
return 0.5 * (float)(a1 * a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS dword ptr [RBP + -0x8],XMM1
MOVSS XMM0,dword ptr [RBP + -0x4]
MOVAPS XMM1,XMM0
MULSS XMM1,dword ptr [RBP + -0x8]
MOVSS XMM0,dword ptr [0x001020b0]
MULSS XMM0,XMM1
POP RBP
RET | /* func0(float, float) */
float func0(float param_1,float param_2)
{
return DAT_001020b0 * param_1 * param_2;
} |
181 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float a,float h){
return (a*h)*0.5;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0(5, 3) - 7.5)<1e-4);
assert (abs(func0(2, 2) - 2.0)<1e-4);
assert (abs(func0(10, 8) - 40.0)<1e-4);
}
| O1 | cpp | func0(float, float):
endbr64
mulss %xmm1,%xmm0
mulss 0xecb(%rip),%xmm0
retq
| _Z5func0ff:
endbr64
mulss xmm0, xmm1
mulss xmm0, cs:dword_2004
retn | float func0(float a1, float a2)
{
return (float)(a1 * a2) * 0.5;
} | func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,dword ptr [0x00102004]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(float, float) */
float func0(float param_1,float param_2)
{
return param_1 * param_2 * _DAT_00102004;
} |
182 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float a,float h){
return (a*h)*0.5;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0(5, 3) - 7.5)<1e-4);
assert (abs(func0(2, 2) - 2.0)<1e-4);
assert (abs(func0(10, 8) - 40.0)<1e-4);
}
| O2 | cpp | func0(float, float):
endbr64
mulss %xmm1,%xmm0
mulss 0xeb4(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0ff:
endbr64
mulss xmm0, xmm1
mulss xmm0, cs:dword_2004
retn | float func0(float a1, float a2)
{
return (float)(a1 * a2) * 0.5;
} | func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,dword ptr [0x00102004]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(float, float) */
float func0(float param_1,float param_2)
{
return param_1 * param_2 * _DAT_00102004;
} |
183 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float a,float h){
return (a*h)*0.5;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0(5, 3) - 7.5)<1e-4);
assert (abs(func0(2, 2) - 2.0)<1e-4);
assert (abs(func0(10, 8) - 40.0)<1e-4);
}
| O3 | cpp | func0(float, float):
endbr64
mulss %xmm1,%xmm0
mulss 0xeb4(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0ff:
endbr64
mulss xmm0, xmm1
mulss xmm0, cs:dword_2004
retn | float func0(float a1, float a2)
{
return (float)(a1 * a2) * 0.5;
} | func0:
ENDBR64
MULSS XMM0,XMM1
MULSS XMM0,dword ptr [0x00102004]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(float, float) */
float func0(float param_1,float param_2)
{
return param_1 * param_2 * _DAT_00102004;
} |
184 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f[100];
f[0]=0;
f[1]=0;
f[2]=2;
f[3]=0;
for (int i=4;i<=n;i++)
{
f[i]=f[i-1]+f[i-2]+f[i-3]+f[i-4];
}
return f[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 4);
assert (func0(8) == 28);
assert (func0(10) == 104);
assert (func0(12) == 386);
assert (func0(6) == 8);
assert (func0(7) == 14);
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x1c0,%rsp
mov %edi,-0x1b4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x1a0(%rbp)
movl $0x0,-0x19c(%rbp)
movl $0x2,-0x198(%rbp)
movl $0x0,-0x194(%rbp)
movl $0x4,-0x1a4(%rbp)
mov -0x1a4(%rbp),%eax
cmp -0x1b4(%r... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 1C0h
mov [rbp+var_1B4], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_1A0], 0
mov [rbp+var_19C], 0
mov [rbp+var_198], 2
mov [rbp+var_194], 0
mov [rbp+var_1A4], 4
jmp short loc_1225
loc_11C1:
mov ... | long long func0(int a1)
{
int i; // [rsp+1Ch] [rbp-1A4h]
_DWORD v3[102]; // [rsp+20h] [rbp-1A0h]
unsigned long long v4; // [rsp+1B8h] [rbp-8h]
v4 = __readfsqword(0x28u);
v3[0] = 0;
v3[1] = 0;
v3[2] = 2;
v3[3] = 0;
for ( i = 4; i <= a1; ++i )
v3[i] = v3[i - 4] + v3[i - 3] + v3[i - 2] + v3[i - 1];... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1c0
MOV dword ptr [RBP + -0x1b4],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x1a0],0x0
MOV dword ptr [RBP + -0x19c],0x0
MOV dword ptr [RBP + -0x198],0x2
MOV dword ptr [RBP + -0x194],0x0
MOV dword ptr [RBP + -0x1a4],0x4
J... | /* func0(int) */
int func0(int param_1)
{
long in_FS_OFFSET;
int local_1ac;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1a8[0] = 0;
local_1a8[1] = 0;
local_1a8[2] = 2;
local_1a8[3] = 0;
for (local_1ac = 4; local_1ac <= param_1; local_1ac = local_1ac + 1)... |
185 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f[100];
f[0]=0;
f[1]=0;
f[2]=2;
f[3]=0;
for (int i=4;i<=n;i++)
{
f[i]=f[i-1]+f[i-2]+f[i-3]+f[i-4];
}
return f[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 4);
assert (func0(8) == 28);
assert (func0(10) == 104);
assert (func0(12) == 386);
assert (func0(6) == 8);
assert (func0(7) == 14);
}
| O1 | cpp | func0(int):
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
movl $0x0,(%rsp)
movl $0x0,0x4(%rsp)
movl $0x2,0x8(%rsp)
movl $0x0,0xc(%rsp)
cmp $0x3,%edi
jle 11cd <_Z5func0i+0x64>
mov %rsp,%rax
lea -0x4(%rdi),%edx
lea 0x4(%rsp,%rdx,4),%rcx
mov 0x8(%rax),%e... | _Z5func0i:
endbr64
sub rsp, 1A8h
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov [rsp+1A8h+var_1A8], 0
mov [rsp+1A8h+var_1A4], 0
mov [rsp+1A8h+var_1A0], 2
mov [rsp+1A8h+var_19C], 0
cmp edi, 3
jle short loc_11CD
mov rax, rsp
lea edx, [rdi-4]
lea rcx, [rsp+r... | long long func0(int a1)
{
int *v1; // rax
int v3; // [rsp+0h] [rbp-1A8h] BYREF
_DWORD v4[101]; // [rsp+4h] [rbp-1A4h] BYREF
unsigned long long v5; // [rsp+198h] [rbp-10h]
v5 = __readfsqword(0x28u);
v3 = 0;
v4[0] = 0;
v4[1] = 2;
v4[2] = 0;
if ( a1 > 3 )
{
v1 = &v3;
do
{
v1[4] = ... | func0:
ENDBR64
SUB RSP,0x1a8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x4],0x0
MOV dword ptr [RSP + 0x8],0x2
MOV dword ptr [RSP + 0xc],0x0
CMP EDI,0x3
JLE 0x001011cd
MOV RAX,RSP
LEA EDX,[RDI + -0x4]
LEA RCX,[RSP + RDX*0x4 + 0x4]
LAB_001011b6:
M... | /* func0(int) */
int func0(int param_1)
{
int *piVar1;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
piVar1 = local_1a8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1a8[0] = 0;
local_1a8[1] = 0;
local_1a8[2] = 2;
local_1a8[3] = 0;
if (3 < param_1) {
do {
piVar1[4] = pi... |
186 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f[100];
f[0]=0;
f[1]=0;
f[2]=2;
f[3]=0;
for (int i=4;i<=n;i++)
{
f[i]=f[i-1]+f[i-2]+f[i-3]+f[i-4];
}
return f[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 4);
assert (func0(8) == 28);
assert (func0(10) == 104);
assert (func0(12) == 386);
assert (func0(6) == 8);
assert (func0(7) == 14);
}
| O2 | cpp | func0(int):
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x2,0x8(%rsp)
cmp $0x3,%edi
jle 131f <_Z5func0i+0x6f>
lea -0x4(%rdi),%eax
lea 0x4(%rsp),%rdx
xor %r8d,%r8d
xor %esi,%esi
lea 0x8(%rsp,%rax,4),%r9
mov $0x2,%ecx
xor %... | _Z5func0i:
endbr64
sub rsp, 1A8h
movdqa xmm0, cs:xmmword_20A0
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
movaps [rsp+1A8h+var_1A8], xmm0
cmp edi, 3
jle short loc_1314
lea eax, [rdi-4]
mov rdx, rsp
mov ecx, 2
xor r8d, r8d
lea r9, [rsp+rax*4+1A8h+var_1A8+4]
xor ... | long long func0(int a1)
{
__m128i *p_si128; // rdx
int v2; // ecx
int v3; // r8d
int v4; // eax
int v5; // esi
__m128i si128; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v8; // [rsp+198h] [rbp-10h]
v8 = __readfsqword(0x28u);
si128 = _mm_load_si128((const __m128i *)&xmmword_20A0);
if ( a1 > 3 )... | func0:
ENDBR64
SUB RSP,0x1a8
MOVDQA XMM0,xmmword ptr [0x001020a0]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
CMP EDI,0x3
JLE 0x00101314
LEA EAX,[RDI + -0x4]
MOV RDX,RSP
MOV ECX,0x2
XOR R8D,R8D
LEA R9,[RSP + RAX*0x4 + 0x4]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_001... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int4 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int *piVar5;
int iVar6;
long in_FS_OFFSET;
int8 local_1a8;
int8 uStack_1a0;
int local_198 [98];
long local_10;
local_... |
187 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f[100];
f[0]=0;
f[1]=0;
f[2]=2;
f[3]=0;
for (int i=4;i<=n;i++)
{
f[i]=f[i-1]+f[i-2]+f[i-3]+f[i-4];
}
return f[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(5) == 4);
assert (func0(8) == 28);
assert (func0(10) == 104);
assert (func0(12) == 386);
assert (func0(6) == 8);
assert (func0(7) == 14);
}
| O3 | cpp | func0(int):
endbr64
sub $0x1a8,%rsp
movdqa 0xdfd(%rip),%xmm0
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
movaps %xmm0,(%rsp)
cmp $0x3,%edi
jle 136a <_Z5func0i+0xba>
lea -0x1(%rdi),%r11d
cmp $0x6,%edi
jle 138b <_Z5func0i+0xdb>
mov %rsp,%r10
mov 0x8(%rsp),%esi
mov 0xc(%rsp),%e... | _Z5func0i:
endbr64
sub rsp, 1A8h
movdqa xmm0, cs:xmmword_20A0
movsxd rsi, edi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
movaps [rsp+1A8h+var_1A8], xmm0
cmp esi, 3
jle loc_136A
lea r11d, [rsi-1]
cmp esi, 6
jle loc_1388
mov r10, rsp
xor r8d, r8d
mov edi, 2
... | long long func0(int a1)
{
long long v1; // rsi
int v2; // r8d
int v3; // edi
int v4; // edx
__m128i *p_si128; // rax
int v6; // ecx
int v7; // r9d
char *v8; // rdx
int v9; // eax
__m128i si128; // [rsp+0h] [rbp-1A8h] BYREF
unsigned long long v12; // [rsp+198h] [rbp-10h]
v1 = a1;
v12 = __read... | func0:
ENDBR64
SUB RSP,0x1a8
MOVDQA XMM0,xmmword ptr [0x001020a0]
MOVSXD RSI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
CMP ESI,0x3
JLE 0x0010136a
LEA R11D,[RSI + -0x1]
CMP ESI,0x6
JLE 0x00101388
MOV R10,RSP
XOR R8D,R8D
MOV EDI,0x2
XOR EDX,EDX
MOV RAX,R10
M... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int4 func0(int param_1)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
long in_FS_OFFSET;
int8 local_1a8;
int8 uStack_1a0;
long local_10;
local_10 = *(long... |
188 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| float func0(vector<float> l){
sort(l.begin(),l.end());
if (l.size()%2==1) return l[l.size()/2];
return 0.5*(l[l.size()/2]+l[l.size()/2-1]);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({3, 1, 2, 4, 5}) - 3)<1e-4);
assert (abs(func0({-10, 4, 6, 1000, 10, 20}) -8.0)<1e-4);
assert (abs(func0({5}) - 5)<1e-4);
assert (abs(func0({6, 5}) - 5.5)<1e-4);
assert (abs(func0({8, 1, 3, 9, 9, 2, 7}) - 7)<1e-4 );
}
| O0 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1a1e <_ZNSt6vectorIfSaIfEE3endEv>
mov %rax,%rbx
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 19d2 <_ZNSt6vectorIfSaIfEE5begi... | _Z5func0St6vectorIfSaIfEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_18], rdi
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNSt6vectorIfSaIfEE3endEv; std::vector<float>::end(void)
mov rbx, rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNSt6vectorIfSaIfEE5beg... | float func0(long long a1)
{
long long v1; // rbx
long long v2; // rax
unsigned long long v3; // rax
unsigned long long v5; // rax
unsigned long long v6; // rax
float v7; // [rsp+4h] [rbp-1Ch]
v1 = std::vector<float>::end(a1);
v2 = std::vector<float>::begin(a1);
std::sort<__gnu_cxx::__normal_iterator... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101ac2
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101a76
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00101b12
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101b4... | /* func0(std::vector<float, std::allocator<float> >) */
ulong func0(vector param_1)
{
float fVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
uint uVar4;
ulong uVar5;
uint *puVar6;
float *pfVar7;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
double dVar8;
this =... |
189 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| float func0(vector<float> l){
sort(l.begin(),l.end());
if (l.size()%2==1) return l[l.size()/2];
return 0.5*(l[l.size()/2]+l[l.size()/2-1]);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({3, 1, 2, 4, 5}) - 3)<1e-4);
assert (abs(func0({-10, 4, 6, 1000, 10, 20}) -8.0)<1e-4);
assert (abs(func0({5}) - 5)<1e-4);
assert (abs(func0({6, 5}) - 5.5)<1e-4);
assert (abs(func0({8, 1, 3, 9, 9, 2, 7}) - 7)<1e-4 );
}
| O1 | cpp | func0(std::vector<float, std::allocator<float> >):
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 12da <_Z5func0St6vectorIfSaIfEE+0xb1>
mov %r12,%rbx
sub %r13,%rbx
mov %rbx,%rax
sar $0x2,%rax
bsr %... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov rbp, [rdi+8]
mov r13, [rdi]
cmp rbp, r13
jz loc_12DE
mov r12, rbp
sub r12, r13
mov rdx, r12
sar rdx, 2
mov eax, 40h ; '@'
jz short loc_1265
bsr rax, rdx
xo... | float func0(float **a1)
{
float *v1; // rbp
float *v2; // r13
int v3; // eax
unsigned long long v4; // rax
float *v5; // rcx
float *v6; // rdx
float v7; // xmm1_4
float *v8; // rax
float v9; // xmm0_4
float *v10; // rcx
unsigned long long v11; // rdx
v1 = a1[1];
v2 = *a1;
if ( v1 != *a1 )
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV RBP,qword ptr [RDI + 0x8]
MOV R13,qword ptr [RDI]
CMP RBP,R13
JZ 0x001012de
MOV R12,RBP
SUB R12,R13
MOV RDX,R12
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... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<float, std::allocator<float> >) */
float func0(vector param_1)
{
float fVar1;
float *pfVar2;
long lVar3;
float *pfVar4;
float *pfVar5;
float *pfVar6;
uint uVar7;
_Iter_less_iter in_ECX;
float *p... |
190 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| float func0(vector<float> l){
sort(l.begin(),l.end());
if (l.size()%2==1) return l[l.size()/2];
return 0.5*(l[l.size()/2]+l[l.size()/2-1]);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({3, 1, 2, 4, 5}) - 3)<1e-4);
assert (abs(func0({-10, 4, 6, 1000, 10, 20}) -8.0)<1e-4);
assert (abs(func0({5}) - 5)<1e-4);
assert (abs(func0({6, 5}) - 5.5)<1e-4);
assert (abs(func0({8, 1, 3, 9, 9, 2, 7}) - 7)<1e-4 );
}
| O2 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rdi),%r13
mov (%rdi),%rbp
mov %r13,%rbx
sub %rbp,%rbx
mov %rbx,%rdx
sar $0x2,%rdx
mov %rdx,%rax
cmp %rbp,%r13
je 160b <_Z5func0St6vectorIfSaIfEE+0xcb>
bsr %... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, [rdi+8]
mov rbp, [rdi]
cmp r12, rbp
jz loc_19A8
mov rbx, r12
mov r13, rdi
mov rsi, r12
mov rdi, rbp
sub rbx, rbp
mov rdx, rbx
sar rdx, 2
bsr rdx, rdx
movsxd rdx, e... | float func0(float **a1)
{
float *v1; // r12
float *v2; // rbp
unsigned long long v3; // rdx
float *i; // rcx
float v5; // xmm1_4
float v6; // xmm0_4
float *v7; // rdx
float *v8; // rax
unsigned long long v9; // rdx
float result; // xmm0_4
v1 = a1[1];
v2 = *a1;
if ( v1 == *a1 )
{
result... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,qword ptr [RDI + 0x8]
MOV RBP,qword ptr [RDI]
CMP R12,RBP
JZ 0x001019a8
MOV RBX,R12
MOV R13,RDI
MOV RSI,R12
MOV RDI,RBP
SUB RBX,RBP
MOV RDX,RBX
SAR RDX,0x2
BSR RDX,RDX
MOVSXD RDX,EDX
ADD RDX,RDX
CALL 0x001016d0
CMP RBX,0x40
JLE 0x00101970
LEA RBX,[R... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<float, std::allocator<float> >) */
float func0(vector param_1)
{
float fVar1;
float *pfVar2;
long lVar3;
float *pfVar4;
ulong uVar5;
_Iter_less_iter in_ECX;
_Iter_less_iter extraout_EDX;
ulong uVa... |
191 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| float func0(vector<float> l){
sort(l.begin(),l.end());
if (l.size()%2==1) return l[l.size()/2];
return 0.5*(l[l.size()/2]+l[l.size()/2-1]);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({3, 1, 2, 4, 5}) - 3)<1e-4);
assert (abs(func0({-10, 4, 6, 1000, 10, 20}) -8.0)<1e-4);
assert (abs(func0({5}) - 5)<1e-4);
assert (abs(func0({6, 5}) - 5.5)<1e-4);
assert (abs(func0({8, 1, 3, 9, 9, 2, 7}) - 7)<1e-4 );
}
| O3 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov 0x8(%rdi),%r14
mov (%rdi),%rbx
mov %r14,%r12
sub %rbx,%r12
mov %r12,%rdx
sar $0x2,%rdx
mov %rdx,%rax
cmp %rbx,%r14
je 1652 <_Z5func0St6vect... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r13, [rdi+8]
mov rbp, [rdi]
mov r15, r13
sub r15, rbp
mov rax, r15
sar rax, 2
mov r14, rax
mov rcx, rax
cmp r13, rbp
jz loc_1943
mov [rsp+48h+var_4... | float func0(float **a1)
{
float *v1; // r13
float *v2; // rbp
long long v3; // r15
unsigned long long v4; // rax
long long v5; // r14
unsigned long long j; // rcx
float *v7; // rbx
unsigned long long v8; // rdx
float *v9; // r15
float v10; // xmm1_4
float *v11; // rdx
float v12; // xmm0_4
flo... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R13,qword ptr [RDI + 0x8]
MOV RBP,qword ptr [RDI]
MOV R15,R13
SUB R15,RBP
MOV RAX,R15
SAR RAX,0x2
MOV R14,RAX
MOV RCX,RAX
CMP R13,RBP
JZ 0x00101943
MOV qword ptr [RSP + 0x8],RAX
MOV R12,RDI
LEA RBX,[RBP + 0x4]
TEST RAX,RAX
JZ 0x001019... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<float, std::allocator<float> >) */
float func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7)
{
float *pfVar1;
long lVar2;
ulong uVar3;
float *pfVar4;... |
192 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string text){
string pr(text.rbegin(),text.rend());
return pr==text;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == true);
assert (func0("aba") == true);
assert (func0("aaaaa") == true);
assert (func0("zbcd") == false);
assert (func0("xywyx") == true);
assert (func0("xywyz") == false);
assert (func0("xywzx") == false);
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x51(%rbp),%rax
mov %rax,%rdi
callq 2330 <_ZNSaIcEC1Ev@plt>
lea ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_59]
mov [rbp+var_48], rax
nop
nop
lea rax, [rbp+var_50]
mov rdx, [rbp... | long long func0(long long a1)
{
unsigned int v1; // ebx
char v3; // [rsp+17h] [rbp-59h] BYREF
_BYTE v4[8]; // [rsp+18h] [rbp-58h] BYREF
_BYTE v5[8]; // [rsp+20h] [rbp-50h] BYREF
char *v6; // [rsp+28h] [rbp-48h]
_BYTE v7[40]; // [rsp+30h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+58h] [rbp-18h]
v8... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x59]
MOV qword ptr [RBP + -0x48],RAX
NOP
NOP
LEA RAX,[RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x68]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101250
LE... | /* func0(std::string) */
ulong func0(string *param_1)
{
bool bVar1;
int7 extraout_var;
long in_FS_OFFSET;
allocator local_61;
int local_60 [8];
int local_58 [8];
allocator *local_50;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_50 = &local_61;
std::s... |
193 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string text){
string pr(text.rbegin(),text.rend());
return pr==text;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == true);
assert (func0("aba") == true);
assert (func0("aaaaa") == true);
assert (func0("zbcd") == false);
assert (func0("xywyx") == true);
assert (func0("xywyz") == false);
assert (func0("xywzx") == false);
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%r12
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
mov (%rdi),%r13
mov 0x8(%rdi),%rbx
lea 0x0(%r13,%rbx,1),%rbp
lea 0x2... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
mov r13, [rdi]
mov r12, [rdi+8]
lea rbx, [r13+r12+0]
lea rax, [rsp+68h+var_48]
mov ... | long long func0(const void **a1)
{
const void *v1; // r13
unsigned long long v2; // r12
unsigned long long v3; // rbx
char *v4; // rax
char *v5; // rdx
char *v6; // rsi
unsigned int v7; // ebx
void *v8; // rdi
const void *v10; // rsi
size_t v11; // [rsp+8h] [rbp-60h] BYREF
void *s1; // [rsp+10h] ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV R13,qword ptr [RDI]
MOV R12,qword ptr [RDI + 0x8]
LEA RBX,[R13 + R12*0x1]
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],0x0
MOV qword pt... | /* func0(std::string) */
bool func0(int8 *param_1)
{
int *puVar1;
ulong uVar2;
int iVar3;
ulong *puVar4;
int *puVar5;
long in_FS_OFFSET;
bool bVar6;
size_t local_60;
ulong *local_58;
size_t local_50;
ulong local_48 [3];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
puVar1 = ... |
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.