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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
194 | 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);
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x40,%rsp
mov 0x8(%rdi),%rbx
mov (%rdi),%r14
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 40h
mov rbp, [rdi+8]
mov r14, [rdi]
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
lea r13, [rsp+68h+var_48]
mov [rsp+68h+n]... | long long func0(const void **a1)
{
unsigned long long v1; // rbp
char *v2; // r14
char *v3; // rbx
_QWORD *v4; // rax
char *v5; // rdx
_QWORD *v6; // rsi
char v7; // cl
unsigned int v8; // ebp
_QWORD *v9; // rbx
size_t v11; // [rsp+8h] [rbp-60h] BYREF
void *s1; // [rsp+10h] [rbp-58h] BYREF
size... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x40
MOV RBP,qword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA R13,[RSP + 0x20]
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x10],R13
LEA RBX,[R14 + RBP*0x1]
MOV... | /* func0(std::string) */
bool func0(int8 *param_1)
{
ulong uVar1;
int *puVar2;
int iVar3;
ulong *puVar4;
ulong *puVar5;
ulong *__s1;
int *puVar6;
long in_FS_OFFSET;
bool bVar7;
size_t local_60;
ulong *local_58;
size_t local_50;
ulong local_48 [3];
long local_30;
uVar1 = param_1[1];
... |
195 | 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);
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x40,%rsp
mov 0x8(%rdi),%rbx
mov (%rdi),%r14
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 40h
mov rbp, [rdi+8]
mov r14, [rdi]
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
lea r13, [rsp+68h+var_48]
mov [rsp+68h+n]... | long long func0(const void **a1)
{
unsigned long long v1; // rbp
char *v2; // r14
char *v3; // rbx
size_t v4; // rdx
_QWORD *v5; // rax
char *v6; // rdx
_QWORD *v7; // rsi
char v8; // cl
unsigned int v9; // ebp
_QWORD *v10; // rbx
size_t v12; // [rsp+8h] [rbp-60h] BYREF
void *s1; // [rsp+10h] [... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x40
MOV RBP,qword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA R13,[RSP + 0x20]
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x10],R13
LEA RBX,[R14 + RBP*0x1]
MOV... | /* func0(std::string) */
bool func0(int8 *param_1)
{
ulong uVar1;
int *puVar2;
int iVar3;
ulong *puVar4;
ulong *puVar5;
ulong *__s1;
int *puVar6;
long in_FS_OFFSET;
bool bVar7;
size_t local_60;
ulong *local_58;
size_t local_50;
ulong local_48 [3];
long local_30;
uVar1 = param_1[1];
... |
196 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n,int p){
int out=1;
for (int i=0;i<n;i++)
out=(out*2)%p;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 5) == 3);
assert (func0(1101, 101) == 2);
assert (func0(0, 101) == 1);
assert (func0(3, 11) == 8);
assert (func0(100, 101) == 1);
assert (func0(30, 5) == 4);
assert (func0(31, 5) == 3);
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jge 117f <_Z5func0ii+0x36>
mov -0x8(%rbp),%eax
add %eax,%eax
cltd
idivl -0x18(%rbp)
mov %edx,-0x8(%rbp)
addl $... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_1177
loc_1167:
mov eax, [rbp+var_8]
add eax, eax
cdq
idiv [rbp+var_18]
mov [rbp+var_8], edx
add [rbp+var_4], 1
loc_1177:
mov eax, [r... | long long func0(int a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-8h]
int i; // [rsp+14h] [rbp-4h]
v3 = 1;
for ( i = 0; i < a1; ++i )
v3 = (int)(2 * v3) % a2;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101177
LAB_00101167:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EAX
CDQ
IDIV dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x8],EDX
ADD dword ptr [RBP + -... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 1;
for (local_c = 0; local_c < param_1; local_c = local_c + 1) {
local_10 = (local_10 * 2) % param_2;
}
return local_10;
} |
197 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n,int p){
int out=1;
for (int i=0;i<n;i++)
out=(out*2)%p;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 5) == 3);
assert (func0(1101, 101) == 2);
assert (func0(0, 101) == 1);
assert (func0(3, 11) == 8);
assert (func0(100, 101) == 1);
assert (func0(30, 5) == 4);
assert (func0(31, 5) == 3);
}
| O1 | cpp | func0(int, int):
endbr64
test %edi,%edi
jle 116b <_Z5func0ii+0x22>
mov $0x0,%ecx
mov $0x1,%edx
lea (%rdx,%rdx,1),%eax
cltd
idiv %esi
add $0x1,%ecx
cmp %ecx,%edi
jne 115b <_Z5func0ii+0x12>
mov %edx,%eax
retq
mov $0x1,%edx
jmp 1168 <_Z5func0ii+0x1f>
| _Z5func0ii:
endbr64
test edi, edi
jle short loc_116B
mov ecx, 0
mov edx, 1
loc_115B:
lea eax, [rdx+rdx]
cdq
idiv esi
add ecx, 1
cmp edi, ecx
jnz short loc_115B
loc_1168:
mov eax, edx
retn
loc_116B:
mov edx, 1
jmp short loc_1168 | long long func0(int a1, int a2)
{
int v2; // ecx
unsigned int v3; // edx
if ( a1 <= 0 )
{
return 1;
}
else
{
v2 = 0;
v3 = 1;
do
{
v3 = (int)(2 * v3) % a2;
++v2;
}
while ( a1 != v2 );
}
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x0010116b
MOV ECX,0x0
MOV EDX,0x1
LAB_0010115b:
LEA EAX,[RDX + RDX*0x1]
CDQ
IDIV ESI
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x0010115b
LAB_00101168:
MOV EAX,EDX
RET
LAB_0010116b:
MOV EDX,0x1
JMP 0x00101168 | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 1;
}
else {
iVar1 = 0;
iVar2 = 1;
do {
iVar2 = (iVar2 * 2) % param_2;
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
}
return iVar2;
} |
198 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n,int p){
int out=1;
for (int i=0;i<n;i++)
out=(out*2)%p;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 5) == 3);
assert (func0(1101, 101) == 2);
assert (func0(0, 101) == 1);
assert (func0(3, 11) == 8);
assert (func0(100, 101) == 1);
assert (func0(30, 5) == 4);
assert (func0(31, 5) == 3);
}
| O2 | cpp | func0(int, int):
endbr64
test %edi,%edi
jle 12e0 <_Z5func0ii+0x20>
xor %ecx,%ecx
mov $0x1,%edx
lea (%rdx,%rdx,1),%eax
add $0x1,%ecx
cltd
idiv %esi
cmp %ecx,%edi
jne 12d0 <_Z5func0ii+0x10>
mov %edx,%eax
retq
mov $0x1,%edx
mov %edx,%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
test edi, edi
jle short loc_12E0
xor ecx, ecx
mov edx, 1
nop
loc_12D0:
lea eax, [rdx+rdx]
add ecx, 1
cdq
idiv esi
cmp edi, ecx
jnz short loc_12D0
mov eax, edx
retn
loc_12E0:
mov edx, 1
mov eax, edx
retn | long long func0(int a1, int a2)
{
int v2; // ecx
unsigned int v3; // edx
if ( a1 <= 0 )
return 1LL;
v2 = 0;
v3 = 1;
do
{
++v2;
v3 = (int)(2 * v3) % a2;
}
while ( a1 != v2 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001012e0
XOR ECX,ECX
MOV EDX,0x1
NOP
LAB_001012d0:
LEA EAX,[RDX + RDX*0x1]
ADD ECX,0x1
CDQ
IDIV ESI
CMP EDI,ECX
JNZ 0x001012d0
MOV EAX,EDX
RET
LAB_001012e0:
MOV EDX,0x1
MOV EAX,EDX
RET | /* func0(int, int) */
ulong func0(int param_1,int param_2)
{
ulong uVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar2 = 0;
iVar3 = 1;
do {
iVar2 = iVar2 + 1;
uVar1 = (long)(iVar3 * 2) % (long)param_2;
iVar3 = (int)uVar1;
} while (param_1 != iVar2);
return uVar1 & 0x... |
199 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n,int p){
int out=1;
for (int i=0;i<n;i++)
out=(out*2)%p;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 5) == 3);
assert (func0(1101, 101) == 2);
assert (func0(0, 101) == 1);
assert (func0(3, 11) == 8);
assert (func0(100, 101) == 1);
assert (func0(30, 5) == 4);
assert (func0(31, 5) == 3);
}
| O3 | cpp | func0(int, int):
endbr64
test %edi,%edi
jle 12e0 <_Z5func0ii+0x20>
xor %ecx,%ecx
mov $0x1,%edx
lea (%rdx,%rdx,1),%eax
add $0x1,%ecx
cltd
idiv %esi
cmp %ecx,%edi
jne 12d0 <_Z5func0ii+0x10>
mov %edx,%eax
retq
mov $0x1,%edx
mov %edx,%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
test edi, edi
jle short loc_12E0
xor ecx, ecx
mov edx, 1
nop
loc_12D0:
lea eax, [rdx+rdx]
add ecx, 1
cdq
idiv esi
cmp edi, ecx
jnz short loc_12D0
mov eax, edx
retn
loc_12E0:
mov edx, 1
mov eax, edx
retn | long long func0(int a1, int a2)
{
int v2; // ecx
unsigned int v3; // edx
if ( a1 <= 0 )
return 1LL;
v2 = 0;
v3 = 1;
do
{
++v2;
v3 = (int)(2 * v3) % a2;
}
while ( a1 != v2 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x001012e0
XOR ECX,ECX
MOV EDX,0x1
NOP
LAB_001012d0:
LEA EAX,[RDX + RDX*0x1]
ADD ECX,0x1
CDQ
IDIV ESI
CMP EDI,ECX
JNZ 0x001012d0
MOV EAX,EDX
RET
LAB_001012e0:
MOV EDX,0x1
MOV EAX,EDX
RET | /* func0(int, int) */
ulong func0(int param_1,int param_2)
{
ulong uVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar2 = 0;
iVar3 = 1;
do {
iVar2 = iVar2 + 1;
uVar1 = (long)(iVar3 * 2) % (long)param_2;
iVar3 = (int)uVar1;
} while (param_1 != iVar2);
return uVar1 & 0x... |
200 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string encode_shift(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+5-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| string func0(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+21-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| #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_shift(str);
assert (func0(encode... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x58(%rbp),%rax
mov %rax,%rdi
callq 2390 <_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_58]
mov rdi, rax
call __ZNSt7__cxx1112basic_stri... | long long func0(long long a1, long long a2)
{
int v2; // edx
int i; // [rsp+18h] [rbp-48h]
_BYTE v5[40]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v6; // [rsp+48h] [rbp-18h]
v6 = __readfsqword(0x28u);
std::string::basic_string(a1);
for ( i = 0; i < (unsigned long long)std::string::length(a2); ++i ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
CALL 0x00102380
MOV dword ptr [RBP + -0x48],0x0
JMP 0x001026cb
LAB_0010264c:
MOV E... | /* func0(std::string) */
string * func0(string *param_1,ulong param_2)
{
char *pcVar1;
ulong uVar2;
long in_FS_OFFSET;
int local_50;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::string::string(param_1);
local_50 = 0;
while( true ) {
uVar2 = std::strin... |
201 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string encode_shift(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+5-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| string func0(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+21-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| #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_shift(str);
assert (func0(encode... | 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 $0x38,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%r14
mov %r14,(%rdi)
movq $0x0,0x... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rsp+88h+var_80], rax
mov [rdi], rax
mov ... | void ** func0(void **a1, _QWORD *a2)
{
long long v4; // rbp
_BYTE *v5; // rax
void *v6; // rcx
unsigned long long v7; // r12
void *v8; // r15
char *v9; // rdx
unsigned long long v10; // rdi
_BYTE *v11; // rax
char *v12; // rsi
unsigned int v13; // ecx
unsigned int v14; // eax
char *v15; // rax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
CMP qword ptr [RSI +... | /* func0(std::string) */
ulong * func0(ulong *param_1,long *param_2)
{
ulong *puVar1;
ulong uVar2;
int iVar3;
uint uVar4;
int8 uVar5;
long lVar6;
uint uVar7;
ulong uVar8;
ulong uVar9;
long in_FS_OFFSET;
char local_69;
ulong *local_68;
int8 local_60;
ulong local_58 [5];
local_58[3] = *... |
202 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string encode_shift(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+5-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| string func0(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+21-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| #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_shift(str);
assert (func0(encode... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x0,0x8(%rdi)
cmpq $0x0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10... | long long func0(long long a1, _QWORD *a2)
{
bool v3; // zf
long long v4; // rbp
size_t v5; // r12
double v6; // rcx
int v7; // eax
double *v8; // rdi
size_t v9; // rdx
size_t v11; // rdx
double *v12; // rdi
double *v13; // [rsp+8h] [rbp-A0h]
long long v14; // [rsp+10h] [rbp-98h]
char v15; // [r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],0x0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
ulong *puVar1;
long lVar2;
int iVar3;
ulong uVar4;
ulong *__dest;
ulong uVar5;
long in_FS_OFFSET;
ulong *local_a0;
char local_69;
ulong *local_68;
size_t local_60;
ulong local_58 [3];
long local_40;
local_40 = *(long *... |
203 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string encode_shift(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+5-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| string func0(string s){
string out;
int i;
for (i=0;i<s.length();i++)
{
int w=((int)s[i]+21-(int)'a')%26+(int)'a';
out=out+(char)w;
}
return out;
}
| #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_shift(str);
assert (func0(encode... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x0,0x8(%rdi)
cmpq $0x0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10... | long long func0(long long a1, _QWORD *a2)
{
bool v3; // zf
unsigned long long v4; // rbp
size_t v5; // r12
double v6; // rcx
int v7; // eax
double *v8; // rdi
size_t v9; // rdx
size_t v11; // rdx
double *v12; // rdi
double *v13; // [rsp+8h] [rbp-A0h]
long long v14; // [rsp+10h] [rbp-98h]
char v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],0x0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
ulong *puVar1;
int iVar2;
long lVar3;
ulong *__dest;
ulong uVar4;
long in_FS_OFFSET;
ulong *local_a0;
char local_69;
ulong *local_68;
size_t local_60;
ulong local_58 [3];
long local_40;
local_40 = *(long *)(in_FS_OFFSET ... |
204 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string text){
string out="";
string vowels="AEIOUaeiou";
for (int i=0;i<text.length();i++)
if (find(vowels.begin(),vowels.end(),text[i])==vowels.end())
out=out+text[i];
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("abcdef\nghijklm") == "bcdf\nghjklm");
assert (func0("fedcba") == "fdcb");
assert (func0("eeeee") == "");
assert (func0("acBAA") == "cB");
assert (func0("EcBOO") == "cB");
assert (func0("ybcd") == "ybcd");
... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
add $0xffffffffffffff80,%rsp
mov %rdi,-0x88(%rbp)
mov %rsi,-0x90(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x68(%rbp),%rax
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 90h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_78]
mov [rbp+var_70], rax
nop
nop
lea ... | long long func0(long long a1, long long a2)
{
long long v2; // r12
long long v3; // rbx
long long v4; // rax
char *v5; // rax
int i; // [rsp+1Ch] [rbp-84h]
long long v8; // [rsp+20h] [rbp-80h] BYREF
_QWORD v9[3]; // [rsp+28h] [rbp-78h] BYREF
_BYTE v10[32]; // [rsp+40h] [rbp-60h] BYREF
_BYTE v11[40]; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x90
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x78]
MOV qword ptr [RBP + -0x70],RAX
NOP
NOP
LEA RDX,[RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x98]
L... | /* func0(std::string) */
string * func0(string *param_1,ulong param_2)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
char *pcVar4;
int4 extraout_var;
ulong uVar5;
long in_FS_OFFSET;
int local_8c;
int8 local_88;
int8 local_80;
int8 *local_78;
int8 *local_70;
string local_68 ... |
205 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string text){
string out="";
string vowels="AEIOUaeiou";
for (int i=0;i<text.length();i++)
if (find(vowels.begin(),vowels.end(),text[i])==vowels.end())
out=out+text[i];
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("abcdef\nghijklm") == "bcdf\nghjklm");
assert (func0("fedcba") == "fdcb");
assert (func0("eeeee") == "");
assert (func0("acBAA") == "cB");
assert (func0("EcBOO") == "cB");
assert (func0("ybcd") == "ybcd");
... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rdi,%r12
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
mov %rax,0x8(... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r12, rdi
mov rbp, rsi
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea r15, [rdi+10h]
mov [rdi], r15
lea rsi, asse... | void ** func0(void **a1, _QWORD *a2)
{
_QWORD *v4; // r15
long long v5; // rbx
char *v6; // rax
long long v7; // rdx
char *v8; // rdi
char *v9; // rsi
char *v10; // rcx
long long v11; // rax
unsigned long long v12; // r13
_BYTE *v13; // rax
void *v14; // rcx
char *v15; // rcx
unsigned long lon... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R12,RDI
MOV RBP,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA R15,[RDI + 0x10]
MOV qword ptr [RDI],R15
LEA RSI,[0x1020cd]
MOV RDX,RSI
LAB_00101302:
CALL 0x00101e16
LEA RDI,[RSP + 0x20]
LEA RAX,[RSP + 0... | /* func0(std::string) */
ulong * func0(ulong *param_1,long *param_2)
{
long *plVar1;
char cVar2;
ulong uVar3;
ulong *puVar4;
uint uVar5;
long *plVar6;
long lVar7;
int8 uVar8;
uint uVar9;
ulong uVar10;
ulong uVar11;
char *pcVar12;
long in_FS_OFFSET;
char local_89;
long *local_88;
long l... |
206 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string text){
string out="";
string vowels="AEIOUaeiou";
for (int i=0;i<text.length();i++)
if (find(vowels.begin(),vowels.end(),text[i])==vowels.end())
out=out+text[i];
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("abcdef\nghijklm") == "bcdf\nghjklm");
assert (func0("fedcba") == "fdcb");
assert (func0("eeeee") == "");
assert (func0("acBAA") == "cB");
assert (func0("EcBOO") == "cB");
assert (func0("ybcd") == "ybcd");
... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movb $0x0,0x10(%rdi)
cmpq $0x... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
mov rbp, rsi
lea rsi, assertion+0Fh; ""
push rbx
mov rdx, rsi
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rax... | void ** func0(void **a1, _QWORD *a2)
{
_BYTE *v4; // rdi
unsigned long long i; // rbx
_BYTE *v6; // rsi
_BYTE *v7; // rcx
long long v8; // rdx
_BYTE *v9; // rax
size_t v11; // r15
double *v12; // rax
double *v13; // rdi
size_t v14; // rdx
double v15; // rcx
double *v16; // [rsp+0h] [rbp-B8h]
_... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
LEA RSI,[0x10203e]
PUSH RBX
MOV RDX,RSI
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV qword ptr [RSP + 0x8],RAX
LAB_00101931:
CALL 0x00101840
LEA RAX... | /* func0(std::string) */
ulong * func0(ulong *param_1,long *param_2)
{
char cVar1;
ulong uVar2;
ulong uVar3;
long *plVar4;
long lVar5;
ulong uVar6;
long *plVar7;
ulong *__dest;
long in_FS_OFFSET;
char local_89;
long *local_88;
long local_80;
long local_78 [2];
ulong *local_68;
size_t loc... |
207 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string text){
string out="";
string vowels="AEIOUaeiou";
for (int i=0;i<text.length();i++)
if (find(vowels.begin(),vowels.end(),text[i])==vowels.end())
out=out+text[i];
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("abcdef\nghijklm") == "bcdf\nghjklm");
assert (func0("fedcba") == "fdcb");
assert (func0("eeeee") == "");
assert (func0("acBAA") == "cB");
assert (func0("EcBOO") == "cB");
assert (func0("ybcd") == "ybcd");
... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x88,%rsp
mov 0x8(%rsi),%r8
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x0,... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov qword ptr [rdi+8], 0
mov [rdi], rax
mov ... | void ** func0(void **a1, _QWORD *a2)
{
long long *v3; // rax
unsigned long long v4; // r8
_QWORD *v5; // rdi
unsigned long long v7; // rbx
long long i; // rax
_BYTE *v9; // rsi
_BYTE *v10; // rcx
long long v11; // rax
long long v12; // rdx
_BYTE *v13; // rax
size_t v14; // r15
void *v15; // rax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI],RAX
MOV byte ptr [RDI + 0x10],0x0
MOV R8,qword ptr [RSI + 0x8]
LEA RDI,[RSP + 0x40]
... | /* func0(std::string) */
ulong * func0(ulong *param_1,long *param_2)
{
char cVar1;
ulong uVar2;
long *plVar3;
ulong *puVar4;
long lVar5;
long lVar6;
long *plVar7;
ulong uVar8;
long in_FS_OFFSET;
char local_89;
long *local_88;
long local_80;
long local_78;
int2 local_70;
int local_6e;
u... |
208 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int>l, int t){
for (int i=0;i<l.size();i++)
if (l[i]>=t) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 4, 10}, 100));
assert (not(func0({1, 20, 4, 10}, 5)));
assert (func0({1, 20, 4, 10}, 21));
assert (func0({1, 20, 4, 10}, 22));
assert (func0({1, 8, 4, 10}, 11));
assert (not(func0({1, 8, 4, 10}, 10)));
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1806 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp ... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_14], 0
jmp short loc_1292
loc_1266:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6... | long long func0(long long a1, int a2)
{
int i; // [rsp+1Ch] [rbp-14h]
for ( i = 0; i < (unsigned long long)std::vector<int>::size(a1); ++i )
{
if ( a2 <= *(_DWORD *)std::vector<int>::operator[](a1, i) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101292
LAB_00101266:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101900
MOV EAX,dword ptr ... | /* func0(std::vector<int, std::allocator<int> >, int) */
int8 func0(vector param_1,int param_2)
{
int *piVar1;
ulong uVar2;
int4 in_register_0000003c;
int local_1c;
local_1c = 0;
while( true ) {
uVar2 = std::vector<int,std::allocator<int>>::size
((vector<int,std::allocator<int... |
209 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int>l, int t){
for (int i=0;i<l.size();i++)
if (l[i]>=t) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 4, 10}, 100));
assert (not(func0({1, 20, 4, 10}, 5)));
assert (func0({1, 20, 4, 10}, 21));
assert (func0({1, 20, 4, 10}, 22));
assert (func0({1, 8, 4, 10}, 11));
assert (not(func0({1, 8, 4, 10}, 10)));
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rax
sub %rdx,%rax
sar $0x2,%rax
mov %rax,%rcx
je 1239 <_Z5func0St6vectorIiSaIiEEi+0x30>
mov $0x0,%eax
cmp %esi,(%rdx,%rax,4)
jge 123f <_Z5func0St6vectorIiSaIiEEi+0x36>
add $0x1,%rax
cmp %rcx,%rax... | _Z5func0St6vectorIiSaIiEEi:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_123C
mov eax, 0
loc_1228:
cmp [rdx+rax*4], esi
jge short loc_1242
add rax, 1
cmp rax, rcx
jb short loc_1228
mov eax, 1
retn
loc_123... | long long func0(_QWORD *a1, int a2)
{
long long v2; // rax
if ( a1[1] == *a1 )
return 1LL;
v2 = 0LL;
while ( *(_DWORD *)(*a1 + 4 * v2) < a2 )
{
if ( ++v2 >= (unsigned long long)((long long)(a1[1] - *a1) >> 2) )
return 1LL;
}
return 0LL;
} | 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 0x0010123c
MOV EAX,0x0
LAB_00101228:
CMP dword ptr [RDX + RAX*0x4],ESI
JGE 0x00101242
ADD RAX,0x1
CMP RAX,RCX
JC 0x00101228
MOV EAX,0x1
RET
LAB_0010123c:
MOV EAX,0x1
RET
LAB_00101242:
MOV EAX,0x0
RET | /* func0(std::vector<int, std::allocator<int> >, int) */
int8 func0(vector param_1,int param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
int4 in_register_0000003c;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
if (lVar1 == lVar2)... |
210 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int>l, int t){
for (int i=0;i<l.size();i++)
if (l[i]>=t) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 4, 10}, 100));
assert (not(func0({1, 20, 4, 10}, 5)));
assert (func0({1, 20, 4, 10}, 21));
assert (func0({1, 20, 4, 10}, 22));
assert (func0({1, 8, 4, 10}, 11));
assert (not(func0({1, 8, 4, 10}, 10)));
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
je 15d8 <_Z5func0St6vectorIiSaIiEEi+0x38>
xor %eax,%eax
jmp 15c9 <_Z5func0St6vectorIiSaIiEEi+0x29>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %rdx,%rax
je 15d8 <_Z5fu... | _Z5func0St6vectorIiSaIiEEi:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_14A8
xor eax, eax
jmp short loc_1499
loc_1490:
add rax, 1
cmp rax, rcx
jnb short loc_14A8
loc_1499:
cmp [rdx+rax*4], esi
jl short l... | long long func0(_QWORD *a1, int a2)
{
long long v2; // rax
if ( a1[1] == *a1 )
return 1LL;
v2 = 0LL;
while ( *(_DWORD *)(*a1 + 4 * v2) < a2 )
{
if ( ++v2 >= (unsigned long long)((long long)(a1[1] - *a1) >> 2) )
return 1LL;
}
return 0LL;
} | 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 0x001014a8
XOR EAX,EAX
JMP 0x00101499
LAB_00101490:
ADD RAX,0x1
CMP RAX,RCX
JNC 0x001014a8
LAB_00101499:
CMP dword ptr [RDX + RAX*0x4],ESI
JL 0x00101490
XOR EAX,EAX
RET
LAB_001014a8:
MOV EAX,0x1
RET | /* func0(std::vector<int, std::allocator<int> >, int) */
int8 func0(vector param_1,int param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
int4 in_register_0000003c;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
if (lVar1 != lVar2)... |
211 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int>l, int t){
for (int i=0;i<l.size();i++)
if (l[i]>=t) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 4, 10}, 100));
assert (not(func0({1, 20, 4, 10}, 5)));
assert (func0({1, 20, 4, 10}, 21));
assert (func0({1, 20, 4, 10}, 22));
assert (func0({1, 8, 4, 10}, 11));
assert (not(func0({1, 8, 4, 10}, 10)));
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
je 1568 <_Z5func0St6vectorIiSaIiEEi+0x38>
xor %eax,%eax
jmp 1559 <_Z5func0St6vectorIiSaIiEEi+0x29>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %rdx,%rax
je 1568 <_Z5fu... | _Z5func0St6vectorIiSaIiEEi:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_1588
xor eax, eax
jmp short loc_1579
loc_1570:
add rax, 1
cmp rax, rcx
jnb short loc_1588
loc_1579:
cmp [rdx+rax*4], esi
jl short l... | long long func0(_QWORD *a1, int a2)
{
long long v2; // rax
if ( a1[1] == *a1 )
return 1LL;
v2 = 0LL;
while ( *(_DWORD *)(*a1 + 4 * v2) < a2 )
{
if ( ++v2 >= (unsigned long long)((long long)(a1[1] - *a1) >> 2) )
return 1LL;
}
return 0LL;
} | 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 0x00101588
XOR EAX,EAX
JMP 0x00101579
LAB_00101570:
ADD RAX,0x1
CMP RAX,RCX
JNC 0x00101588
LAB_00101579:
CMP dword ptr [RDX + RAX*0x4],ESI
JL 0x00101570
XOR EAX,EAX
RET
LAB_00101588:
MOV EAX,0x1
RET | /* func0(std::vector<int, std::allocator<int> >, int) */
int8 func0(vector param_1,int param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
int4 in_register_0000003c;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
if (lVar1 != lVar2)... |
212 | func0 | #include<stdio.h>
#include<stdlib.h>
using namespace std;
#include<algorithm>
#include<math.h>
| int func0(int x,int y){
return x+y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0, 1) == 1);
assert (func0(1, 0) == 1);
assert (func0(2, 3) == 5);
assert (func0(5, 7) == 12);
assert (func0(7, 5) == 12);
for (int i=0;i<100;i+=1)
{
int x=rand()%1000;
int y=rand()%1000;
assert (func0(x, y) ... | O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
pop %rbp
retq
| _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
add eax, edx
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
POP RBP
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return param_2 + param_1;
} |
213 | func0 | #include<stdio.h>
#include<stdlib.h>
using namespace std;
#include<algorithm>
#include<math.h>
| int func0(int x,int y){
return x+y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0, 1) == 1);
assert (func0(1, 0) == 1);
assert (func0(2, 3) == 5);
assert (func0(5, 7) == 12);
assert (func0(7, 5) == 12);
for (int i=0;i<100;i+=1)
{
int x=rand()%1000;
int y=rand()%1000;
assert (func0(x, y) ... | O1 | cpp | func0(int, int):
endbr64
lea (%rdi,%rsi,1),%eax
retq
| _Z5func0ii:
endbr64
lea eax, [rdi+rsi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return param_1 + param_2;
} |
214 | func0 | #include<stdio.h>
#include<stdlib.h>
using namespace std;
#include<algorithm>
#include<math.h>
| int func0(int x,int y){
return x+y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0, 1) == 1);
assert (func0(1, 0) == 1);
assert (func0(2, 3) == 5);
assert (func0(5, 7) == 12);
assert (func0(7, 5) == 12);
for (int i=0;i<100;i+=1)
{
int x=rand()%1000;
int y=rand()%1000;
assert (func0(x, y) ... | O2 | cpp | func0(int, int):
endbr64
lea (%rdi,%rsi,1),%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
lea eax, [rdi+rsi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return param_1 + param_2;
} |
215 | func0 | #include<stdio.h>
#include<stdlib.h>
using namespace std;
#include<algorithm>
#include<math.h>
| int func0(int x,int y){
return x+y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0, 1) == 1);
assert (func0(1, 0) == 1);
assert (func0(2, 3) == 5);
assert (func0(5, 7) == 12);
assert (func0(7, 5) == 12);
for (int i=0;i<100;i+=1)
{
int x=rand()%1000;
int y=rand()%1000;
assert (func0(x, y) ... | O3 | cpp | func0(int, int):
endbr64
lea (%rdi,%rsi,1),%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
lea eax, [rdi+rsi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 + a2);
} | func0:
ENDBR64
LEA EAX,[RDI + RSI*0x1]
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return param_1 + param_2;
} |
216 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string s0,string s1){
for (int i=0;i<s0.length();i++)
if (find(s1.begin(),s1.end(),s0[i])==s1.end())
return false;
for (int i=0;i<s1.length();i++)
if (find(s0.begin(),s0.end(),s1[i])==s0.end())
return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert (func0("abcd", "dddddddabc") == true);
assert (func0("dddddddabc", "abcd") == true);
assert (func0("eabcd", "dddddddabc") == false);
assert (func0("abcd", "dddddddabcf") == false);
ass... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x30,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %fs:0x28,%rax
mov... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
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 [rbp+var_30], 0
jmp short loc_1432
loc_13B8:
mov ... | long long func0(long long a1, long long a2)
{
long long v2; // r12
long long v3; // rbx
long long v4; // rax
long long v6; // r12
long long v7; // rbx
long long v8; // rax
int i; // [rsp+10h] [rbp-30h]
int j; // [rsp+14h] [rbp-2Ch]
long long v11; // [rsp+18h] [rbp-28h] BYREF
_QWORD v12[4]; // [rsp+... | 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 dword ptr [RBP + -0x30],0x0
JMP 0x00101432
LAB_001013b8:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101... | /* func0(std::string, std::string) */
int8 func0(ulong param_1,ulong param_2)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int4 extraout_var;
ulong uVar4;
char *pcVar5;
int4 extraout_var_00;
int8 uVar6;
long in_FS_OFFSET;
int local_38;
int local_34;
int8 local_30;
int8 loc... |
217 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string s0,string s1){
for (int i=0;i<s0.length();i++)
if (find(s1.begin(),s1.end(),s0[i])==s1.end())
return false;
for (int i=0;i<s1.length();i++)
if (find(s0.begin(),s0.end(),s1[i])==s0.end())
return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert (func0("abcd", "dddddddabc") == true);
assert (func0("dddddddabc", "abcd") == true);
assert (func0("eabcd", "dddddddabc") == false);
assert (func0("abcd", "dddddddabcf") == false);
ass... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%r12
mov $0x0,%ebx
cmpq $0x0,0x8(%rdi)
je ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rdi
mov r12, rsi
mov r14, [rdi+8]
test r14, r14
jz short loc_1278
mov ebx, 0
loc_124F:
mov rdi, [r12]
mov rbp, rdi
add ... | long long func0(_QWORD *a1, _QWORD *a2)
{
long long v2; // r14
long long v3; // rbx
long long v4; // rbp
long long v5; // r15
long long v6; // rbx
long long v7; // rbp
v2 = a1[1];
if ( v2 )
{
v3 = 0LL;
while ( 1 )
{
v4 = a2[1] + *a2;
if ( v4 == std::__find_if<__gnu_cxx::__nor... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV R12,RSI
MOV R14,qword ptr [RDI + 0x8]
TEST R14,R14
JZ 0x00101278
MOV EBX,0x0
LAB_0010124f:
MOV RDI,qword ptr [R12]
MOV RBP,RDI
ADD RBP,qword ptr [R12 + 0x8]
MOV RDX,RBX
ADD RDX,qword ptr [R13]
MOV RSI,RBP
CALL 0x00101850
CM... | /* func0(std::string, std::string) */
int8 func0(long *param_1,long *param_2,int8 param_3,random_access_iterator_tag param_4)
{
long lVar1;
long lVar2;
__normal_iterator _Var3;
int4 extraout_var;
int4 extraout_var_00;
long lVar4;
long lVar5;
lVar2 = param_1[1];
if (lVar2 != 0) {
lVar4 = 0;
... |
218 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string s0,string s1){
for (int i=0;i<s0.length();i++)
if (find(s1.begin(),s1.end(),s0[i])==s1.end())
return false;
for (int i=0;i<s1.length();i++)
if (find(s0.begin(),s0.end(),s1[i])==s0.end())
return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert (func0("abcd", "dddddddabc") == true);
assert (func0("dddddddabc", "abcd") == true);
assert (func0("eabcd", "dddddddabc") == false);
assert (func0("abcd", "dddddddabcf") == false);
ass... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
mov %rsi,%r12
push %rbp
mov %rdi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
cmpq $0x0,0x8(%rdi)
jne ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r12
mov r12, rdi
push rbp
mov rbp, rsi
push rbx
mov r9, [rdi+8]
mov rbx, [rsi+8]
test r9, r9
jz short loc_16C0
mov r10, [rsi]
mov r8, [rdi]
lea rsi, [r10+rbx]
lea r11, [r8+r9]
jmp short loc... | long long func0(long long *a1, long long *a2)
{
long long v3; // r9
long long v4; // rbx
long long v5; // r10
long long v6; // r8
long long v7; // rsi
long long v8; // r8
long long v9; // r11
long long v11; // r10
long long v12; // r8
long long v13; // r9
long long v14; // rbx
long long v15; //... | func0:
ENDBR64
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV R9,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RSI + 0x8]
TEST R9,R9
JZ 0x001016c0
MOV R10,qword ptr [RSI]
MOV R8,qword ptr [RDI]
LEA RSI,[R10 + RBX*0x1]
LEA R11,[R8 + R9*0x1]
JMP 0x001016a9
LAB_001016a0:
ADD R8,0x1
CMP R8,R11
JZ 0x001016c0
LAB_001016a9... | /* func0(std::string, std::string) */
int8 func0(long *param_1,long *param_2,int8 param_3,random_access_iterator_tag param_4)
{
__normal_iterator _Var1;
int4 extraout_var;
int4 extraout_var_00;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
lVar6 = param_1[1];
lVar2 =... |
219 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| bool func0(string s0,string s1){
for (int i=0;i<s0.length();i++)
if (find(s1.begin(),s1.end(),s0[i])==s1.end())
return false;
for (int i=0;i<s1.length();i++)
if (find(s0.begin(),s0.end(),s1[i])==s0.end())
return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("eabcdzzzz", "dddzzzzzzzddeddabc") == true);
assert (func0("abcd", "dddddddabc") == true);
assert (func0("dddddddabc", "abcd") == true);
assert (func0("eabcd", "dddddddabc") == false);
assert (func0("abcd", "dddddddabcf") == false);
ass... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
xor %ebx,%ebx
sub $0x8,%rsp
mov 0x8(%rdi),%rax
test ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r12
mov r12, rdi
push rbp
mov rbp, rsi
push rbx
mov r9, [rdi+8]
mov rbx, [rsi+8]
test r9, r9
jz short loc_1760
mov r10, [rsi]
mov r8, [rdi]
lea rsi, [r10+rbx]
lea r11, [r8+r9]
jmp short loc... | long long func0(long long *a1, long long *a2)
{
long long v3; // r9
long long v4; // rbx
long long v5; // r10
long long v6; // r8
long long v7; // rsi
long long v8; // r8
long long v9; // r11
long long v11; // r10
long long v12; // r8
long long v13; // r9
long long v14; // rbx
long long v15; //... | func0:
ENDBR64
PUSH R12
MOV R12,RDI
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV R9,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RSI + 0x8]
TEST R9,R9
JZ 0x00101760
MOV R10,qword ptr [RSI]
MOV R8,qword ptr [RDI]
LEA RSI,[R10 + RBX*0x1]
LEA R11,[R8 + R9*0x1]
JMP 0x00101749
LAB_00101740:
ADD R8,0x1
CMP R11,R8
JZ 0x00101760
LAB_00101749... | /* func0(std::string, std::string) */
int8 func0(long *param_1,long *param_2,int8 param_3,random_access_iterator_tag param_4)
{
__normal_iterator _Var1;
int4 extraout_var;
int4 extraout_var_00;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
lVar6 = param_1[1];
lVar2 =... |
220 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f[1000];
f[0]=0;f[1]=1;
for (int i=2;i<=n; i++)
f[i]=f[i-1]+f[i-2];
return f[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(10) == 55);
assert (func0(1) == 1);
assert (func0(8) == 21);
assert (func0(11) == 89);
assert (func0(12) == 144);
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0xfd0,%rsp
mov %edi,-0xfc4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0xfb0(%rbp)
movl $0x1,-0xfac(%rbp)
movl $0x2,-0xfb4(%rbp)
mov -0xfb4(%rbp),%eax
cmp -0xfc4(%rbp),%eax
jg 11f7 <_Z5func0i+0x8e>
mov -0xfb... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0FD0h
mov [rbp+var_FC4], edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_FB0], 0
mov [rbp+var_FAC], 1
mov [rbp+var_FB4], 2
jmp short loc_11E9
loc_11AD:
mov eax, [rbp+var_FB4]
sub eax, 1
cdqe
mov e... | long long func0(int a1)
{
int i; // [rsp+1Ch] [rbp-FB4h]
_DWORD v3[1002]; // [rsp+20h] [rbp-FB0h]
unsigned long long v4; // [rsp+FC8h] [rbp-8h]
v4 = __readfsqword(0x28u);
v3[0] = 0;
v3[1] = 1;
for ( i = 2; i <= a1; ++i )
v3[i] = v3[i - 2] + v3[i - 1];
return (unsigned int)v3[a1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xfd0
MOV dword ptr [RBP + -0xfc4],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0xfb0],0x0
MOV dword ptr [RBP + -0xfac],0x1
MOV dword ptr [RBP + -0xfb4],0x2
JMP 0x001011e9
LAB_001011ad:
MOV EAX,dword ptr [RBP + -0xfb4]
SUB E... | /* func0(int) */
int func0(int param_1)
{
long in_FS_OFFSET;
int local_fbc;
int local_fb8 [1002];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_fb8[0] = 0;
local_fb8[1] = 1;
for (local_fbc = 2; local_fbc <= param_1; local_fbc = local_fbc + 1) {
local_fb8[local_fbc] = local_fb8... |
221 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f[1000];
f[0]=0;f[1]=1;
for (int i=2;i<=n; i++)
f[i]=f[i-1]+f[i-2];
return f[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(10) == 55);
assert (func0(1) == 1);
assert (func0(8) == 21);
assert (func0(11) == 89);
assert (func0(12) == 144);
}
| O1 | cpp | func0(int):
endbr64
sub $0xfb8,%rsp
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
movl $0x0,(%rsp)
movl $0x1,0x4(%rsp)
cmp $0x1,%edi
jle 11b7 <_Z5func0i+0x4e>
mov %rsp,%rax
lea -0x2(%rdi),%edx
lea 0x4(%rsp,%rdx,4),%rcx
mov (%rax),%edx
add 0x4(%rax),%edx
mov %edx,0x8(%rax)
... | _Z5func0i:
endbr64
sub rsp, 0FB8h
mov rax, fs:28h
mov [rsp+0FB8h+var_10], rax
xor eax, eax
mov [rsp+0FB8h+var_FB8], 0
mov [rsp+0FB8h+var_FB4], 1
cmp edi, 1
jle short loc_11B7
mov rax, rsp
lea edx, [rdi-2]
lea rcx, [rsp+rdx*4+0FB8h+var_FB4]
loc_11A6:
mov edx, [rax]
add ... | long long func0(int a1)
{
int *v1; // rax
int v3; // [rsp+0h] [rbp-FB8h] BYREF
_DWORD v4[1001]; // [rsp+4h] [rbp-FB4h] BYREF
unsigned long long v5; // [rsp+FA8h] [rbp-10h]
v5 = __readfsqword(0x28u);
v3 = 0;
v4[0] = 1;
if ( a1 > 1 )
{
v1 = &v3;
do
{
v1[2] = v1[1] + *v1;
++v1;
... | func0:
ENDBR64
SUB RSP,0xfb8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x4],0x1
CMP EDI,0x1
JLE 0x001011b7
MOV RAX,RSP
LEA EDX,[RDI + -0x2]
LEA RCX,[RSP + RDX*0x4 + 0x4]
LAB_001011a6:
MOV EDX,dword ptr [RAX]
ADD EDX,dword ptr [RAX + 0x4]
MOV dwo... | /* func0(int) */
int func0(int param_1)
{
int *piVar1;
long in_FS_OFFSET;
int local_fb8 [1002];
long local_10;
piVar1 = local_fb8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_fb8[0] = 0;
local_fb8[1] = 1;
if (1 < param_1) {
do {
piVar1[2] = *piVar1 + piVar1[1];
piVar1 = piVar... |
222 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f[1000];
f[0]=0;f[1]=1;
for (int i=2;i<=n; i++)
f[i]=f[i-1]+f[i-2];
return f[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(10) == 55);
assert (func0(1) == 1);
assert (func0(8) == 21);
assert (func0(11) == 89);
assert (func0(12) == 144);
}
| O2 | cpp | func0(int):
endbr64
sub $0xfb8,%rsp
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
movabs $0x100000000,%rax
mov %rax,(%rsp)
cmp $0x1,%edi
jle 12d0 <_Z5func0i+0x60>
lea -0x2(%rdi),%edx
lea 0x8(%rsp),%rax
xor %ecx,%ecx
lea (%rax,%rdx,4),%rsi
mov $0x1,%edx
jmp 12c7 <_Z5func0i+0... | _Z5func0i:
endbr64
sub rsp, 0FB8h
mov rax, fs:28h
mov [rsp+0FB8h+var_10], rax
xor eax, eax
mov rax, cs:qword_2088
mov [rsp+0FB8h+var_FB8], rax
cmp edi, 1
jle short loc_12CA
lea eax, [rdi-2]
lea rdx, [rsp+0FB8h+var_FB0]
xor ecx, ecx
lea r8, [rsp+rax*4+0FB8h+var_FAC]
mov ... | long long func0(int a1)
{
_BYTE *v1; // rdx
int v2; // ecx
int v3; // eax
int v4; // esi
long long v6; // [rsp+0h] [rbp-FB8h]
_BYTE v7[4000]; // [rsp+8h] [rbp-FB0h] BYREF
unsigned long long v8; // [rsp+FA8h] [rbp-10h]
v8 = __readfsqword(0x28u);
v6 = 0x100000000LL;
if ( a1 > 1 )
{
v1 = v7;
... | func0:
ENDBR64
SUB RSP,0xfb8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [0x00102088]
MOV qword ptr [RSP],RAX
CMP EDI,0x1
JLE 0x001012ca
LEA EAX,[RDI + -0x2]
LEA RDX,[RSP + 0x8]
XOR ECX,ECX
LEA R8,[RSP + RAX*0x4 + 0xc]
MOV EAX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_001012b8:
... | /* func0(int) */
int4 func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int *piVar5;
long in_FS_OFFSET;
int8 local_fb8;
int local_fb0 [1000];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_fb8 = DAT_00102088;
if (1 < param_1) {
piVar4 = local_fb0;
i... |
223 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int f[1000];
f[0]=0;f[1]=1;
for (int i=2;i<=n; i++)
f[i]=f[i-1]+f[i-2];
return f[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(10) == 55);
assert (func0(1) == 1);
assert (func0(8) == 21);
assert (func0(11) == 89);
assert (func0(12) == 144);
}
| O3 | cpp | func0(int):
endbr64
sub $0xfb8,%rsp
mov %fs:0x28,%rax
mov %rax,0xfa8(%rsp)
xor %eax,%eax
movabs $0x100000000,%rax
mov %rax,(%rsp)
cmp $0x1,%edi
jle 12f4 <_Z5func0i+0x84>
cmp $0x3,%edi
jle 1315 <_Z5func0i+0xa5>
lea -0x4(%rdi),%eax
lea 0x8(%rsp),%r8
mov $0x1,%esi
xor %edx,%edx
and ... | _Z5func0i:
endbr64
sub rsp, 0FB8h
mov rax, fs:28h
mov [rsp+0FB8h+var_10], rax
xor eax, eax
mov rax, cs:qword_2088
mov [rsp+0FB8h+var_FB8], rax
cmp edi, 1
jle short loc_12F4
cmp edi, 3
jle short loc_1315
lea ecx, [rdi-4]
lea rsi, [rsp+0FB8h+var_FB0]
mov edx, 1
xor ... | long long func0(int a1)
{
char *v1; // rsi
int v2; // edx
int v3; // eax
int v4; // r8d
signed int v5; // ecx
char *v6; // rax
int v7; // edx
long long v9; // [rsp+0h] [rbp-FB8h] BYREF
char v10; // [rsp+8h] [rbp-FB0h] BYREF
unsigned long long v11; // [rsp+FA8h] [rbp-10h]
v11 = __readfsqword(0x28... | func0:
ENDBR64
SUB RSP,0xfb8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xfa8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [0x00102088]
MOV qword ptr [RSP],RAX
CMP EDI,0x1
JLE 0x001012f4
CMP EDI,0x3
JLE 0x00101315
LEA ECX,[RDI + -0x4]
LEA RSI,[RSP + 0x8]
MOV EDX,0x1
XOR EAX,EAX
AND ECX,0xfffffffe
MOV R8D,0x2
ADD ECX,0x4
LA... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
long in_FS_OFFSET;
int local_fb0 [1000];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (1 < param_1) {
if (param_1 < 4) {
iVar3 = 2;
}
else {
iVar4 = 1;
... |
224 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string brackets){
int level=0;
for (int i=0;i<brackets.length();i++)
{
if (brackets[i]=='<') level+=1;
if (brackets[i]=='>') level-=1;
if (level<0) return false;
}
if (level!=0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("<>"));
assert (func0("<<><>>"));
assert (func0("<><><<><>><>"));
assert (func0("<><><<<><><>><>><<><><<>>>"));
assert (not (func0("<<<><>>>>")));
assert (not (func0("><<>")));
assert (not (func0("<")));
assert (not (func0("<<<<... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1290... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_13C5
loc_136A:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx... | _BOOL8 func0(long long a1)
{
int v2; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = 0;
for ( i = 0; i < (unsigned long long)std::string::length(a1); ++i )
{
if ( *(_BYTE *)std::string::operator[](a1, i) == 60 )
++v2;
if ( *(_BYTE *)std::string::operator[](a1, i) == 62 )
--v2;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001013c5
LAB_0010136a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101250
MOVZX EAX,byte ptr... | /* func0(std::string) */
bool func0(ulong param_1)
{
char *pcVar1;
ulong uVar2;
int local_20;
int local_1c;
local_20 = 0;
local_1c = 0;
while( true ) {
uVar2 = std::string::length();
if (uVar2 <= (ulong)(long)local_1c) {
return local_20 == 0;
}
pcVar1 = (char *)std::string::oper... |
225 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string brackets){
int level=0;
for (int i=0;i<brackets.length();i++)
{
if (brackets[i]=='<') level+=1;
if (brackets[i]=='>') level-=1;
if (level<0) return false;
}
if (level!=0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("<>"));
assert (func0("<<><>>"));
assert (func0("<><><<><>><>"));
assert (func0("<><><<<><><>><>><<><><<>>>"));
assert (not (func0("<<<><>>>>")));
assert (not (func0("><<>")));
assert (not (func0("<")));
assert (not (func0("<<<<... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
test %rsi,%rsi
je 1228 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3f>
mov (%rdi),%rax
add %rax,%rsi
mov $0x0,%edx
jmp 121b <_Z5func0NSt7__cxx1112basic_stringIcSt11... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
test rsi, rsi
jz short loc_1247
mov rax, [rdi]
add rsi, rax
mov ecx, 0
jmp short loc_122F
loc_1223:
add ecx, 1
loc_1226:
add rax, 1
cmp rax, rsi
jz short loc_124C
loc_122F:
movzx edx, by... | bool func0(long long a1)
{
long long v1; // rsi
_BYTE *v2; // rax
_BYTE *v3; // rsi
int v4; // ecx
v1 = *(_QWORD *)(a1 + 8);
if ( v1 )
{
v2 = *(_BYTE **)a1;
v3 = (_BYTE *)(*(_QWORD *)a1 + v1);
v4 = 0;
while ( 1 )
{
if ( *v2 == 60 )
{
++v4;
}
else if ( ... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x00101247
MOV RAX,qword ptr [RDI]
ADD RSI,RAX
MOV ECX,0x0
JMP 0x0010122f
LAB_00101223:
ADD ECX,0x1
LAB_00101226:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x0010124c
LAB_0010122f:
MOVZX EDX,byte ptr [RAX]
CMP DL,0x3c
JZ 0x00101223
CMP DL,0x3e
JNZ 0x00101226
SUB ECX,0x1
JNS... | /* func0(std::string) */
bool func0(int8 *param_1)
{
char *pcVar1;
int iVar2;
char *pcVar3;
if (param_1[1] == 0) {
iVar2 = 0;
}
else {
pcVar1 = (char *)*param_1;
pcVar3 = pcVar1 + param_1[1];
iVar2 = 0;
do {
if (*pcVar1 == '<') {
iVar2 = iVar2 + 1;
}
else i... |
226 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string brackets){
int level=0;
for (int i=0;i<brackets.length();i++)
{
if (brackets[i]=='<') level+=1;
if (brackets[i]=='>') level-=1;
if (level<0) return false;
}
if (level!=0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("<>"));
assert (func0("<<><>>"));
assert (func0("<><><<><>><>"));
assert (func0("<><><<<><><>><>><<><><<>>>"));
assert (not (func0("<<<><>>>>")));
assert (not (func0("><<>")));
assert (not (func0("<")));
assert (not (func0("<<<<... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
test %rsi,%rsi
je 1883 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x53>
mov (%rdi),%rax
xor %ecx,%ecx
add %rax,%rsi
jmp 1866 <_Z5func0NSt7__cxx1112basic_stringIcSt11... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
test rsi, rsi
jz short loc_15F3
mov rax, [rdi]
xor ecx, ecx
add rsi, rax
jmp short loc_15D3
loc_15C0:
cmp dl, 3Eh ; '>'
jnz short loc_15CA
sub ecx, 1
jb short loc_15F0
loc_15CA:
add ra... | char func0(long long a1)
{
long long v1; // rsi
_BYTE *v2; // rax
int v3; // ecx
_BYTE *v4; // rsi
v1 = *(_QWORD *)(a1 + 8);
if ( !v1 )
return 1;
v2 = *(_BYTE **)a1;
v3 = 0;
v4 = (_BYTE *)(*(_QWORD *)a1 + v1);
while ( 1 )
{
while ( *v2 == 60 )
{
++v2;
++v3;
if ( v2 ... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x001015f3
MOV RAX,qword ptr [RDI]
XOR ECX,ECX
ADD RSI,RAX
JMP 0x001015d3
LAB_001015c0:
CMP DL,0x3e
JNZ 0x001015ca
SUB ECX,0x1
JC 0x001015f0
LAB_001015ca:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x001015e7
LAB_001015d3:
MOVZX EDX,byte ptr [RAX]
CMP DL,0x3c
JNZ 0x001015c0
... | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
bool bVar5;
if (param_1[1] == 0) {
return 1;
}
iVar3 = 0;
pcVar4 = (char *)*param_1 + param_1[1];
pcVar1 = (char *)*param_1;
do {
while (pcVar2 = pcVar1, *pcVar2 == '<') {
i... |
227 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string brackets){
int level=0;
for (int i=0;i<brackets.length();i++)
{
if (brackets[i]=='<') level+=1;
if (brackets[i]=='>') level-=1;
if (level<0) return false;
}
if (level!=0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("<>"));
assert (func0("<<><>>"));
assert (func0("<><><<><>><>"));
assert (func0("<><><<<><><>><>><<><><<>>>"));
assert (not (func0("<<<><>>>>")));
assert (not (func0("><<>")));
assert (not (func0("<")));
assert (not (func0("<<<<... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
test %rsi,%rsi
je 18f3 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x53>
mov (%rdi),%rax
xor %ecx,%ecx
add %rax,%rsi
jmp 18d6 <_Z5func0NSt7__cxx1112basic_stringIcSt11... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
test rsi, rsi
jz short loc_1833
mov rax, [rdi]
xor ecx, ecx
add rsi, rax
jmp short loc_1813
loc_1800:
cmp dl, 3Eh ; '>'
jnz short loc_180A
sub ecx, 1
jb short loc_1830
loc_180A:
add ra... | char func0(long long a1)
{
long long v1; // rsi
_BYTE *v2; // rax
int v3; // ecx
_BYTE *v4; // rsi
v1 = *(_QWORD *)(a1 + 8);
if ( !v1 )
return 1;
v2 = *(_BYTE **)a1;
v3 = 0;
v4 = (_BYTE *)(*(_QWORD *)a1 + v1);
while ( 1 )
{
while ( *v2 == 60 )
{
++v2;
++v3;
if ( v4 ... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x00101833
MOV RAX,qword ptr [RDI]
XOR ECX,ECX
ADD RSI,RAX
JMP 0x00101813
LAB_00101800:
CMP DL,0x3e
JNZ 0x0010180a
SUB ECX,0x1
JC 0x00101830
LAB_0010180a:
ADD RAX,0x1
CMP RSI,RAX
JZ 0x00101827
LAB_00101813:
MOVZX EDX,byte ptr [RAX]
CMP DL,0x3c
JNZ 0x00101800
... | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
bool bVar5;
if (param_1[1] == 0) {
return 1;
}
iVar3 = 0;
pcVar4 = (char *)*param_1 + param_1[1];
pcVar1 = (char *)*param_1;
do {
while (pcVar2 = pcVar1, *pcVar2 == '<') {
i... |
228 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<float> l){
int incr,decr;
incr=0;decr=0;
for (int i=1;i<l.size();i++)
{
if (l[i]>l[i-1]) incr=1;
if (l[i]<l[i-1]) decr=1;
}
if (incr+decr==2) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 4, 10}) == true);
assert (func0({1, 2, 4, 20}) == true);
assert (func0({1, 20, 4, 10}) == false);
assert (func0({4, 1, 0, -10}) == true);
assert (func0({4, 1, 1, 0}) == true);
assert (func0({1, 2, 3, 2, 5, 60}) == false);
ass... | O0 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1b26 <_ZNKSt6vect... | _Z5func0St6vectorIfSaIfEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 1
jmp loc_1314
loc_1274:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax... | _BOOL8 func0(long long a1)
{
float v2; // [rsp+4h] [rbp-2Ch]
float v3; // [rsp+4h] [rbp-2Ch]
int v4; // [rsp+14h] [rbp-1Ch]
int v5; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v4 = 0;
v5 = 0;
for ( i = 1; i < (unsigned long long)std::vector<float>::size(a1); ++i )
{
v2 = *(float *)std::... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x1
JMP 0x00101314
LAB_00101274:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CA... | /* func0(std::vector<float, std::allocator<float> >) */
bool func0(vector param_1)
{
float fVar1;
float *pfVar2;
ulong uVar3;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
int local_24;
int local_20;
int local_1c;
this = (vector<float,std::allocator<float>> *)CONCAT44(in_r... |
229 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<float> l){
int incr,decr;
incr=0;decr=0;
for (int i=1;i<l.size();i++)
{
if (l[i]>l[i-1]) incr=1;
if (l[i]<l[i-1]) decr=1;
}
if (incr+decr==2) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 4, 10}) == true);
assert (func0({1, 2, 4, 20}) == true);
assert (func0({1, 20, 4, 10}) == false);
assert (func0({4, 1, 0, -10}) == true);
assert (func0({4, 1, 1, 0}) == true);
assert (func0({1, 2, 3, 2, 5, 60}) == false);
ass... | O1 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
cmp $0x7,%rdx
jbe 125b <_Z5func0St6vectorIfSaIfEE+0x52>
mov %rcx,%rax
lea -0x4(%rcx,%rdx,1),%rdi
mov $0x0,%ecx
mov $0x0,%edx
mov $0x1,%esi
movss 0x4(%rax),%xmm0
movss (%rax),%xmm1
... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rdx, [rdi]
mov rax, [rdi+8]
sub rax, rdx
mov rsi, rax
sar rsi, 2
cmp rax, 4
jbe short loc_125F
mov ecx, 0
mov r8d, 0
mov eax, 1
mov edi, 1
jmp short loc_1247
loc_123B:
mov r8d, edi
loc_123E:
add rax, 1
cmp rax, rsi
jnb ... | bool func0(long long *a1)
{
long long v1; // rdx
int v2; // ecx
int v3; // r8d
unsigned long long v4; // rax
float v5; // xmm0_4
float v6; // xmm1_4
v1 = *a1;
if ( (unsigned long long)(a1[1] - *a1) <= 4 )
{
v2 = 0;
v3 = 0;
}
else
{
v2 = 0;
v3 = 0;
v4 = 1LL;
do
{
... | func0:
ENDBR64
MOV RDX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RDX
MOV RSI,RAX
SAR RSI,0x2
CMP RAX,0x4
JBE 0x0010125f
MOV ECX,0x0
MOV R8D,0x0
MOV EAX,0x1
MOV EDI,0x1
JMP 0x00101247
LAB_0010123b:
MOV R8D,EDI
LAB_0010123e:
ADD RAX,0x1
CMP RAX,RSI
JNC 0x0010126a
LAB_00101247:
MOVSS XMM0,dword ptr [RDX + RAX*... | /* func0(std::vector<float, std::allocator<float> >) */
int8 func0(vector param_1)
{
float fVar1;
float fVar2;
long lVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
int4 in_register_0000003c;
int iVar7;
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar4 = ((long *)CONCAT44(in_register_00... |
230 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<float> l){
int incr,decr;
incr=0;decr=0;
for (int i=1;i<l.size();i++)
{
if (l[i]>l[i-1]) incr=1;
if (l[i]<l[i-1]) decr=1;
}
if (incr+decr==2) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 4, 10}) == true);
assert (func0({1, 2, 4, 20}) == true);
assert (func0({1, 20, 4, 10}) == false);
assert (func0({4, 1, 0, -10}) == true);
assert (func0({4, 1, 1, 0}) == true);
assert (func0({1, 2, 3, 2, 5, 60}) == false);
ass... | O2 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
sub %rax,%rdx
cmp $0x7,%rdx
jbe 1630 <_Z5func0St6vectorIfSaIfEE+0x50>
lea -0x4(%rdx,%rax,1),%rdi
xor %ecx,%ecx
xor %edx,%edx
mov $0x1,%esi
nopw 0x0(%rax,%rax,1)
movss 0x4(%rax),%xmm0
movss (%rax)... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rcx, [rdi]
mov rax, [rdi+8]
sub rax, rcx
mov rsi, rax
sar rsi, 2
cmp rax, 4
jbe short loc_1598
movss xmm0, dword ptr [rcx]
mov eax, 1
xor edx, edx
xor edi, edi
mov r8d, 1
jmp short loc_1570
loc_1560:
ucomiss xmm1, xmm0
cmova edx,... | char func0(long long a1)
{
float *v1; // rcx
unsigned long long v2; // rsi
float v3; // xmm0_4
unsigned long long v4; // rax
int v5; // edx
int v6; // edi
float v7; // xmm1_4
v1 = *(float **)a1;
v2 = (long long)(*(_QWORD *)(a1 + 8) - *(_QWORD *)a1) >> 2;
if ( *(_QWORD *)(a1 + 8) - *(_QWORD *)a1 <=... | func0:
ENDBR64
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RCX
MOV RSI,RAX
SAR RSI,0x2
CMP RAX,0x4
JBE 0x00101598
MOVSS XMM0,dword ptr [RCX]
MOV EAX,0x1
XOR EDX,EDX
XOR EDI,EDI
MOV R8D,0x1
JMP 0x00101570
LAB_00101560:
UCOMISS XMM1,XMM0
CMOVA EDX,R8D
ADD RAX,0x1
CMP RAX,RSI
JNC 0x0010158b
LAB_00101570:... | /* func0(std::vector<float, std::allocator<float> >) */
int8 func0(vector param_1)
{
float fVar1;
float *pfVar2;
int iVar3;
ulong uVar4;
ulong uVar5;
int iVar6;
ulong uVar7;
int iVar8;
int4 in_register_0000003c;
float fVar9;
pfVar2 = *(float **)CONCAT44(in_register_0000003c,param_1);
uVar4 ... |
231 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<float> l){
int incr,decr;
incr=0;decr=0;
for (int i=1;i<l.size();i++)
{
if (l[i]>l[i-1]) incr=1;
if (l[i]<l[i-1]) decr=1;
}
if (incr+decr==2) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1, 2, 4, 10}) == true);
assert (func0({1, 2, 4, 20}) == true);
assert (func0({1, 20, 4, 10}) == false);
assert (func0({4, 1, 0, -10}) == true);
assert (func0({4, 1, 1, 0}) == true);
assert (func0({1, 2, 3, 2, 5, 60}) == false);
ass... | O3 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rax
sub %r8,%rax
mov %rax,%r9
sar $0x2,%r9
cmp $0x7,%rax
jbe 16d0 <_Z5func0St6vectorIfSaIfEE+0xd0>
cmp $0x3,%r9
jbe 16d6 <_Z5func0St6vectorIfSaIfEE+0xd6>
lea -0x4(%r9),%rdi
movss (%r8),%xmm0
mov $0... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rsi, [rdi]
mov rax, [rdi+8]
sub rax, rsi
mov rdi, rax
sar rdi, 2
cmp rax, 4
jbe loc_1728
mov eax, 2
cmp rdi, rax
cmovnb rax, rdi
lea r8, [rax-1]
sub rax, 2
cmp rax, 2
jbe loc_172E
mov rdx, r8
pxor xmm3, xmm3
movdqa xmm5,... | char func0(__m128 **a1)
{
__m128 *v1; // rsi
long long v2; // rax
unsigned long long v3; // rdi
long long v4; // rax
unsigned long long v5; // r8
__m128i v6; // xmm3
__m128i si128; // xmm5
__m128 *v8; // rax
__m128i v9; // xmm4
__m128 v10; // xmm6
__m128 v11; // xmm0
__m128i v12; // xmm0
__m1... | func0:
ENDBR64
MOV RSI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RSI
MOV RDI,RAX
SAR RDI,0x2
CMP RAX,0x4
JBE 0x00101728
MOV EAX,0x2
CMP RDI,RAX
CMOVNC RAX,RDI
LEA R8,[RAX + -0x1]
SUB RAX,0x2
CMP RAX,0x2
JBE 0x0010172e
MOV RDX,R8
PXOR XMM3,XMM3
MOVDQA XMM5,xmmword ptr [0x00102170]
MOV RAX,RSI
SHR RDX,0x2
MOV... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<float, std::allocator<float> >) */
int4 func0(vector param_1)
{
ulong uVar1;
float fVar2;
float *pfVar3;
uint uVar4;
ulong uVar5;
float *pfVar6;
float *pfVar7;
uint uVar8;
int iVar9;
int4 in_r... |
232 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l1,vector<int> l2){
vector<int> out={};
for (int i=0;i<l1.size();i++)
if (find(out.begin(),out.end(),l1[i])==out.end())
if (find(l2.begin(),l2.end(),l1[i])!=l2.end())
out.push_back(l1[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({1, 4, 3, 34, 653, 2, 5}, {5, 7, 1, 5, 9, 653, 121}) , {1, 5, 65... | O0 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x50,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %rdx,-0x58(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
pxor xmm0, xmm0
movups xmmword ptr [rax],... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // r12
long long v4; // rbx
long long v5; // rax
long long v6; // r12
long long v7; // rbx
long long v8; // rax
long long v9; // rax
long long v10; // rbx
long long v11; // rax
int i; // [rsp+24h] [rbp-2Ch]
long long v15; /... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qwo... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1,vector param_2)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int *piVar4;
int4 extraout_var;
int4 extraout_var_00;
ulong uVar5;
vector<i... |
233 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l1,vector<int> l2){
vector<int> out={};
for (int i=0;i<l1.size();i++)
if (find(out.begin(),out.end(),l1[i])==out.end())
if (find(l2.begin(),l2.end(),l1[i])!=l2.end())
out.push_back(l1[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({1, 4, 3, 34, 653, 2, 5}, {5, 7, 1, 5, 9, 653, 121}) , {1, 5, 65... | O1 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rdx,%r13
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rs... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
mov r15, rdx
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp [rsi+8], rdx
jz short loc_1331
mov r13, r... | char ** func0(char **a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
unsigned long long v5; // rbx
char *v6; // r12
_DWORD *v7; // r14
char *v8; // r12
char *v9; // r13
int v10; // eax
unsigned long long v11; // rax
char *v12; // rbx
int v13; // ecx
char *v14; // rax
int v15; // edx
char... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
MOV R15,RDX
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 0x00101331
MOV R13,RSI
MOV EBX,0x0
JMP 0x001012e3
LAB_001012bd:
MOV RDX,R14
MOV R... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1,vector param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
__normal_iterator _Var7;
uint uVar8;
int4 extraout_var;
int... |
234 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l1,vector<int> l2){
vector<int> out={};
for (int i=0;i<l1.size();i++)
if (find(out.begin(),out.end(),l1[i])==out.end())
if (find(l2.begin(),l2.end(),l1[i])!=l2.end())
out.push_back(l1[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({1, 4, 3, 34, 653, 2, 5}, {5, 7, 1, 5, 9, 653, 121}) , {1, 5, 65... | O2 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%r... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 8
movups xmmword ptr [rdi], xmm0
mov r9, [rsi]
mov qword ptr [rdi+10h], 0
cmp r9, [rsi+8]
jz loc_1D09
mov rbp, rsi
mov r14, rdx
xor ... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v3; // r9
unsigned long long v6; // rbx
char *v7; // r15
char *v8; // r13
long long v9; // r8
long long v10; // rsi
_DWORD *v11; // r8
long long v12; // rdx
unsigned long long v13; // rax
char *v15; // rbx
int v16; // ecx
int ... | func0:
MOV RDI,R12
CALL 0x00101db0
MOV RDI,RBX
LAB_0010114b:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) [clone
.cold] */
void func0(vector param_1,vector param_2)
{
vector<int,std::allocator<int>> *unaff_R12;
std::vector<int,std::allocator<int>>::~vector(unaff_R12);
/* WARNING: Subroutine does not retu... |
235 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> l1,vector<int> l2){
vector<int> out={};
for (int i=0;i<l1.size();i++)
if (find(out.begin(),out.end(),l1[i])==out.end())
if (find(l2.begin(),l2.end(),l1[i])!=l2.end())
out.push_back(l1[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({1, 4, 3, 34, 653, 2, 5}, {5, 7, 1, 5, 9, 653, 121}) , {1, 5, 65... | O3 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
movups xmmword ptr [rdi], xmm0
mov r9, [rsi+8]
mov r8, [rsi]
mov qword ptr [rdi+10h], 0
cmp r8, r9
jz loc_1CB4
mov r15, rsi
mov r... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v3; // r9
long long v4; // r8
unsigned long long v7; // r12
char *v8; // rbx
char *v9; // r13
long long v10; // r9
long long v11; // r10
long long v12; // rsi
_DWORD *v13; // r10
int v14; // ecx
int v15; // edx
char *v16; // r... | func0:
MOV RDI,RBP
CALL 0x00101e90
MOV RDI,RBX
LAB_0010114b:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) [clone
.cold] */
void func0(vector param_1,vector param_2)
{
vector<int,std::allocator<int>> *unaff_RBP;
std::vector<int,std::allocator<int>>::~vector(unaff_RBP);
/* WARNING: Subroutine does not retu... |
236 | 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++)
while (n%i==0 and n>i) n=n/i;
return n;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(15) == 5);
assert (func0(27) == 3);
assert (func0(63) == 7);
assert (func0(330) == 11);
assert (func0(13195) == 29);
assert (func0(2048) == 2);
}
| 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 118d <_Z5func0i+0x44>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1187 <_Z5func0i+0x3e>
mov -0x14(%rbp),%e... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 2
jmp short loc_1180
loc_115D:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov [rbp+var_14], eax
loc_1167:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_11... | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
for ( i = 2; a1 >= i * i; ++i )
{
while ( !(a1 % i) && a1 > i )
a1 /= i;
}
return (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00101180
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x14],EAX
LAB_00101167:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST E... | /* func0(int) */
int func0(int param_1)
{
int4 local_1c;
int4 local_c;
local_1c = param_1;
for (local_c = 2; local_c * local_c <= local_1c; local_c = local_c + 1) {
for (; (local_1c % local_c == 0 && (local_c < local_1c)); local_1c = local_1c / local_c) {
}
}
return local_1c;
} |
237 | 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++)
while (n%i==0 and n>i) n=n/i;
return n;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(15) == 5);
assert (func0(27) == 3);
assert (func0(63) == 7);
assert (func0(330) == 11);
assert (func0(13195) == 29);
assert (func0(2048) == 2);
}
| O1 | cpp | func0(int):
endbr64
cmp $0x3,%edi
jle 1188 <_Z5func0i+0x3f>
mov $0x2,%ecx
jmp 1165 <_Z5func0i+0x1c>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jg 1188 <_Z5func0i+0x3f>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1159 <_Z5func0i+0x10>
cmp %ecx,%edi
jle 1159 <_... | _Z5func0i:
endbr64
mov ecx, 2
cmp edi, 3
jg short loc_1166
loc_1157:
mov eax, edi
retn
loc_115A:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, edi
jg short loc_1157
loc_1166:
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_115A
cmp edi, ecx
jle short loc... | long long func0(int a1)
{
int v1; // ecx
int v3; // esi
v1 = 2;
if ( a1 > 3 )
{
do
{
if ( !(a1 % v1) && a1 > v1 )
{
do
{
v3 = a1 / v1;
a1 = v3;
}
while ( !(v3 % v1) && v3 > v1 );
}
++v1;
}
while ( v1 * v1 <= a1 );
... | func0:
ENDBR64
MOV ECX,0x2
CMP EDI,0x3
JG 0x00101166
LAB_00101157:
MOV EAX,EDI
RET
LAB_0010115a:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,EDI
JG 0x00101157
LAB_00101166:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010115a
CMP EDI,ECX
JLE 0x0010115a
LAB_00101173:
MOV EAX,EDI
CDQ
IDIV ECX
MOV ESI,EAX
MOV EDI,EAX
CDQ... | /* func0(int) */
ulong func0(int param_1)
{
ulong uVar1;
int iVar2;
int iVar3;
int iVar4;
ulong uVar5;
uVar5 = (ulong)(uint)param_1;
iVar3 = 2;
if (3 < param_1) {
do {
iVar2 = (int)uVar5;
iVar4 = iVar2 % iVar3;
while ((iVar4 == 0 && (iVar3 < iVar2))) {
uVar1 = (long)(i... |
238 | 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++)
while (n%i==0 and n>i) n=n/i;
return n;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(15) == 5);
assert (func0(27) == 3);
assert (func0(63) == 7);
assert (func0(330) == 11);
assert (func0(13195) == 29);
assert (func0(2048) == 2);
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%r8d
cmp $0x3,%edi
jle 13da <_Z5func0i+0x4a>
mov $0x2,%ecx
nopl 0x0(%rax)
mov %r8d,%eax
cltd
idiv %ecx
test %edx,%edx
je 13c8 <_Z5func0i+0x38>
jmp 13cd <_Z5func0i+0x3d>
nopl 0x0(%rax)
mov %r8d,%eax
cltd
idiv %ecx
cltd
mov %eax,%r8d
idiv %ecx
test %e... | _Z5func0i:
endbr64
mov ecx, 2
cmp edi, 3
jle short loc_12BE
xchg ax, ax
loc_1290:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_12AE
jmp short loc_12B2
loc_12A0:
mov eax, edi
cdq
idiv ecx
cdq
mov edi, eax
idiv ecx
test edx, edx
jnz short loc_12B2
loc_12AE:
c... | long long func0(int a1)
{
int v1; // ecx
int v2; // edx
v1 = 2;
if ( a1 > 3 )
{
do
{
if ( !(a1 % v1) )
{
do
{
if ( a1 <= v1 )
break;
v2 = (a1 / v1) >> 31;
a1 /= v1;
}
while ( !(unsigned int)(__SPAIR64__(v2, a1) % v... | func0:
ENDBR64
MOV ECX,0x2
CMP EDI,0x3
JLE 0x001012be
NOP
LAB_00101290:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x001012ae
JMP 0x001012b2
LAB_001012a0:
MOV EAX,EDI
CDQ
IDIV ECX
CDQ
MOV EDI,EAX
IDIV ECX
TEST EDX,EDX
JNZ 0x001012b2
LAB_001012ae:
CMP EDI,ECX
JG 0x001012a0
LAB_001012b2:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,EC... | /* func0(int) */
int func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
iVar2 = 2;
if (3 < param_1) {
do {
iVar3 = param_1 % iVar2;
while ((iVar3 == 0 && (iVar2 < param_1))) {
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar2);
iVar3 = (int)((long)((ul... |
239 | 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++)
while (n%i==0 and n>i) n=n/i;
return n;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(15) == 5);
assert (func0(27) == 3);
assert (func0(63) == 7);
assert (func0(330) == 11);
assert (func0(13195) == 29);
assert (func0(2048) == 2);
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%r8d
cmp $0x3,%edi
jle 13aa <_Z5func0i+0x4a>
mov $0x2,%ecx
nopl 0x0(%rax)
mov %r8d,%eax
cltd
idiv %ecx
test %edx,%edx
je 1398 <_Z5func0i+0x38>
jmp 139d <_Z5func0i+0x3d>
nopl 0x0(%rax)
mov %r8d,%eax
cltd
idiv %ecx
cltd
mov %eax,%r8d
idiv %ecx
test %e... | _Z5func0i:
endbr64
mov ecx, 2
cmp edi, 3
jle short loc_143E
xchg ax, ax
loc_1410:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_142E
jmp short loc_1432
loc_1420:
mov eax, edi
cdq
idiv ecx
cdq
mov edi, eax
idiv ecx
test edx, edx
jnz short loc_1432
loc_142E:
c... | long long func0(int a1)
{
int v1; // ecx
int v2; // edx
v1 = 2;
if ( a1 > 3 )
{
do
{
if ( !(a1 % v1) )
{
do
{
if ( a1 <= v1 )
break;
v2 = (a1 / v1) >> 31;
a1 /= v1;
}
while ( !(unsigned int)(__SPAIR64__(v2, a1) % v... | func0:
ENDBR64
MOV ECX,0x2
CMP EDI,0x3
JLE 0x0010143e
NOP
LAB_00101410:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x0010142e
JMP 0x00101432
LAB_00101420:
MOV EAX,EDI
CDQ
IDIV ECX
CDQ
MOV EDI,EAX
IDIV ECX
TEST EDX,EDX
JNZ 0x00101432
LAB_0010142e:
CMP EDI,ECX
JG 0x00101420
LAB_00101432:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,EC... | /* func0(int) */
int func0(int param_1)
{
long lVar1;
int iVar2;
int iVar3;
iVar2 = 2;
if (3 < param_1) {
do {
iVar3 = param_1 % iVar2;
while ((iVar3 == 0 && (iVar2 < param_1))) {
lVar1 = (long)param_1;
param_1 = (int)(lVar1 / (long)iVar2);
iVar3 = (int)((long)((ul... |
240 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
return n*(n+1)/2;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 1);
assert (func0(6) == 21);
assert (func0(11) == 66);
assert (func0(30) == 465);
assert (func0(100) == 5050);
assert (func0(10) == 55);
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
add $0x1,%eax
imul -0x4(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
add eax, 1
imul eax, [rbp+var_4]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1) / 2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 + 1) * param_1) / 2;
} |
241 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
return n*(n+1)/2;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 1);
assert (func0(6) == 21);
assert (func0(11) == 66);
assert (func0(30) == 465);
assert (func0(100) == 5050);
assert (func0(10) == 55);
}
| O1 | cpp | func0(int):
endbr64
lea 0x1(%rdi),%eax
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
| _Z5func0i:
endbr64
lea edx, [rdi+1]
imul edx, edi
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1) / 2);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
IMUL EDX,EDI
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 + 1) * param_1) / 2;
} |
242 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
return n*(n+1)/2;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 1);
assert (func0(6) == 21);
assert (func0(11) == 66);
assert (func0(30) == 465);
assert (func0(100) == 5050);
assert (func0(10) == 55);
}
| O2 | cpp | func0(int):
endbr64
lea 0x1(%rdi),%eax
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0i:
endbr64
lea edx, [rdi+1]
imul edx, edi
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1) / 2);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
IMUL EDX,EDI
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 + 1) * param_1) / 2;
} |
243 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
return n*(n+1)/2;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(1) == 1);
assert (func0(6) == 21);
assert (func0(11) == 66);
assert (func0(30) == 465);
assert (func0(100) == 5050);
assert (func0(10) == 55);
}
| O3 | cpp | func0(int):
endbr64
lea 0x1(%rdi),%eax
imul %eax,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0i:
endbr64
lea edx, [rdi+1]
imul edx, edi
mov eax, edx
shr eax, 1Fh
add eax, edx
sar eax, 1
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (a1 + 1) / 2);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
IMUL EDX,EDI
MOV EAX,EDX
SHR EAX,0x1f
ADD EAX,EDX
SAR EAX,0x1
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 + 1) * param_1) / 2;
} |
244 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string brackets){
int level=0;
for (int i=0;i<brackets.length();i++)
{
if (brackets[i]=='(') level+=1;
if (brackets[i]==')') level-=1;
if (level<0) return false;
}
if (level!=0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("()"));
assert (func0("(()())"));
assert (func0("()()(()())()"));
assert (func0("()()((()()())())(()()(()))"));
assert (not (func0("((()())))")));
assert (not (func0(")(()")));
assert (not (func0("(")));
assert (not (func0("((((... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1290... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_13C5
loc_136A:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx... | _BOOL8 func0(long long a1)
{
int v2; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = 0;
for ( i = 0; i < (unsigned long long)std::string::length(a1); ++i )
{
if ( *(_BYTE *)std::string::operator[](a1, i) == 40 )
++v2;
if ( *(_BYTE *)std::string::operator[](a1, i) == 41 )
--v2;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001013c5
LAB_0010136a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101250
MOVZX EAX,byte ptr... | /* func0(std::string) */
bool func0(ulong param_1)
{
char *pcVar1;
ulong uVar2;
int local_20;
int local_1c;
local_20 = 0;
local_1c = 0;
while( true ) {
uVar2 = std::string::length();
if (uVar2 <= (ulong)(long)local_1c) {
return local_20 == 0;
}
pcVar1 = (char *)std::string::oper... |
245 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string brackets){
int level=0;
for (int i=0;i<brackets.length();i++)
{
if (brackets[i]=='(') level+=1;
if (brackets[i]==')') level-=1;
if (level<0) return false;
}
if (level!=0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("()"));
assert (func0("(()())"));
assert (func0("()()(()())()"));
assert (func0("()()((()()())())(()()(()))"));
assert (not (func0("((()())))")));
assert (not (func0(")(()")));
assert (not (func0("(")));
assert (not (func0("((((... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
test %rsi,%rsi
je 1228 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3f>
mov (%rdi),%rax
add %rax,%rsi
mov $0x0,%edx
jmp 121b <_Z5func0NSt7__cxx1112basic_stringIcSt11... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
test rsi, rsi
jz short loc_1247
mov rax, [rdi]
add rsi, rax
mov ecx, 0
jmp short loc_122F
loc_1223:
add ecx, 1
loc_1226:
add rax, 1
cmp rax, rsi
jz short loc_124C
loc_122F:
movzx edx, by... | bool func0(long long a1)
{
long long v1; // rsi
_BYTE *v2; // rax
_BYTE *v3; // rsi
int v4; // ecx
v1 = *(_QWORD *)(a1 + 8);
if ( v1 )
{
v2 = *(_BYTE **)a1;
v3 = (_BYTE *)(*(_QWORD *)a1 + v1);
v4 = 0;
while ( 1 )
{
if ( *v2 == 40 )
{
++v4;
}
else if ( ... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x00101247
MOV RAX,qword ptr [RDI]
ADD RSI,RAX
MOV ECX,0x0
JMP 0x0010122f
LAB_00101223:
ADD ECX,0x1
LAB_00101226:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x0010124c
LAB_0010122f:
MOVZX EDX,byte ptr [RAX]
CMP DL,0x28
JZ 0x00101223
CMP DL,0x29
JNZ 0x00101226
SUB ECX,0x1
JNS... | /* func0(std::string) */
bool func0(int8 *param_1)
{
char *pcVar1;
int iVar2;
char *pcVar3;
if (param_1[1] == 0) {
iVar2 = 0;
}
else {
pcVar1 = (char *)*param_1;
pcVar3 = pcVar1 + param_1[1];
iVar2 = 0;
do {
if (*pcVar1 == '(') {
iVar2 = iVar2 + 1;
}
else i... |
246 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string brackets){
int level=0;
for (int i=0;i<brackets.length();i++)
{
if (brackets[i]=='(') level+=1;
if (brackets[i]==')') level-=1;
if (level<0) return false;
}
if (level!=0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("()"));
assert (func0("(()())"));
assert (func0("()()(()())()"));
assert (func0("()()((()()())())(()()(()))"));
assert (not (func0("((()())))")));
assert (not (func0(")(()")));
assert (not (func0("(")));
assert (not (func0("((((... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
test %rsi,%rsi
je 1883 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x53>
mov (%rdi),%rax
xor %ecx,%ecx
add %rax,%rsi
jmp 1866 <_Z5func0NSt7__cxx1112basic_stringIcSt11... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
test rsi, rsi
jz short loc_15F3
mov rax, [rdi]
xor ecx, ecx
add rsi, rax
jmp short loc_15D3
loc_15C0:
cmp dl, 29h ; ')'
jnz short loc_15CA
sub ecx, 1
jb short loc_15F0
loc_15CA:
add ra... | char func0(long long a1)
{
long long v1; // rsi
_BYTE *v2; // rax
int v3; // ecx
_BYTE *v4; // rsi
v1 = *(_QWORD *)(a1 + 8);
if ( !v1 )
return 1;
v2 = *(_BYTE **)a1;
v3 = 0;
v4 = (_BYTE *)(*(_QWORD *)a1 + v1);
while ( 1 )
{
while ( *v2 == 40 )
{
++v2;
++v3;
if ( v2 ... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x001015f3
MOV RAX,qword ptr [RDI]
XOR ECX,ECX
ADD RSI,RAX
JMP 0x001015d3
LAB_001015c0:
CMP DL,0x29
JNZ 0x001015ca
SUB ECX,0x1
JC 0x001015f0
LAB_001015ca:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x001015e7
LAB_001015d3:
MOVZX EDX,byte ptr [RAX]
CMP DL,0x28
JNZ 0x001015c0
... | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
bool bVar5;
if (param_1[1] == 0) {
return 1;
}
iVar3 = 0;
pcVar4 = (char *)*param_1 + param_1[1];
pcVar1 = (char *)*param_1;
do {
while (pcVar2 = pcVar1, *pcVar2 == '(') {
i... |
247 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(string brackets){
int level=0;
for (int i=0;i<brackets.length();i++)
{
if (brackets[i]=='(') level+=1;
if (brackets[i]==')') level-=1;
if (level<0) return false;
}
if (level!=0) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("()"));
assert (func0("(()())"));
assert (func0("()()(()())()"));
assert (func0("()()((()()())())(()()(()))"));
assert (not (func0("((()())))")));
assert (not (func0(")(()")));
assert (not (func0("(")));
assert (not (func0("((((... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
test %rsi,%rsi
je 18f3 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x53>
mov (%rdi),%rax
xor %ecx,%ecx
add %rax,%rsi
jmp 18d6 <_Z5func0NSt7__cxx1112basic_stringIcSt11... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
test rsi, rsi
jz short loc_1833
mov rax, [rdi]
xor ecx, ecx
add rsi, rax
jmp short loc_1813
loc_1800:
cmp dl, 29h ; ')'
jnz short loc_180A
sub ecx, 1
jb short loc_1830
loc_180A:
add ra... | char func0(long long a1)
{
long long v1; // rsi
_BYTE *v2; // rax
int v3; // ecx
_BYTE *v4; // rsi
v1 = *(_QWORD *)(a1 + 8);
if ( !v1 )
return 1;
v2 = *(_BYTE **)a1;
v3 = 0;
v4 = (_BYTE *)(*(_QWORD *)a1 + v1);
while ( 1 )
{
while ( *v2 == 40 )
{
++v2;
++v3;
if ( v4 ... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x00101833
MOV RAX,qword ptr [RDI]
XOR ECX,ECX
ADD RSI,RAX
JMP 0x00101813
LAB_00101800:
CMP DL,0x29
JNZ 0x0010180a
SUB ECX,0x1
JC 0x00101830
LAB_0010180a:
ADD RAX,0x1
CMP RSI,RAX
JZ 0x00101827
LAB_00101813:
MOVZX EDX,byte ptr [RAX]
CMP DL,0x28
JNZ 0x00101800
... | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
bool bVar5;
if (param_1[1] == 0) {
return 1;
}
iVar3 = 0;
pcVar4 = (char *)*param_1 + param_1[1];
pcVar1 = (char *)*param_1;
do {
while (pcVar2 = pcVar1, *pcVar2 == '(') {
i... |
248 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> xs){
vector<float> out={};
for (int i=1;i<xs.size();i++)
out.push_back(i*xs[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({3, 1, 2, 4, 5}) , {1, 4, 12, 20}));
assert (is... | O0 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%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, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
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
m... | long long func0(long long a1, long long a2)
{
unsigned long long v2; // rbx
float v4; // [rsp+Ch] [rbp-34h]
float v5; // [rsp+20h] [rbp-20h] BYREF
int i; // [rsp+24h] [rbp-1Ch]
unsigned long long v7; // [rsp+28h] [rbp-18h]
v7 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
s... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV 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(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
float *pfVar1;
ulong uVar2;
ulong uVar3;
vector<float,std::allocator<float>> *in_RSI;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
long in_FS_OFFSET;
float fVa... |
249 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> xs){
vector<float> out={};
for (int i=1;i<xs.size();i++)
out.push_back(i*xs[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({3, 1, 2, 4, 5}) , {1, 4, 12, 20}));
assert (is... | O1 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
mov 0x8(%rsi),%rax
sub %rdx,%... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
mov rax, [rsi+8]
sub rax, r... | 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
float v8; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v9; // [rsp+8h] [rbp-30h]
v9 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v2 ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
SUB RAX,RDX
CMP RAX,0x4
JBE 0x0010136d
MOV R... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
float *pfVar1;
long lVar2;
ulong uVar3;
long *in_RSI;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
long in_FS_OFFSET;
float local_34;
long local_30;
thi... |
250 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> xs){
vector<float> out={};
for (int i=1;i<xs.size();i++)
out.push_back(i*xs[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({3, 1, 2, 4, 5}) , {1, 4, 12, 20}));
assert (is... | O2 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov 0x8(%rsi),%rcx
mov (%rsi),%rdx
mov %rcx,%... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov rax, [rsi+8]
mov qword ptr [rdi+10h], 0
sub rax, r... | long long func0(long long a1, long long *a2)
{
long long v2; // rdx
long long v3; // rax
float *v5; // rax
float *v6; // rsi
long long v7; // rbx
float v8; // xmm0_4
float v10; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+4h] [rbp-30h]
v11 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
SUB RAX,RDX
CMP RAX,0x4
JBE 0x001017f0
MOV R... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
long lVar1;
float *pfVar2;
long lVar3;
ulong uVar4;
long *in_RSI;
float *pfVar5;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
long in_FS_OFFSET;
float loca... |
251 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> xs){
vector<float> out={};
for (int i=1;i<xs.size();i++)
out.push_back(i*xs[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({3, 1, 2, 4, 5}) , {1, 4, 12, 20}));
assert (is... | O3 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov 0x8(%rsi),%rcx
mov (%rsi),%rdx
mov %rcx,%ra... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov rax, [rsi+8]
mov qword ptr [rdi+10h], 0
sub rax, r... | long long func0(long long a1, long long *a2)
{
long long v2; // rdx
long long v3; // rax
float *v5; // rax
float *v6; // rsi
long long v7; // rbx
float v8; // xmm0_4
float v10; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+4h] [rbp-30h]
v11 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
SUB RAX,RDX
CMP RAX,0x4
JBE 0x001017f0
MOV R... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
long lVar1;
float *pfVar2;
long lVar3;
ulong uVar4;
long *in_RSI;
float *pfVar5;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
long in_FS_OFFSET;
float loca... |
252 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int ff[100];
ff[0]=0;
ff[1]=0;
ff[2]=1;
for (int i=3;i<=n;i++)
ff[i]=ff[i-1]+ff[i-2]+ff[i-3];
return ff[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2) == 1);
assert (func0(1) == 0);
assert (func0(5) == 4);
assert (func0(8) == 24);
assert (func0(10) == 81);
assert (func0(12) == 274);
assert (func0(14) == 927);
}
| 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 $0x1,-0x198(%rbp)
movl $0x3,-0x1a4(%rbp)
mov -0x1a4(%rbp),%eax
cmp -0x1b4(%rbp),%eax
jg 1215 <_Z5... | _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], 1
mov [rbp+var_1A4], 3
jmp short loc_1207
loc_11B7:
mov eax, [rbp+var_1A4]
sub ... | 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] = 1;
for ( i = 3; i <= a1; ++i )
v3[i] = v3[i - 3] + v3[i - 2] + v3[i - 1];
return (unsigned int)v... | 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],0x1
MOV dword ptr [RBP + -0x1a4],0x3
JMP 0x00101207
LAB_001011b7:
MOV E... | /* 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] = 1;
for (local_1ac = 3; local_1ac <= param_1; local_1ac = local_1ac + 1) {
local_1a8[loc... |
253 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int ff[100];
ff[0]=0;
ff[1]=0;
ff[2]=1;
for (int i=3;i<=n;i++)
ff[i]=ff[i-1]+ff[i-2]+ff[i-3];
return ff[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2) == 1);
assert (func0(1) == 0);
assert (func0(5) == 4);
assert (func0(8) == 24);
assert (func0(10) == 81);
assert (func0(12) == 274);
assert (func0(14) == 927);
}
| 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 $0x1,0x8(%rsp)
cmp $0x2,%edi
jle 11c2 <_Z5func0i+0x59>
mov %rsp,%rax
lea -0x3(%rdi),%edx
lea 0x4(%rsp,%rdx,4),%rcx
mov 0x4(%rax),%edx
add 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], 1
cmp edi, 2
jle short loc_11C2
mov rax, rsp
lea edx, [rdi-3]
lea rcx, [rsp+rdx*4+1A8h+var_1A4]
loc_11AE:
m... | 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] = 1;
if ( a1 > 2 )
{
v1 = &v3;
do
{
v1[3] = *v1 + v1[2] +... | 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],0x1
CMP EDI,0x2
JLE 0x001011c2
MOV RAX,RSP
LEA EDX,[RDI + -0x3]
LEA RCX,[RSP + RDX*0x4 + 0x4]
LAB_001011ae:
MOV EDX,dword ptr [RAX + 0x4]
A... | /* 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] = 1;
if (2 < param_1) {
do {
piVar1[3] = piVar1[1] + piVar1[2] ... |
254 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int ff[100];
ff[0]=0;
ff[1]=0;
ff[2]=1;
for (int i=3;i<=n;i++)
ff[i]=ff[i-1]+ff[i-2]+ff[i-3];
return ff[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2) == 1);
assert (func0(1) == 0);
assert (func0(5) == 4);
assert (func0(8) == 24);
assert (func0(10) == 81);
assert (func0(12) == 274);
assert (func0(14) == 927);
}
| O2 | cpp | func0(int):
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movl $0x1,0x8(%rsp)
cmp $0x2,%edi
jle 1348 <_Z5func0i+0x68>
lea -0x3(%rdi),%edx
lea 0x4(%rsp),%rax
xor %esi,%esi
xor %ecx,%ecx
lea 0x8(%rsp,%rdx,4),%r8
mov $0x1,%edx
jmp 1... | _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_1A0], 1
cmp edi, 2
jle short loc_1349
lea eax, [rdi-3]
lea rdx, [rsp+1A8h+var_19C]
xor ecx, ecx
xor r8d, r8d
lea r9, [rsp+rax*4+1A8h+va... | long long func0(int a1)
{
_BYTE *v1; // rdx
int v2; // ecx
int v3; // r8d
int v4; // eax
int v5; // esi
long long v7; // [rsp+0h] [rbp-1A8h]
int v8; // [rsp+8h] [rbp-1A0h]
_BYTE v9[396]; // [rsp+Ch] [rbp-19Ch] BYREF
unsigned long long v10; // [rsp+198h] [rbp-10h]
v10 = __readfsqword(0x28u);
v7 =... | func0:
ENDBR64
SUB RSP,0x1a8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV qword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x1
CMP EDI,0x2
JLE 0x00101349
LEA EAX,[RDI + -0x3]
LEA RDX,[RSP + 0xc]
XOR ECX,ECX
XOR R8D,R8D
LEA R9,[RSP + RAX*0x4 + 0x10]
MOV EAX,0x1
NOP word ptr [RAX + RAX*0x1]
LA... | /* 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;
int4 local_1a0;
int local_19c [99];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_1a8 = 0;
local_1a0 = 1;
if (2 < param... |
255 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(int n){
int ff[100];
ff[0]=0;
ff[1]=0;
ff[2]=1;
for (int i=3;i<=n;i++)
ff[i]=ff[i-1]+ff[i-2]+ff[i-3];
return ff[n];
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(2) == 1);
assert (func0(1) == 0);
assert (func0(5) == 4);
assert (func0(8) == 24);
assert (func0(10) == 81);
assert (func0(12) == 274);
assert (func0(14) == 927);
}
| O3 | cpp | func0(int):
endbr64
sub $0x1a8,%rsp
mov %fs:0x28,%rax
mov %rax,0x198(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movl $0x1,0x8(%rsp)
cmp $0x2,%edi
jle 1387 <_Z5func0i+0xa7>
lea -0x1(%rdi),%r10d
cmp $0x5,%edi
jle 13a8 <_Z5func0i+0xc8>
lea 0xc(%rsp),%r8
mov $0x1,%esi
xor %edx,%edx
mov ... | _Z5func0i:
endbr64
sub rsp, 1A8h
movsxd rsi, edi
mov rax, fs:28h
mov [rsp+1A8h+var_10], rax
xor eax, eax
mov [rsp+1A8h+var_1A8], 0
mov [rsp+1A8h+var_1A0], 1
cmp esi, 2
jle short loc_1387
lea r10d, [rsi-1]
cmp esi, 5
jle loc_13A5
lea r8, [rsp+1A8h+var_19C]
mov edi, 1
... | long long func0(int a1)
{
long long v1; // rsi
int v2; // eax
char *v3; // r8
int v4; // edi
int v5; // edx
int v6; // ecx
int v7; // r9d
char *v8; // rax
int v9; // edx
long long v11; // [rsp+0h] [rbp-1A8h] BYREF
int v12; // [rsp+8h] [rbp-1A0h]
char v13; // [rsp+Ch] [rbp-19Ch] BYREF
unsigned... | func0:
ENDBR64
SUB RSP,0x1a8
MOVSXD RSI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x198],RAX
XOR EAX,EAX
MOV qword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x1
CMP ESI,0x2
JLE 0x00101387
LEA R10D,[RSI + -0x1]
CMP ESI,0x5
JLE 0x001013a5
LEA R8,[RSP + 0xc]
MOV EDI,0x1
XOR EDX,EDX
MOV ECX,0x3
LAB_00101334:
LEA R... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
long in_FS_OFFSET;
int local_1a8 [102];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = 0;
local_1a8[0] = 0;
local_1a8[1] = 0;
local_1a8[2] = 1;
... |
256 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string s){
string vowels="aeiouAEIOU";
int count=0;
for (int i=0;i<s.length();i++)
if (find(vowels.begin(),vowels.end(),s[i])!=vowels.end())
count+=1;
if (s[s.length()-1]=='y' or s[s.length()-1]=='Y') count+=1;
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("abcde") == 2);
assert (func0("Alone") == 3);
assert (func0("key") == 2);
assert (func0("bye") == 1);
assert (func0("keY") == 2);
assert (func0("bYe") == 1);
assert (func0("ACEDY") == 3);
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x60,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x48(%rbp),%rax
mov %rax,%rdi
callq 2300 <_ZNSaIcEC1Ev@... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 60h
mov [rbp+var_68], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_50]
mov [rbp+var_48], rax
nop
nop
lea rdx, [rbp+var_50]
lea ... | long long func0(long long a1)
{
long long v1; // r12
long long v2; // rbx
long long v3; // rax
long long v4; // rax
long long v5; // rax
unsigned int v8; // [rsp+10h] [rbp-60h]
int i; // [rsp+14h] [rbp-5Ch]
long long v10; // [rsp+18h] [rbp-58h] BYREF
_QWORD v11[2]; // [rsp+20h] [rbp-50h] BYREF
_BYT... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x60
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV qword ptr [RBP + -0x48],RAX
NOP
NOP
LEA RDX,[RBP + -0x50]
LEA RAX,[RBP + -0x40]
LEA RCX,[0x103008]
MOV RSI,RCX
MOV RDI,RAX
... | /* func0(std::string) */
int func0(ulong param_1)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int4 extraout_var;
ulong uVar4;
char *pcVar5;
long in_FS_OFFSET;
int local_68;
int local_64;
int8 local_60;
int8 local_58;
int8 *local_50;
string local_48 [40];
long local_20;
... |
257 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string s){
string vowels="aeiouAEIOU";
int count=0;
for (int i=0;i<s.length();i++)
if (find(vowels.begin(),vowels.end(),s[i])!=vowels.end())
count+=1;
if (s[s.length()-1]=='y' or s[s.length()-1]=='Y') count+=1;
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("abcde") == 2);
assert (func0("Alone") == 3);
assert (func0("key") == 2);
assert (func0("bye") == 1);
assert (func0("keY") == 2);
assert (func0("bYe") == 1);
assert (func0("ACEDY") == 3);
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %rsp,%rdi
lea 0x10(%rsp),%rax
mov %rax,(%rsp)
lea 0xe03(%rip),%rdx
lea -0xa(%rdx),%rs... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
push rbx
sub rsp, 38h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+48h+var_20], rax
xor eax, eax
mov rdi, rsp
lea rax, [rsp+48h+var_38]
mov [rsp+48h+var_48], rax
lea rdx, aAeiouaeiou+0Ah; ""
lea rsi, [r... | long long func0(long long a1)
{
long long v1; // r11
char *v2; // r8
char *v3; // rsi
int v4; // ebp
char *v5; // rax
char v6; // dl
long long v7; // rdx
unsigned int v8; // ebp
void *v10; // [rsp+0h] [rbp-48h] BYREF
long long v11; // [rsp+8h] [rbp-40h]
_QWORD v12[7]; // [rsp+10h] [rbp-38h] BYREF... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RDI,RSP
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
LEA RDX,[0x10206b]
LEA RSI,[RDX + -0xa]
CALL 0x00101744
MOV R11,qword ptr [RBX + 0x8]
TEST R11,R11
JZ 0x00101347
MOV RDI,qword ptr [RS... | /* func0(std::string) */
int func0(long *param_1)
{
char *pcVar1;
char cVar2;
byte bVar3;
long lVar4;
long *plVar5;
long *plVar6;
long *plVar7;
long lVar8;
int iVar9;
char *pcVar10;
long in_FS_OFFSET;
long *local_48;
ulong local_40;
long local_38 [3];
long local_20;
local_20 = *(lon... |
258 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string s){
string vowels="aeiouAEIOU";
int count=0;
for (int i=0;i<s.length();i++)
if (find(vowels.begin(),vowels.end(),s[i])!=vowels.end())
count+=1;
if (s[s.length()-1]=='y' or s[s.length()-1]=='Y') count+=1;
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("abcde") == 2);
assert (func0("Alone") == 3);
assert (func0("key") == 2);
assert (func0("bye") == 1);
assert (func0("keY") == 2);
assert (func0("bYe") == 1);
assert (func0("ACEDY") == 3);
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbx
sub $0x30,%rsp
mov 0x8(%rdi),%r11
mov (%rdi),%rbx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rsi
movb $0x0,0x1a(%rsp)
movabs $0x494541756f696561,%rax
mov %rax,0x... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
push rbx
sub rsp, 38h
mov rbx, [rdi+8]
mov rbp, [rdi]
mov rax, fs:28h
mov [rsp+48h+var_20], rax
xor eax, eax
lea r9, [rsp+48h+var_38]
mov [rsp+48h+var_2E], 0
mov rax, 494541756F696561h
mov [rsp+4... | long long func0(char **a1)
{
char *v1; // rbx
char *v2; // rbp
char *v3; // rdi
int v4; // r8d
char v5; // dl
char *i; // rax
long long v7; // rbx
char v9[24]; // [rsp+10h] [rbp-38h] BYREF
unsigned long long v10; // [rsp+28h] [rbp-20h]
v1 = a1[1];
v2 = *a1;
v10 = __readfsqword(0x28u);
strcpy... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RBX,qword ptr [RDI + 0x8]
MOV RBP,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
LEA R9,[RSP + 0x10]
MOV byte ptr [RSP + 0x1a],0x0
MOV RAX,0x494541756f696561
MOV qword ptr [RSP + 0x10],RAX
MOV EAX,0x554f
MOV qword ptr [RSP],R9
MOV... | /* func0(std::string) */
int func0(int8 *param_1)
{
char cVar1;
char *pcVar2;
char *pcVar3;
char *pcVar4;
long lVar5;
char *pcVar6;
int iVar7;
long in_FS_OFFSET;
char local_38 [24];
long local_20;
lVar5 = param_1[1];
pcVar2 = (char *)*param_1;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
... |
259 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string s){
string vowels="aeiouAEIOU";
int count=0;
for (int i=0;i<s.length();i++)
if (find(vowels.begin(),vowels.end(),s[i])!=vowels.end())
count+=1;
if (s[s.length()-1]=='y' or s[s.length()-1]=='Y') count+=1;
return count;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("abcde") == 2);
assert (func0("Alone") == 3);
assert (func0("key") == 2);
assert (func0("bye") == 1);
assert (func0("keY") == 2);
assert (func0("bYe") == 1);
assert (func0("ACEDY") == 3);
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
sub $0x38,%rsp
mov 0x8(%rdi),%r9
mov (%rdi),%rdi
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%r10
movb $0x0,0x1a(%rsp)
movabs $0x494541756f696561,%rax
mov %rax,0x10(%rsp)
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov r8, [rdi+8]
mov rdi, [rdi]
test r8, r8
jz short loc_158D
mov rdx, rdi
lea rsi, [r8+rdi]
xor ecx, ecx
nop dword ptr [rax+00000000h]
loc_1530:
movzx eax, byte ptr [rdx]
cmp al, 61h ; 'a'
jz short loc_1588
... | long long func0(char **a1)
{
char *v1; // r8
char *v2; // rdi
char *v3; // rdx
int v4; // ecx
char v5; // al
long long v6; // r8
v1 = a1[1];
v2 = *a1;
if ( v1 )
{
v3 = v2;
v4 = 0;
do
{
v5 = *v3;
if ( *v3 == 97
|| v5 == 101
|| v5 == 105
|| v5 == 1... | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RDI]
TEST R8,R8
JZ 0x0010158d
MOV RDX,RDI
LEA RSI,[R8 + RDI*0x1]
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_00101530:
MOVZX EAX,byte ptr [RDX]
CMP AL,0x61
JZ 0x00101588
CMP AL,0x65
JZ 0x00101588
CMP AL,0x69
JZ 0x00101588
CMP AL,0x6f
JZ 0x00101588
CMP AL,0x75
JZ 0x... | /* func0(std::string) */
int func0(int8 *param_1)
{
char cVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
long lVar5;
lVar5 = param_1[1];
pcVar2 = (char *)*param_1;
if (lVar5 == 0) {
lVar5 = -1;
iVar3 = 0;
}
else {
iVar3 = 0;
pcVar4 = pcVar2;
do {
cVar1 = *pcVar4;
i... |
260 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int x,int shift){
string xs;
xs=to_string(x);
if (xs.length()<shift)
{
string s(xs.rbegin(),xs.rend());
return s;
}
xs=xs.substr(xs.length()-shift)+xs.substr(0,xs.length()-shift);
return xs;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(100, 2) == "001");
assert (func0(12, 2) == "12");
assert (func0(97, 8) == "79");
assert (func0(12, 1) == "21");
assert (func0(11, 101) == "11");
}
| O0 | cpp | func0[abi:cxx11](int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xc8,%rsp
mov %rdi,-0xc8(%rbp)
mov %esi,-0xcc(%rbp)
mov %edx,-0xd0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0xa0(%rbp),%rax
mov %rax,%rdi
callq 2390 <_ZNSt7__cxx1112basic_stringIcSt11char... | _Z5func0B5cxx11ii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0C8h
mov [rbp+var_C8], rdi
mov [rbp+var_CC], esi
mov [rbp+var_D0], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_A0]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_tra... | long long func0[abi:cxx11](long long a1, int a2, int a3)
{
long long v3; // rax
long long v4; // rax
char v7; // [rsp+17h] [rbp-B9h] BYREF
_BYTE v8[8]; // [rsp+18h] [rbp-B8h] BYREF
_BYTE v9[8]; // [rsp+20h] [rbp-B0h] BYREF
char *v10; // [rsp+28h] [rbp-A8h]
_BYTE v11[32]; // [rsp+30h] [rbp-A0h] BYREF
_B... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RBP + -0xc8],RDI
MOV dword ptr [RBP + -0xcc],ESI
MOV dword ptr [RBP + -0xd0],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xa0]
MOV RDI,RAX
CALL 0x00102330
LEA RAX,[RBP + -0x40]
MOV EDX,dwo... | /* func0[abi:cxx11](int, int) */
string * func0_abi_cxx11_(int param_1,int param_2)
{
ulong uVar1;
int in_EDX;
int4 in_register_0000003c;
string *this;
long in_FS_OFFSET;
allocator local_c1;
int local_c0 [8];
int local_b8 [8];
allocator *local_b0;
string local_a8 [32];
string local_88 [32];
st... |
261 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int x,int shift){
string xs;
xs=to_string(x);
if (xs.length()<shift)
{
string s(xs.rbegin(),xs.rend());
return s;
}
xs=xs.substr(xs.length()-shift)+xs.substr(0,xs.length()-shift);
return xs;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(100, 2) == "001");
assert (func0(12, 2) == "12");
assert (func0(97, 8) == "79");
assert (func0(12, 1) == "21");
assert (func0(11, 101) == "11");
}
| O1 | cpp | func0[abi:cxx11](int, int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,%rbx
mov %esi,%r8d
mov %edx,%ebp
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rax
mov %rax,0x10(%rsp)
movq $0x0,0x18(%rsp)
movb $0x0,0x20(%rsp)
lea 0x70(%r... | _Z5func0B5cxx11ii:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 170h
mov r13, rdi
mov r14d, edx
mov rax, fs:28h
mov [rsp+198h+var_30], rax
xor eax, eax
lea rax, [rsp+198h+var_178]
mov [rsp+198h+var_188], rax
mov [rsp+198h+var_180], 0
mov byte ptr [... | void ** func0[abi:cxx11](void **a1, int a2, int a3)
{
unsigned int v5; // r12d
unsigned int v6; // ebp
unsigned int v7; // eax
unsigned int v8; // ebx
unsigned int v9; // edx
char *v10; // r12
int v11; // ebp
char v12; // bp
char *v13; // rax
long long v14; // rcx
size_t v15; // rbp
char *v16; /... | func0[abi:cxx11]:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x170
MOV R13,RDI
MOV R14D,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x168],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],0x0
MOV byte ptr [RSP + 0x20],0x0
MOV R12D,ESI
SHR R12D,0x1... | /* func0[abi:cxx11](int, int) */
int8 * func0_abi_cxx11_(int param_1,int param_2)
{
uint uVar1;
ulong *puVar2;
int8 *puVar3;
int8 uVar4;
ulong *puVar5;
int in_EDX;
uint uVar6;
ulong uVar7;
ulong *puVar8;
uint uVar9;
char cVar10;
ulong uVar11;
long lVar12;
int4 in_register_0000003c;
int8 ... |
262 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int x,int shift){
string xs;
xs=to_string(x);
if (xs.length()<shift)
{
string s(xs.rbegin(),xs.rend());
return s;
}
xs=xs.substr(xs.length()-shift)+xs.substr(0,xs.length()-shift);
return xs;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(100, 2) == "001");
assert (func0(12, 2) == "12");
assert (func0(97, 8) == "79");
assert (func0(12, 1) == "21");
assert (func0(11, 101) == "11");
}
| O2 | cpp | func0[abi:cxx11](int, int):
endbr64
push %r15
mov %esi,%r8d
lea 0xb62(%rip),%rcx
push %r14
mov %edx,%r14d
mov $0x10,%edx
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0xb8,%rsp
mov 0x2ae7(%rip),%rsi
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
lea 0x80(%r... | _Z5func0B5cxx11ii:
endbr64
push r15
mov r15d, esi
push r14
push r13
movsxd r13, edx
push r12
push rbp
mov rbp, rdi
push rbx
mov ebx, esi
shr ebx, 1Fh
sub rsp, 198h
mov rax, fs:28h
mov [rsp+1C8h+var_40], rax
xor eax, eax
neg r15d
lea r14, [rsp+1C8h+var_190+8]
mo... | __m128i ** func0[abi:cxx11](__m128i **a1, int a2, int a3)
{
unsigned long long v3; // r13
unsigned int v5; // ebx
unsigned int v6; // r15d
long long v7; // rax
int v8; // edx
int v9; // ecx
int v10; // ecx
long long v11; // rsi
int v12; // ecx
long long v13; // rax
__int8 *v14; // rbx
unsigned l... | func0[abi:cxx11]:
ENDBR64
PUSH R15
MOV R15D,ESI
PUSH R14
PUSH R13
MOVSXD R13,EDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV EBX,ESI
SHR EBX,0x1f
SUB RSP,0x198
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x188],RAX
XOR EAX,EAX
NEG R15D
LEA R14,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
CMOVS R15D,ESI
MOV qword ptr ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int, int) */
int8 * func0_abi_cxx11_(int param_1,int param_2)
{
uint uVar1;
int *puVar2;
char ***pppcVar3;
char ***pppcVar4;
uint uVar5;
uint uVar6;
char ****ppppcVar7;
int8 *puVar8;
char ****ppp... |
263 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int x,int shift){
string xs;
xs=to_string(x);
if (xs.length()<shift)
{
string s(xs.rbegin(),xs.rend());
return s;
}
xs=xs.substr(xs.length()-shift)+xs.substr(0,xs.length()-shift);
return xs;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(100, 2) == "001");
assert (func0(12, 2) == "12");
assert (func0(97, 8) == "79");
assert (func0(12, 1) == "21");
assert (func0(11, 101) == "11");
}
| O3 | cpp | func0[abi:cxx11](int, int):
endbr64
push %r15
mov %esi,%r8d
lea 0x954(%rip),%rcx
push %r14
push %r13
mov %rdi,%r13
push %r12
movslq %edx,%r12
mov $0x10,%edx
push %rbp
push %rbx
sub $0xb8,%rsp
mov 0x2907(%rip),%rsi
mov %fs:0x28,%rax
mov %rax,0xa8(%rsp)
xor %eax,%eax
lea 0x80(%rs... | _Z5func0B5cxx11ii:
endbr64
push r15
mov r15d, esi
push r14
push r13
push r12
mov r12, rdi
push rbp
movsxd rbp, edx
push rbx
mov ebx, esi
shr ebx, 1Fh
sub rsp, 198h
mov rax, fs:28h
mov [rsp+1C8h+var_40], rax
xor eax, eax
neg r15d
lea r14, [rsp+1C8h+var_190+8]
mo... | size_t ** func0[abi:cxx11](size_t **a1, int a2, int a3)
{
size_t v4; // rbp
unsigned int v5; // ebx
unsigned int v6; // r15d
long long v7; // rax
int v8; // edx
int v9; // ecx
int v10; // ecx
long long v11; // rsi
int v12; // ecx
long long v13; // rax
__int8 *v14; // rbx
unsigned long long v15; ... | func0[abi:cxx11]:
ENDBR64
PUSH R15
MOV R15D,ESI
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOVSXD RBP,EDX
PUSH RBX
MOV EBX,ESI
SHR EBX,0x1f
SUB RSP,0x198
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x188],RAX
XOR EAX,EAX
NEG R15D
LEA R14,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
CMOVS R15D,ESI
MOV qword ptr ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int, int) */
int8 * func0_abi_cxx11_(int param_1,int param_2)
{
uint uVar1;
int8 ****ppppuVar2;
int8 ****ppppuVar3;
uint uVar4;
ulong uVar5;
int8 *****pppppuVar6;
int8 *puVar7;
int8 *****pppppuVar8... |
264 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string s){
int sum=0;
for (int i=0;i<s.length();i++)
if (s[i]>=65 and s[i]<=90)
sum+=s[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("abAB") == 131);
assert (func0("abcCd") == 67);
assert (func0("helloE") == 69);
assert (func0("woArBld") == 131);
assert (func0("aAaaaXa") == 153);
assert (func0(" How are yOu?") == 151);
assert (func0("... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1290... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_13D4
loc_136A:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx... | long long func0(long long a1)
{
unsigned int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v3 = 0;
for ( i = 0; i < (unsigned long long)std::string::length(a1); ++i )
{
if ( *(char *)std::string::operator[](a1, i) > 64 && *(char *)std::string::operator[](a1, i) <= 90 )
v3 += *(char *)st... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001013d4
LAB_0010136a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101250
MOVZX EAX,byte ptr... | /* func0(std::string) */
int func0(ulong param_1)
{
bool bVar1;
char *pcVar2;
ulong uVar3;
int4 local_20;
int4 local_1c;
local_20 = 0;
local_1c = 0;
do {
uVar3 = std::string::length();
if (uVar3 <= (ulong)(long)local_1c) {
return local_20;
}
pcVar2 = (char *)std::string::opera... |
265 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string s){
int sum=0;
for (int i=0;i<s.length();i++)
if (s[i]>=65 and s[i]<=90)
sum+=s[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("abAB") == 131);
assert (func0("abcCd") == 67);
assert (func0("helloE") == 69);
assert (func0("woArBld") == 131);
assert (func0("aAaaaXa") == 153);
assert (func0(" How are yOu?") == 151);
assert (func0("... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov %rdi,%rax
mov 0x8(%rdi),%rdi
test %rdi,%rdi
je 1222 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x39>
mov (%rax),%rdx
add %rdx,%rdi
mov $0x0,%ecx
movzbl (%rdx),%eax
lea -0x41(%ra... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
test rax, rax
jz short loc_1240
mov rdx, [rdi]
lea rdi, [rax+rdx]
mov ecx, 0
loc_1222:
movzx eax, byte ptr [rdx]
lea esi, [rax-41h]
movsx eax, al
add eax, ecx
cmp sil, 1Ah
cmovb ecx, eax
add ... | long long func0(long long a1)
{
long long v1; // rax
_BYTE *v2; // rdx
_BYTE *v3; // rdi
unsigned int v4; // ecx
v1 = *(_QWORD *)(a1 + 8);
if ( v1 )
{
v2 = *(_BYTE **)a1;
v3 = (_BYTE *)(v1 + *(_QWORD *)a1);
v4 = 0;
do
{
if ( (unsigned __int8)(*v2 - 65) < 0x1Au )
v4 += (... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x00101240
MOV RDX,qword ptr [RDI]
LEA RDI,[RAX + RDX*0x1]
MOV ECX,0x0
LAB_00101222:
MOVZX EAX,byte ptr [RDX]
LEA ESI,[RAX + -0x41]
MOVSX EAX,AL
ADD EAX,ECX
CMP SIL,0x1a
CMOVC ECX,EAX
ADD RDX,0x1
CMP RDI,RDX
JNZ 0x00101222
LAB_0010123d:
MOV EAX,ECX
RET
LAB_00... | /* func0(std::string) */
int func0(int8 *param_1)
{
char *pcVar1;
int iVar2;
char *pcVar3;
if (param_1[1] == 0) {
iVar2 = 0;
}
else {
pcVar3 = (char *)*param_1;
pcVar1 = pcVar3 + param_1[1];
iVar2 = 0;
do {
if ((byte)(*pcVar3 + 0xbfU) < 0x1a) {
iVar2 = *pcVar3 + iVar2;... |
266 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string s){
int sum=0;
for (int i=0;i<s.length();i++)
if (s[i]>=65 and s[i]<=90)
sum+=s[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("abAB") == 131);
assert (func0("abcCd") == 67);
assert (func0("helloE") == 69);
assert (func0("woArBld") == 131);
assert (func0("aAaaaXa") == 153);
assert (func0(" How are yOu?") == 151);
assert (func0("... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
test %rsi,%rsi
je 1690 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x40>
mov (%rdi),%rdx
xor %r8d,%r8d
add %rdx,%rsi
nopw %cs:0x0(%rax,%rax,1)
movsbl (%rdx),%eax
lea ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
test rax, rax
jz short loc_14F0
mov rdx, [rdi]
xor ecx, ecx
lea rdi, [rax+rdx]
nop word ptr [rax+rax+00000000h]
loc_14D0:
movsx eax, byte ptr [rdx]
lea esi, [rax-41h]
add eax, ecx
cmp sil, 1A... | long long func0(char **a1)
{
char *v1; // rax
char *v2; // rdx
unsigned int v3; // ecx
char *v4; // rdi
int v5; // eax
unsigned __int8 v6; // si
unsigned int v7; // eax
v1 = a1[1];
if ( !v1 )
return 0LL;
v2 = *a1;
v3 = 0;
v4 = &(*a1)[(_QWORD)v1];
do
{
v5 = *v2;
v6 = v5 - 65;
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x001014f0
MOV RDX,qword ptr [RDI]
XOR ECX,ECX
LEA RDI,[RAX + RDX*0x1]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001014d0:
MOVSX EAX,byte ptr [RDX]
LEA ESI,[RAX + -0x41]
ADD EAX,ECX
CMP SIL,0x1a
CMOVC ECX,EAX
ADD RDX,0x1
CMP RDI,RDX
JNZ 0x001014d0
MOV EAX,ECX
RET
L... | /* func0(std::string) */
int func0(int8 *param_1)
{
char *pcVar1;
int iVar2;
char *pcVar3;
if (param_1[1] != 0) {
pcVar3 = (char *)*param_1;
iVar2 = 0;
pcVar1 = pcVar3 + param_1[1];
do {
if ((byte)(*pcVar3 + 0xbfU) < 0x1a) {
iVar2 = *pcVar3 + iVar2;
}
pcVar3 = pcVa... |
267 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string s){
int sum=0;
for (int i=0;i<s.length();i++)
if (s[i]>=65 and s[i]<=90)
sum+=s[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("abAB") == 131);
assert (func0("abcCd") == 67);
assert (func0("helloE") == 69);
assert (func0("woArBld") == 131);
assert (func0("aAaaaXa") == 153);
assert (func0(" How are yOu?") == 151);
assert (func0("... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rdx
test %rdx,%rdx
je 35d0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x330>
lea -0x1(%rdx),%rax
mov (%rdi),%rcx
cmp $0xe,%rax
jbe 35d3 <_Z5func0NSt7__cxx1112basic_strin... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
test rsi, rsi
jz loc_3570
lea rax, [rsi-1]
mov rdi, [rdi]
cmp rax, 0Eh
jbe loc_3573
mov rcx, rsi
pxor xmm7, xmm7
pxor xmm6, xmm6
mov rax, rdi
and rcx, 0FFFFFFFFFFFFFFF0h
pxor xmm5, xmm... | long long func0(const __m128i **a1)
{
const __m128i *v1; // rsi
const __m128i *v2; // rdi
__m128 v3; // xmm7
const __m128i *v4; // rax
unsigned long long v5; // rcx
__m128i si128; // xmm9
__m128i v7; // xmm8
__m128i v8; // xmm1
__m128i v9; // xmm0
__m128i v10; // xmm3
__m128i v11; // xmm4
__m12... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x00103570
LEA RAX,[RSI + -0x1]
MOV RDI,qword ptr [RDI]
CMP RAX,0xe
JBE 0x00103573
MOV RCX,RSI
PXOR XMM7,XMM7
PXOR XMM6,XMM6
MOV RAX,RDI
AND RCX,-0x10
PXOR XMM5,XMM5
MOVDQA XMM9,xmmword ptr [0x00104180]
MOVDQA XMM8,xmmword ptr [0x00104190]
LEA RDX,[RCX + RDI*... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::string) */
int func0(int8 *param_1)
{
ulong uVar1;
ulong uVar2;
int (*pauVar3) [16];
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
bool bVar11;
bool bVar12;... |
268 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string s,int n){
string num1="",num2="";
int is12;
is12=0;
for (int i=0;i<s.size();i++)
if (s[i]>=48 and s[i]<=57)
{
if (is12==0) num1=num1+s[i];
if (is12==1) num2=num2+s[i];
}
else
if (is12==0 and num1.length()>0) is12... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("5 apples and 6 oranges",19) == 8);
assert (func0("5 apples and 6 oranges",21) == 10);
assert (func0("0 apples and 1 oranges",3) == 2);
assert (func0("1 apples and 0 oranges",3) == 2);
assert (func0("2 apples and 3 oranges",100) == 95);
... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xb8,%rsp
mov %rdi,-0xb8(%rbp)
mov %esi,-0xbc(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0xa9(%rbp),%rax
mov %rax,%rdi
callq 23... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+var_A8], rdi
mov [rbp+var_AC], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_99]
mov [rbp+var_90], rax
nop
nop
lea rdx, [r... | long long func0(long long a1, int a2)
{
char *v3; // rax
char *v4; // rax
unsigned long long v6; // rbx
const char *v7; // rax
int v8; // ebx
const char *v9; // rax
unsigned int v10; // ebx
char v12; // [rsp+17h] [rbp-99h] BYREF
int v13; // [rsp+18h] [rbp-98h]
int i; // [rsp+1Ch] [rbp-94h]
char *... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0xa8],RDI
MOV dword ptr [RBP + -0xac],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x99]
MOV qword ptr [RBP + -0x90],RAX
NOP
NOP
LEA RDX,[RBP + -0x99]
LEA RAX,[RBP + -0x80]
LEA RCX,[0x104008]
M... | /* func0(std::string, int) */
int func0(ulong param_1,int param_2)
{
bool bVar1;
int iVar2;
int iVar3;
long lVar4;
ulong uVar5;
char *pcVar6;
ulong uVar7;
long in_FS_OFFSET;
allocator local_a1;
int local_a0;
int local_9c;
allocator *local_98;
allocator *local_90;
string local_88 [32];
st... |
269 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string s,int n){
string num1="",num2="";
int is12;
is12=0;
for (int i=0;i<s.size();i++)
if (s[i]>=48 and s[i]<=57)
{
if (is12==0) num1=num1+s[i];
if (is12==1) num2=num2+s[i];
}
else
if (is12==0 and num1.length()>0) is12... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("5 apples and 6 oranges",19) == 8);
assert (func0("5 apples and 6 oranges",21) == 10);
assert (func0("0 apples and 1 oranges",3) == 2);
assert (func0("1 apples and 0 oranges",3) == 2);
assert (func0("2 apples and 3 oranges",100) == 95);
... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %rdi,%rbp
mov %esi,%r13d
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor %eax,%eax
mov %rsp,%rdi
lea 0x10(%rsp... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov rbp, rdi
mov r13d, esi
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rdi, [rsp+0B8h+var_A8]
lea rax, [rsp+0B8h+var... | long long func0(_QWORD *a1, int a2)
{
unsigned long long v4; // rbx
_BOOL4 v5; // r12d
unsigned long long v6; // r14
void *v7; // r15
unsigned long long v8; // r14
void *v9; // r15
char *v10; // rax
long long v11; // rcx
void *v12; // rdi
unsigned long long v13; // rdx
unsigned long long v14; // ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RBP,RDI
MOV R13D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x10]
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
LEA RBX,[0x1021ca]
MOV RDX,RBX
MOV RSI,RBX
LAB_00101310:
CALL 0x00101... | /* func0(std::string, int) */
int func0(long *param_1,int param_2)
{
char cVar1;
long *plVar2;
long *plVar3;
uint uVar4;
int iVar5;
int iVar6;
int8 uVar7;
long lVar8;
uint uVar9;
ulong uVar10;
ulong uVar11;
ulong uVar12;
long in_FS_OFFSET;
bool bVar13;
char local_aa;
char local_a9;
l... |
270 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string s,int n){
string num1="",num2="";
int is12;
is12=0;
for (int i=0;i<s.size();i++)
if (s[i]>=48 and s[i]<=57)
{
if (is12==0) num1=num1+s[i];
if (is12==1) num2=num2+s[i];
}
else
if (is12==0 and num1.length()>0) is12... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("5 apples and 6 oranges",19) == 8);
assert (func0("5 apples and 6 oranges",21) == 10);
assert (func0("0 apples and 1 oranges",3) == 2);
assert (func0("1 apples and 0 oranges",3) == 2);
assert (func0("2 apples and 3 oranges",100) == 95);
... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xd8,%rsp
mov %esi,0x14(%rsp)
lea 0x50(%rsp),%r15
mov %fs:0x28,%rax
mov %rax,0xc8(%rsp)
xor %eax,%eax
lea 0x70(%rsp),%rax... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
lea rbx, function+0Ah; ""
mov rdx, rbx
sub rsp, 0C8h
mov [rsp+0F8h+var_CC], esi
lea rdi, [rsp+0F8h+dest]
mov rsi, rbx
mov rax, fs:28... | long long func0(_QWORD *a1, int a2)
{
long long v3; // rbx
_BOOL4 v4; // r12d
int v5; // ebx
unsigned int v6; // ebx
double *v8; // rdi
size_t v9; // rdx
__m128 v10; // xmm0
double v11; // rdx
size_t v12; // r12
double *v13; // rdi
size_t v14; // rdx
__m128 v15; // xmm0
double v16; // rdx
s... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
LEA RBX,[0x10203a]
MOV RDX,RBX
SUB RSP,0xc8
MOV dword ptr [RSP + 0x2c],ESI
LEA RDI,[RSP + 0x50]
MOV RSI,RBX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x60]
MOV qword ptr [RSP + 0x38],RDI
MOV qwor... | /* func0(std::string, int) */
ulong func0(long *param_1,int param_2)
{
char cVar1;
long *plVar2;
ulong uVar3;
long lVar4;
long *plVar5;
ulong uVar6;
int iVar7;
int iVar8;
size_t sVar9;
ulong uVar10;
long in_FS_OFFSET;
bool bVar11;
char local_aa;
char local_a9;
long *local_a8;
ulong loc... |
271 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string s,int n){
string num1="",num2="";
int is12;
is12=0;
for (int i=0;i<s.size();i++)
if (s[i]>=48 and s[i]<=57)
{
if (is12==0) num1=num1+s[i];
if (is12==1) num2=num2+s[i];
}
else
if (is12==0 and num1.length()>0) is12... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("5 apples and 6 oranges",19) == 8);
assert (func0("5 apples and 6 oranges",21) == 10);
assert (func0("0 apples and 1 oranges",3) == 2);
assert (func0("1 apples and 0 oranges",3) == 2);
assert (func0("2 apples and 3 oranges",100) == 95);
... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xd8,%rsp
mov 0x8(%rdi),%rdx
mov %esi,0x14(%rsp)
lea 0x50(%rsp),%r15
mov %fs:0x28,%rax
mov %rax,0xc8(%rsp)
xor %eax,%eax
... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov rcx, [rdi+8]
mov [rsp+0E8h+var_BC], esi
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
xor eax, eax
lea rax, [rsp+0E8h+var_A0+8]
mov ... | long long func0(_QWORD *a1, int a2)
{
unsigned long long v2; // rcx
long long v4; // rbx
_BOOL4 v5; // r12d
double *v6; // rdi
size_t v7; // rdx
__m128 v8; // xmm0
double v9; // rdx
__int8 *v10; // rdi
int v11; // ebx
unsigned int v12; // ebx
size_t v14; // rdx
__m128 v15; // xmm0
size_t v16;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV RCX,qword ptr [RDI + 0x8]
MOV dword ptr [RSP + 0x2c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x50]
MOV byte ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x4... | /* func0(std::string, int) */
int func0(long *param_1,int param_2)
{
char cVar1;
ulong *puVar2;
ulong uVar3;
ulong *puVar4;
ulong uVar5;
ulong uVar6;
int iVar7;
int iVar8;
ulong uVar9;
size_t sVar10;
ulong uVar11;
long in_FS_OFFSET;
bool bVar12;
char local_aa;
char local_a9;
ulong *loc... |
272 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> arr){
vector<int> out={};
for (int i=0;i<arr.size();i++)
if (arr[i]%2==0 and (out.size()==0 or arr[i]<out[0]))
out={arr[i],i};
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({4,2,3}) , {2, 1}));
assert (issame(func0({1,2,3}) , {2, 1})... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
movq ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov rax, [rbp+var_48]
pxor xmm0, xmm0
movups xmmword ptr [rax], xmm0
movq qwo... | long long func0(long long a1, long long a2)
{
int v2; // ebx
int i; // [rsp+1Ch] [rbp-34h]
_DWORD v6[2]; // [rsp+20h] [rbp-30h] BYREF
unsigned long long v7; // [rsp+28h] [rbp-28h]
v7 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
std::vector<int>::vector(a1);
for ( i = 0; i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword ptr [RAX + 0x10],XMM... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int iVar1;
bool bVar2;
uint *puVar3;
long lVar4;
int *piVar5;
int4 *puVar6;
ulong uVar7;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>>... |
273 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> arr){
vector<int> out={};
for (int i=0;i<arr.size();i++)
if (arr[i]%2==0 and (out.size()==0 or arr[i]<out[0]))
out={arr[i],i};
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({4,2,3}) , {2, 1}));
assert (issame(func0({1,2,3}) , {2, 1})... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rbp
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
cmp %rdx,0x... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r12, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp rdx, [rsi+8]
jz loc_13... | long long func0(long long a1, long long *a2)
{
long long v2; // rdx
unsigned long long v3; // rbx
int v4; // eax
_DWORD v6[2]; // [rsp+0h] [rbp-38h] BYREF
unsigned long long v7[6]; // [rsp+8h] [rbp-30h] BYREF
v7[0] = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v2 = *a2;
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP RDX,qword ptr [RSI + 0x8]
JZ 0x00101340
MOV RBP,RSI
MOV EBX,0x0
MOV R1... | /* func0(std::vector<int, std::allocator<int> >) */
int (*) [16] func0(vector param_1)
{
uint uVar1;
long lVar2;
ulong uVar3;
long *in_RSI;
int4 in_register_0000003c;
int (*pauVar4) [16];
long in_FS_OFFSET;
uint local_38;
int4 local_34;
long local_30 [2];
pauVar4 = (int (*) [16])CONCAT44(in_r... |
274 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> arr){
vector<int> out={};
for (int i=0;i<arr.size();i++)
if (arr[i]%2==0 and (out.size()==0 or arr[i]<out[0]))
out={arr[i],i};
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({4,2,3}) , {2, 1}));
assert (issame(func0({1,2,3}) , {2, 1})... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp rdx, [rsi+8]
jz short ... | long long func0(long long a1, long long *a2)
{
long long v3; // rdx
unsigned long long i; // rbx
signed int v6; // eax
char *v7; // rcx
unsigned long long *v8; // rdi
unsigned long long v9; // xmm0_8
long long v10; // rsi
long long v11; // r13
_QWORD *v12; // rdi
long long v14; // rax
_QWORD *v15... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP RDX,qword ptr [RSI + 0x8]
JZ 0x001019e5
MOV R12,RSI
XOR EBX,EBX
NOP
LA... | /* func0(std::vector<int, std::allocator<int> >) */
int (*) [16] func0(vector param_1)
{
uint *__dest;
void *pvVar1;
int8 *puVar2;
uint *puVar3;
uint uVar4;
ulong uVar5;
uint uVar6;
long *in_RSI;
ulong uVar7;
long lVar8;
int4 in_register_0000003c;
int (*pauVar9) [16];
uint *puVar10;
ulong ... |
275 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> arr){
vector<int> out={};
for (int i=0;i<arr.size();i++)
if (arr[i]%2==0 and (out.size()==0 or arr[i]<out[0]))
out={arr[i],i};
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({4,2,3}) , {2, 1}));
assert (issame(func0({1,2,3}) , {2, 1})... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rdx
mov 0x8(%rsi),... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi+8]
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp rcx, r... | long long func0(long long a1, long long *a2)
{
long long v3; // rcx
long long v4; // rdx
unsigned long long i; // rbx
signed int v7; // eax
char *v8; // rsi
unsigned long long *v9; // rdi
unsigned long long v10; // xmm0_8
long long v11; // rcx
signed long long v12; // r13
_QWORD *v13; // rdi
long... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RCX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP RCX,RDX
JZ 0x00101b0c
MOV R12,RSI
XOR EB... | /* func0(std::vector<int, std::allocator<int> >) */
int (*) [16] func0(vector param_1)
{
uint *__dest;
void *pvVar1;
int8 *puVar2;
uint uVar3;
long lVar4;
ulong uVar5;
long lVar6;
uint uVar7;
ulong uVar8;
long *in_RSI;
uint *puVar9;
int4 in_register_0000003c;
int (*pauVar10) [16];
uint *pu... |
276 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
vector<vector<int>> freq={};
int max=-1;
for (int i=0;i<lst.size();i++)
{
bool has=false;
for (int j=0;j<freq.size();j++)
if (lst[i]==freq[j][0])
{
freq[j][1]+=1;
has=true;
if (freq[j][1]>=freq[j][0]... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, 5, 5, 5, 1}) == 1);
assert (func0({4, 1, 4, 1, 4, 4}) == 4);
assert (func0({3, 3}) == -1);
assert (func0({8, 8, 8, 8, 8, 8, 8, 8}) == 8);
assert (func0({2, 3, 3, 2, 2}) == 2);
assert (func0({2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x78,%rsp
mov %rdi,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movq $0x0,-0x70(%rbp)
movq $0x0,-0x68(%rbp)
movq $0x0,-0x60(%rbp)
lea -0x70(%rbp),%rax
... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 88h
mov [rbp+var_98], rdi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
pxor xmm0, xmm0
movaps [rbp+var_70], xmm0
movq [rbp+var_60], xmm0
lea rax, [rbp+var_70]
mov rdi, ra... | long long func0(long long a1)
{
int v1; // ebx
long long v2; // rax
long long v3; // rax
_DWORD *v4; // rax
long long v5; // rax
int v6; // ebx
long long v7; // rax
long long v8; // rax
int *v9; // rax
long long v11; // rax
unsigned long long v12; // rbx
unsigned long long v14; // rbx
unsigne... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x98],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOVQ qword ptr [RBP + -0x60],XMM0
LEA RAX,[RBP + -0x70]
MOV RDI,RAX
CALL 0x00103ed2
MOV... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
bool bVar2;
vector<int,std::allocator<int>> *pvVar3;
int4 *puVar4;
int *piVar5;
ulong uVar6;
ulong uVar7;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
__new_allocato... |
277 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
vector<vector<int>> freq={};
int max=-1;
for (int i=0;i<lst.size();i++)
{
bool has=false;
for (int j=0;j<freq.size();j++)
if (lst[i]==freq[j][0])
{
freq[j][1]+=1;
has=true;
if (freq[j][1]>=freq[j][0]... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, 5, 5, 5, 1}) == 1);
assert (func0({4, 1, 4, 1, 4, 4}) == 4);
assert (func0({3, 3}) == -1);
assert (func0({8, 8, 8, 8, 8, 8, 8, 8}) == 8);
assert (func0({2, 3, 3, 2, 2}) == 2);
assert (func0({2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 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 %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
mov (%rdi),%r9
cmp %r9,0x8(%rdi)
je 1448... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov [rsp+88h+var_78], 0
mov [rsp+88h+var_70], 0
mov [rsp+88h+var_68], 0
mov r13d, 0
mov r12d... | long long func0(_QWORD *a1)
{
unsigned long long v2; // r13
unsigned int v3; // r12d
unsigned long long v4; // rdx
unsigned int **v5; // rax
signed int v6; // ecx
char v7; // r9
char *v8; // rbp
unsigned long long v9; // rdi
_QWORD *v10; // rdx
long long *v11; // rax
void **v12; // rbp
void *v1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV R13D,0x0
MOV R12D,0xffffffff
MOV R15,-0x5555555555555555
M... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int *piVar1;
int iVar2;
uint uVar3;
void *pvVar4;
bool bVar5;
int8 *puVar6;
int8 *puVar7;
int8 *puVar8;
ulong uVar9;
int4 in_register_0000003c;
long *plVar10;
int iVar11;
ulong uVar12;
long in_FS_OFFSET;
int8... |
278 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
vector<vector<int>> freq={};
int max=-1;
for (int i=0;i<lst.size();i++)
{
bool has=false;
for (int j=0;j<freq.size();j++)
if (lst[i]==freq[j][0])
{
freq[j][1]+=1;
has=true;
if (freq[j][1]>=freq[j][0]... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, 5, 5, 5, 1}) == 1);
assert (func0({4, 1, 4, 1, 4, 4}) == 4);
assert (func0({3, 3}) == -1);
assert (func0({8, 8, 8, 8, 8, 8, 8, 8}) == 8);
assert (func0({2, 3, 3, 2, 2}) == 2);
assert (func0({2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3... | O2 | 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),%r10
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
cmp %r10,0x8(%rdi)
je 28... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
mov ebx, 0FFFFFFFFh
sub rsp, 58h
mov rsi, [rdi]
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
movaps [rsp+88h+var_78], xmm0
mov [rsp+88h+var_68], 0
cmp ... | long long func0(long long *a1)
{
int v1; // ebx
long long v2; // rsi
unsigned long long v3; // r12
char *v4; // rbp
char *v5; // r13
int **v6; // rdx
char v7; // r10
_DWORD *v8; // r8
unsigned long long v9; // rax
int *v10; // r9
int v11; // ecx
int v12; // r11d
int v13; // r9d
char *v14; /... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,0xffffffff
SUB RSP,0x58
MOV RSI,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
CMP qword ptr [RDI + 0x8],RSI
JZ 0x001023... | /* func0(std::vector<int, std::allocator<int> >) */
uint func0(vector param_1)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
void *pvVar5;
bool bVar6;
uint uVar7;
ulong uVar8;
int8 *puVar9;
uint uVar10;
int8 *puVar11;
long lVar12;
int4 in_register_0000003c;
long *plVar13;
ulong u... |
279 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> lst){
vector<vector<int>> freq={};
int max=-1;
for (int i=0;i<lst.size();i++)
{
bool has=false;
for (int j=0;j<freq.size();j++)
if (lst[i]==freq[j][0])
{
freq[j][1]+=1;
has=true;
if (freq[j][1]>=freq[j][0]... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({5, 5, 5, 5, 1}) == 1);
assert (func0({4, 1, 4, 1, 4, 4}) == 4);
assert (func0({3, 3}) == -1);
assert (func0({8, 8, 8, 8, 8, 8, 8, 8}) == 8);
assert (func0({2, 3, 3, 2, 2}) == 2);
assert (func0({2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov (%rdi),%r10
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movaps %xmm0,(%rsp)
movq $0x0,0x10(%rsp)
cmp %r10,0x8(%rdi)
je 247c... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
mov ebx, 0FFFFFFFFh
sub rsp, 58h
mov [rsp+88h+var_80], rdi
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov rax, rdi
mov rdi, [rdi+8]
movaps [rsp+88h+v... | long long func0(long long *a1)
{
unsigned int v1; // ebx
long long v3; // rdi
long long v4; // rsi
unsigned long long v5; // r12
char *v6; // r13
char *v7; // rbp
signed int **v8; // rdx
char v9; // r10
_DWORD *v10; // r9
unsigned long long v11; // rax
signed int *v12; // r11
signed int v13; //... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,0xffffffff
SUB RSP,0x58
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RAX,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x2... | /* func0(std::vector<int, std::allocator<int> >) */
uint func0(vector param_1)
{
uint *puVar1;
uint uVar2;
uint uVar3;
uint *puVar4;
void *pvVar5;
bool bVar6;
uint uVar7;
ulong uVar8;
int8 *puVar9;
uint uVar10;
int8 *puVar11;
long lVar12;
int4 in_register_0000003c;
long *plVar13;
long lV... |
280 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> lst){
vector<int> out={};
sort(lst.begin(),lst.end());
int l=0,r=lst.size()-1;
while (l<r)
{
out.push_back(lst[l]);
l+=1;
out.push_back(lst[r]);
r-=1;
}
if (l==r) out.push_back(lst[l]);
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({1, 2, 3, 4}) , {1, 4, 2, 3}));
assert (issame(func0({5, 6, ... | 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)
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 -... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, [rbp+var_28]
pxor xmm0, xmm0
movups xmmword ptr [rax], xmm0
movq qword ptr [rax+10h], xmm0
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorI... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
long long v4; // rax
long long v5; // rax
long long v6; // rax
int v8; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
std::vector<int>::vector(a1);
v2 = ... | 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 0x001026ba
MOV RAX,qword ptr [RBP + -0x... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
int *piVar3;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int local_20;
int loca... |
281 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> lst){
vector<int> out={};
sort(lst.begin(),lst.end());
int l=0,r=lst.size()-1;
while (l<r)
{
out.push_back(lst[l]);
l+=1;
out.push_back(lst[r]);
r-=1;
}
if (l==r) out.push_back(lst[l]);
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({1, 2, 3, 4}) , {1, 4, 2, 3}));
assert (issame(func0({5, 6, ... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %rsi,%r14
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov 0x8(%rsi),%rbp
mov (%rsi),%r13
cmp %rbp,%r13
je 1343 <_Z5fun... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov r12, rsi
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rbp, [rsi+8]
mov r14, [rsi]
cmp r14, rbp
jz loc_1342
mov ... | long long func0(long long a1, char **a2)
{
char *v4; // rbp
char *v5; // r14
int v6; // eax
unsigned long long v7; // rax
char *v8; // rdi
char *v9; // rsi
int v10; // ecx
char *v11; // rax
int v12; // edx
long long v13; // r15
int v14; // r14d
long long v15; // r13
long long v16; // rbp
in... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV R12,RSI
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RBP,qword ptr [RSI + 0x8]
MOV R14,qword ptr [RSI]
CMP R14,RBP
JZ 0x00101342
MOV R13,RBP
SUB R13,R14
MOV RDX,R13
SAR RDX,0x2
MOV EAX,0x4... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int *piVar1;
int *piVar2;
int *piVar3;
int *piVar4;
uint uVar5;
_Iter_less_iter in_ECX;
_Iter_less_iter extraout_EDX;
ulong uVar6;
long lVar7;
long *in_RSI;
__normal_iterator _Var8;
in... |
282 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> lst){
vector<int> out={};
sort(lst.begin(),lst.end());
int l=0,r=lst.size()-1;
while (l<r)
{
out.push_back(lst[l]);
l+=1;
out.push_back(lst[r]);
r-=1;
}
if (l==r) out.push_back(lst[l]);
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({1, 2, 3, 4}) , {1, 4, 2, 3}));
assert (issame(func0({5, 6, ... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov 0x8(%rsi),%rbp
mov (%rsi),%r13
cmp %rbp,%r13
je 1f69 <_Z5func0St6vectorIiSaIi... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov r12, [rsi+8]
mov r13, [rsi]
cmp r13, r12
jz loc_1F69
mov rbp, r12
mov ... | long long func0(long long a1, char **a2)
{
char *v3; // r12
char *v4; // r13
long long v6; // rdx
unsigned long long v7; // rax
char *v8; // rax
long long v9; // r15
unsigned int v10; // edx
unsigned int v11; // r13d
long long v12; // rbp
long long v13; // r12
long long v14; // rsi
char *v15; /... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV R12,qword ptr [RSI + 0x8]
MOV R13,qword ptr [RSI]
CMP R13,R12
JZ 0x00101f69
MOV RBP,R12
MOV R14,RSI
MOV RDX,-0x2
SUB RBP,R13
MOV RAX,RBP
SAR RAX,0x... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
int *piVar6;
_Iter_less_iter in_ECX;
_Iter_less_iter extraout_EDX;
uint uVar7;
long lVar8;
long lVar9;
long *in_RSI;
int ... |
283 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<int> func0(vector<int> lst){
vector<int> out={};
sort(lst.begin(),lst.end());
int l=0,r=lst.size()-1;
while (l<r)
{
out.push_back(lst[l]);
l+=1;
out.push_back(lst[r]);
r-=1;
}
if (l==r) out.push_back(lst[l]);
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({1, 2, 3, 4}) , {1, 4, 2, 3}));
assert (issame(func0({5, 6, ... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov 0x8(%rsi),%rbp
mov (%rsi),%r15
cmp %rbp,%r15
je 1f2a <_Z5func0St6vectorIiSaIiEE... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov r13, [rsi+8]
mov rcx, [rsi]
cmp rcx, r13
jz loc_20BC
mov r15, r13
mov ... | long long func0(long long a1, char **a2)
{
char *v3; // r13
char *v4; // rcx
char *v6; // rbp
long long v7; // r15
long long j; // r12
unsigned long long v9; // rdx
char *v10; // rcx
char *v11; // r15
int v12; // r12d
char *v13; // rsi
int v14; // edx
char *i; // rax
int v16; // esi
int v17... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV R13,qword ptr [RSI + 0x8]
MOV RCX,qword ptr [RSI]
CMP RCX,R13
JZ 0x001020bc
MOV R15,R13
MOV R14,RSI
LEA RBP,[RCX + 0x4]
SUB R15,RCX
MOV RAX,R15
SA... | /* 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,int8 param_7)
{
int iVar1;
int *piVar2;
int iVar3;
uint uVar4;
ulong uVar5;
int *piVar6;
__normal_iterator _Var7;
int *piVar8;
... |
284 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float a,float b,float c){
if (a+b<=c or a+c<=b or b+c<=a) return -1;
float h=(a+b+c)/2;
float area;
area=pow(h*(h-a)*(h-b)*(h-c),0.5);
return area;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0(3, 4, 5)-6.00)<0.01);
assert (abs(func0(1, 2, 10) +1)<0.01);
assert (abs(func0(4, 8, 5) -8.18)<0.01);
assert (abs(func0(2, 2, 2) -1.73)<0.01);
assert (abs(func0(1, 2, 3) +1)<0.01);
assert (abs(func0(10, 5, 7) - 16.25)<0.01);
ass... | O0 | cpp | func0(float, float, float):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
movss %xmm0,-0x14(%rbp)
movss %xmm1,-0x18(%rbp)
movss %xmm2,-0x1c(%rbp)
movss -0x14(%rbp),%xmm0
movaps %xmm0,%xmm1
addss -0x18(%rbp),%xmm1
movss -0x1c(%rbp),%xmm0
comiss %xmm1,%xmm0
jae 11c9 <_Z5func0fff+0x60>
movss -0x14(%rbp)... | _Z5func0fff:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
movss [rbp+var_14], xmm0
movss [rbp+var_18], xmm1
movss [rbp+var_1C], xmm2
movss xmm0, [rbp+var_14]
movaps xmm1, xmm0
addss xmm1, [rbp+var_18]
movss xmm0, [rbp+var_1C]
comiss xmm0, xmm1
jnb short loc_11C9
movss xmm0, [rbp+var_14]
mov... | void func0(float a1, float a2, float a3)
{
__m128i v3; // xmm0
__m128i v4; // xmm1
unsigned int v7; // [rsp+18h] [rbp-8h]
if ( a3 < (float)(a1 + a2) && a2 < (float)(a1 + a3) && a1 < (float)(a2 + a3) )
{
*(float *)&v7 = (float)((float)(a1 + a2) + a3) / 2.0;
v3 = (__m128i)v7;
*(float *)v3.m128i_i3... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOVSS dword ptr [RBP + -0x14],XMM0
MOVSS dword ptr [RBP + -0x18],XMM1
MOVSS dword ptr [RBP + -0x1c],XMM2
MOVSS XMM0,dword ptr [RBP + -0x14]
MOVAPS XMM1,XMM0
ADDSS XMM1,dword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RBP + -0x1c]
COMISS XMM0,XMM1
JNC 0x001011c9
MOVSS XMM0,d... | /* func0(float, float, float) */
void func0(float param_1,float param_2,float param_3)
{
float fVar1;
if (((param_3 < param_1 + param_2) && (param_2 < param_1 + param_3)) &&
(param_1 < param_2 + param_3)) {
fVar1 = (param_1 + param_2 + param_3) / DAT_00102184;
std::pow<float,double>
... |
285 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float a,float b,float c){
if (a+b<=c or a+c<=b or b+c<=a) return -1;
float h=(a+b+c)/2;
float area;
area=pow(h*(h-a)*(h-b)*(h-c),0.5);
return area;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0(3, 4, 5)-6.00)<0.01);
assert (abs(func0(1, 2, 10) +1)<0.01);
assert (abs(func0(4, 8, 5) -8.18)<0.01);
assert (abs(func0(2, 2, 2) -1.73)<0.01);
assert (abs(func0(1, 2, 3) +1)<0.01);
assert (abs(func0(10, 5, 7) - 16.25)<0.01);
ass... | O1 | cpp | func0(float, float, float):
endbr64
movaps %xmm0,%xmm3
addss %xmm1,%xmm3
comiss %xmm3,%xmm2
jae 11cf <_Z5func0fff+0x86>
movss 0xea3(%rip),%xmm4
movaps %xmm0,%xmm5
addss %xmm2,%xmm5
comiss %xmm5,%xmm1
jae 11d7 <_Z5func0fff+0x8e>
movaps %xmm1,%xmm5
addss %xmm2,%xmm5
comiss %xmm5,%xmm0
jae 11d7 <_Z5func0fff+0... | _Z5func0fff:
endbr64
movaps xmm3, xmm0
addss xmm3, xmm1
comiss xmm2, xmm3
jnb short loc_11CB
movaps xmm4, xmm0
addss xmm4, xmm2
comiss xmm1, xmm4
jnb short loc_11D7
movss xmm4, cs:dword_2004
movaps xmm5, xmm1
addss xmm5, xmm2
comiss xmm0, xmm5
jnb short loc_11D3
sub rsp, 8
addss xmm3, xm... | __int128 __usercall func0@<xmm0>(float a1@<xmm0>, float a2@<xmm1>, float a3@<xmm2>)
{
__int128 v3; // xmm4
double v4; // xmm0_8
__int128 v5; // xmm4
if ( a3 >= (float)(a1 + a2) )
return 0xBF800000;
if ( a2 >= (float)(a1 + a3) )
return 0xBF800000;
v3 = 0xBF800000;
if ( a1 < (float)(a2 + a3) )
{
... | func0:
ENDBR64
MOVAPS XMM3,XMM0
ADDSS XMM3,XMM1
COMISS XMM2,XMM3
JNC 0x001011cb
MOVAPS XMM4,XMM0
ADDSS XMM4,XMM2
COMISS XMM1,XMM4
JNC 0x001011d7
MOVSS XMM4,dword ptr [0x00102004]
MOVAPS XMM5,XMM1
ADDSS XMM5,XMM2
COMISS XMM0,XMM5
JNC 0x001011d3
SUB RSP,0x8
ADDSS XMM3,XMM2
MULSS XMM3,dword ptr [0x00102008]
MOVAPS XMM4,XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(float, float, float) */
float func0(float param_1,float param_2,float param_3)
{
double dVar1;
float fVar2;
if (((param_3 < param_1 + param_2) && (param_2 < param_1 + param_3)) &&
(param_1 < param_2 + param_3))... |
286 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float a,float b,float c){
if (a+b<=c or a+c<=b or b+c<=a) return -1;
float h=(a+b+c)/2;
float area;
area=pow(h*(h-a)*(h-b)*(h-c),0.5);
return area;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0(3, 4, 5)-6.00)<0.01);
assert (abs(func0(1, 2, 10) +1)<0.01);
assert (abs(func0(4, 8, 5) -8.18)<0.01);
assert (abs(func0(2, 2, 2) -1.73)<0.01);
assert (abs(func0(1, 2, 3) +1)<0.01);
assert (abs(func0(10, 5, 7) - 16.25)<0.01);
ass... | O2 | cpp | func0(float, float, float):
endbr64
movaps %xmm0,%xmm3
movss 0xe95(%rip),%xmm5
addss %xmm1,%xmm3
comiss %xmm3,%xmm2
jae 11f0 <_Z5func0fff+0x90>
movaps %xmm0,%xmm4
addss %xmm2,%xmm4
comiss %xmm4,%xmm1
jae 11f0 <_Z5func0fff+0x90>
movaps %xmm1,%xmm4
addss %xmm2,%xmm4
comiss %xmm4,%xmm0
jae 11f0 <_Z5func0fff+0... | _Z5func0fff:
endbr64
movaps xmm3, xmm0
addss xmm3, xmm1
comiss xmm2, xmm3
jnb short loc_11E8
movaps xmm4, xmm0
addss xmm4, xmm2
comiss xmm1, xmm4
movss xmm4, cs:dword_2004
jnb short loc_11F0
movaps xmm5, xmm1
addss xmm5, xmm2
comiss xmm0, xmm5
jnb short loc_11F0
sub rsp, 8
addss xmm3, xm... | __int128 __usercall func0@<xmm0>(float a1@<xmm0>, float a2@<xmm1>, float a3@<xmm2>)
{
__int128 v3; // xmm4
double v4; // xmm0_8
__int128 v5; // xmm4
if ( a3 >= (float)(a1 + a2) )
return 0xBF800000;
v3 = 0xBF800000;
if ( a2 < (float)(a1 + a3) && a1 < (float)(a2 + a3) )
{
v4 = pow(
(floa... | func0:
ENDBR64
MOVAPS XMM3,XMM0
ADDSS XMM3,XMM1
COMISS XMM2,XMM3
JNC 0x001011e8
MOVAPS XMM4,XMM0
ADDSS XMM4,XMM2
COMISS XMM1,XMM4
MOVSS XMM4,dword ptr [0x00102004]
JNC 0x001011f0
MOVAPS XMM5,XMM1
ADDSS XMM5,XMM2
COMISS XMM0,XMM5
JNC 0x001011f0
SUB RSP,0x8
ADDSS XMM3,XMM2
MULSS XMM3,dword ptr [0x00102008]
MOVAPS XMM4,XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(float, float, float) */
float func0(float param_1,float param_2,float param_3)
{
double dVar1;
float fVar2;
if (((param_3 < param_1 + param_2) && (param_2 < param_1 + param_3)) &&
(param_1 < param_2 + param_3))... |
287 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float a,float b,float c){
if (a+b<=c or a+c<=b or b+c<=a) return -1;
float h=(a+b+c)/2;
float area;
area=pow(h*(h-a)*(h-b)*(h-c),0.5);
return area;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0(3, 4, 5)-6.00)<0.01);
assert (abs(func0(1, 2, 10) +1)<0.01);
assert (abs(func0(4, 8, 5) -8.18)<0.01);
assert (abs(func0(2, 2, 2) -1.73)<0.01);
assert (abs(func0(1, 2, 3) +1)<0.01);
assert (abs(func0(10, 5, 7) - 16.25)<0.01);
ass... | O3 | cpp | func0(float, float, float):
endbr64
movaps %xmm0,%xmm3
movss 0xe95(%rip),%xmm5
addss %xmm1,%xmm3
comiss %xmm3,%xmm2
jae 11f0 <_Z5func0fff+0x90>
movaps %xmm0,%xmm4
addss %xmm2,%xmm4
comiss %xmm4,%xmm1
jae 11f0 <_Z5func0fff+0x90>
movaps %xmm1,%xmm4
addss %xmm2,%xmm4
comiss %xmm4,%xmm0
jae 11f0 <_Z5func0fff+0... | _Z5func0fff:
endbr64
movaps xmm3, xmm0
addss xmm3, xmm1
comiss xmm2, xmm3
jnb short loc_11E8
movaps xmm4, xmm0
addss xmm4, xmm2
comiss xmm1, xmm4
movss xmm4, cs:dword_2004
jnb short loc_11F0
movaps xmm5, xmm1
addss xmm5, xmm2
comiss xmm0, xmm5
jnb short loc_11F0
sub rsp, 8
addss xmm3, xm... | __int128 __usercall func0@<xmm0>(float a1@<xmm0>, float a2@<xmm1>, float a3@<xmm2>)
{
__int128 v3; // xmm4
double v4; // xmm0_8
__int128 v5; // xmm4
if ( a3 >= (float)(a1 + a2) )
return 0xBF800000;
v3 = 0xBF800000;
if ( a2 < (float)(a1 + a3) && a1 < (float)(a2 + a3) )
{
v4 = pow(
(floa... | func0:
ENDBR64
MOVAPS XMM3,XMM0
ADDSS XMM3,XMM1
COMISS XMM2,XMM3
JNC 0x001011e8
MOVAPS XMM4,XMM0
ADDSS XMM4,XMM2
COMISS XMM1,XMM4
MOVSS XMM4,dword ptr [0x00102004]
JNC 0x001011f0
MOVAPS XMM5,XMM1
ADDSS XMM5,XMM2
COMISS XMM0,XMM5
JNC 0x001011f0
SUB RSP,0x8
ADDSS XMM3,XMM2
MULSS XMM3,dword ptr [0x00102008]
MOVAPS XMM4,XM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(float, float, float) */
float func0(float param_1,float param_2,float param_3)
{
double dVar1;
float fVar2;
if (((param_3 < param_1 + param_2) && (param_2 < param_1 + param_3)) &&
(param_1 < param_2 + param_3))... |
288 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> q,int w){
int sum=0;
for (int i=0;i<q.size();i++)
{
if (q[i]!=q[q.size()-1-i]) return false;
sum+=q[i];
}
if (sum>w) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({3, 2, 3}, 9)==true);
assert (func0({1, 2}, 5) == false);
assert (func0({3}, 5) == true);
assert (func0({3, 2, 3}, 1) == false);
assert (func0({1, 2, 3}, 6) ==false);
assert (func0({5}, 5) == true);
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1818 <_ZNKSt6vec... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_12DE
loc_126D:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov ... | _BOOL8 func0(long long a1, int a2)
{
int v2; // ebx
long long v3; // rax
int v5; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v5 = 0;
for ( i = 0; i < (unsigned long long)std::vector<int>::size(a1); ++i )
{
v2 = *(_DWORD *)std::vector<int>::operator[](a1, i);
v3 = std::vector<int>::size(... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012de
LAB_0010126d:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CA... | /* func0(std::vector<int, std::allocator<int> >, int) */
bool func0(vector param_1,int param_2)
{
int iVar1;
int *piVar2;
long lVar3;
ulong uVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int local_20;
int local_1c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_re... |
289 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> q,int w){
int sum=0;
for (int i=0;i<q.size();i++)
{
if (q[i]!=q[q.size()-1-i]) return false;
sum+=q[i];
}
if (sum>w) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({3, 2, 3}, 9)==true);
assert (func0({1, 2}, 5) == false);
assert (func0({3}, 5) == true);
assert (func0({3, 2, 3}, 1) == false);
assert (func0({1, 2, 3}, 6) ==false);
assert (func0({5}, 5) == true);
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rax
sub %r8,%rax
mov %rax,%rdx
sar $0x2,%rdx
mov %rdx,%r9
je 124f <_Z5func0St6vectorIiSaIiEEi+0x46>
lea -0x4(%r8,%rax,1),%rdx
mov $0x0,%eax
mov $0x0,%edi
mov (%r8,%rax,4),%ecx
cmp (%rdx),%ecx
j... | _Z5func0St6vectorIiSaIiEEi:
endbr64
mov rax, [rdi+8]
mov r8, [rdi]
mov rdx, rax
sub rdx, r8
mov r9, rdx
sar r9, 2
cmp rax, r8
jz short loc_1252
lea rdx, [r8+rdx-4]
mov eax, 0
mov edi, 0
loc_1235:
mov ecx, [r8+rax*4]
cmp ecx, [rdx]
jnz short loc_1259
add edi, ... | bool func0(long long *a1, int a2)
{
long long v2; // r8
unsigned long long v3; // r9
_DWORD *v4; // rdx
unsigned long long v5; // rax
int v6; // edi
int v7; // ecx
v2 = *a1;
v3 = (a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
{
v6 = 0;
return a2 >= v6;
}
else
{
v4 = (_DWORD *)(a1[1] - 4... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV R8,qword ptr [RDI]
MOV RDX,RAX
SUB RDX,R8
MOV R9,RDX
SAR R9,0x2
CMP RAX,R8
JZ 0x00101252
LEA RDX,[R8 + RDX*0x1 + -0x4]
MOV EAX,0x0
MOV EDI,0x0
LAB_00101235:
MOV ECX,dword ptr [R8 + RAX*0x4]
CMP ECX,dword ptr [RDX]
JNZ 0x00101259
ADD EDI,ECX
ADD RAX,0x1
SUB RDX,0x4
CMP RA... | /* func0(std::vector<int, std::allocator<int> >, int) */
int8 func0(vector param_1,int param_2)
{
int iVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
int *piVar5;
int iVar6;
int4 in_register_0000003c;
uVar3 = ((ulong *)CONCAT44(in_register_0000003c,param_1))[1];
uVar2 = *(ulong *)CONCAT44(in_registe... |
290 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> q,int w){
int sum=0;
for (int i=0;i<q.size();i++)
{
if (q[i]!=q[q.size()-1-i]) return false;
sum+=q[i];
}
if (sum>w) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({3, 2, 3}, 9)==true);
assert (func0({1, 2}, 5) == false);
assert (func0({3}, 5) == true);
assert (func0({3, 2, 3}, 1) == false);
assert (func0({1, 2, 3}, 6) ==false);
assert (func0({5}, 5) == true);
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rax
sub %r8,%rax
mov %rax,%r9
sar $0x2,%r9
je 1512 <_Z5func0St6vectorIiSaIiEEi+0x42>
lea -0x4(%r8,%rax,1),%rdx
xor %edi,%edi
xor %eax,%eax
jmp 1507 <_Z5func0St6vectorIiSaIiEEi+0x37>
nopw 0x0(%rax,%... | _Z5func0St6vectorIiSaIiEEi:
endbr64
mov rax, [rdi+8]
mov r8, [rdi]
mov rdx, rax
sub rdx, r8
mov r9, rdx
sar r9, 2
cmp rax, r8
jz short loc_14DA
lea rdx, [r8+rdx-4]
xor eax, eax
xor edi, edi
jmp short loc_14CF
loc_14C0:
add rax, 1
add edi, ecx
sub rdx, 4
cmp ... | bool func0(long long *a1, int a2)
{
long long v2; // r8
unsigned long long v3; // r9
_DWORD *v4; // rdx
unsigned long long v5; // rax
int v6; // edi
int v7; // ecx
v2 = *a1;
v3 = (a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
{
v6 = 0;
return a2 >= v6;
}
else
{
v4 = (_DWORD *)(a1[1] - 4... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV R8,qword ptr [RDI]
MOV RDX,RAX
SUB RDX,R8
MOV R9,RDX
SAR R9,0x2
CMP RAX,R8
JZ 0x001014da
LEA RDX,[R8 + RDX*0x1 + -0x4]
XOR EAX,EAX
XOR EDI,EDI
JMP 0x001014cf
LAB_001014c0:
ADD RAX,0x1
ADD EDI,ECX
SUB RDX,0x4
CMP RAX,R9
JNC 0x001014dc
LAB_001014cf:
MOV ECX,dword ptr [R8 +... | /* func0(std::vector<int, std::allocator<int> >, int) */
int8 func0(vector param_1,int param_2)
{
int iVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
int *piVar5;
int iVar6;
int4 in_register_0000003c;
uVar3 = ((ulong *)CONCAT44(in_register_0000003c,param_1))[1];
uVar2 = *(ulong *)CONCAT44(in_registe... |
291 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<int> q,int w){
int sum=0;
for (int i=0;i<q.size();i++)
{
if (q[i]!=q[q.size()-1-i]) return false;
sum+=q[i];
}
if (sum>w) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({3, 2, 3}, 9)==true);
assert (func0({1, 2}, 5) == false);
assert (func0({3}, 5) == true);
assert (func0({3, 2, 3}, 1) == false);
assert (func0({1, 2, 3}, 6) ==false);
assert (func0({5}, 5) == true);
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rax
sub %r8,%rax
mov %rax,%r9
sar $0x2,%r9
je 1512 <_Z5func0St6vectorIiSaIiEEi+0x42>
lea -0x4(%r8,%rax,1),%rdx
xor %edi,%edi
xor %eax,%eax
jmp 1507 <_Z5func0St6vectorIiSaIiEEi+0x37>
nopw 0x0(%rax,%... | _Z5func0St6vectorIiSaIiEEi:
endbr64
mov rax, [rdi+8]
mov r8, [rdi]
mov rdx, rax
sub rdx, r8
mov r9, rdx
sar r9, 2
cmp rax, r8
jz short loc_14DA
lea rdx, [r8+rdx-4]
xor eax, eax
xor edi, edi
jmp short loc_14CF
loc_14C0:
add rax, 1
add edi, ecx
sub rdx, 4
cmp ... | bool func0(long long *a1, int a2)
{
long long v2; // r8
unsigned long long v3; // r9
_DWORD *v4; // rdx
unsigned long long v5; // rax
int v6; // edi
int v7; // ecx
v2 = *a1;
v3 = (a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
{
v6 = 0;
return a2 >= v6;
}
else
{
v4 = (_DWORD *)(a1[1] - 4... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV R8,qword ptr [RDI]
MOV RDX,RAX
SUB RDX,R8
MOV R9,RDX
SAR R9,0x2
CMP RAX,R8
JZ 0x001014da
LEA RDX,[R8 + RDX*0x1 + -0x4]
XOR EAX,EAX
XOR EDI,EDI
JMP 0x001014cf
LAB_001014c0:
ADD RAX,0x1
ADD EDI,ECX
SUB RDX,0x4
CMP RAX,R9
JNC 0x001014dc
LAB_001014cf:
MOV ECX,dword ptr [R8 +... | /* func0(std::vector<int, std::allocator<int> >, int) */
int8 func0(vector param_1,int param_2)
{
int iVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
int *piVar5;
int iVar6;
int4 in_register_0000003c;
uVar3 = ((ulong *)CONCAT44(in_register_0000003c,param_1))[1];
uVar2 = *(ulong *)CONCAT44(in_registe... |
292 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> arr){
int out=0;
for (int i=0;i<arr.size()-1-i;i++)
if (arr[i]!=arr[arr.size()-1-i])
out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3,5,4,7,9,6}) == 4);
assert (func0({1, 2, 3, 4, 3, 2, 2}) == 1);
assert (func0({1, 4, 2}) == 1);
assert (func0({1, 4, 4, 2}) == 1);
assert (func0({1, 2, 3, 2, 1}) == 0);
assert (func0({3, 1, 1, 3}) == 0);
assert (func0({1}) == ... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1a2a <_ZNKSt6vectorIiSaIiEE4sizeEv>
mov -0... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_12BE
loc_126A:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vec... | long long func0(long long a1)
{
int v1; // ebx
long long v2; // rax
unsigned int v4; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v4 = 0;
for ( i = 0; i < (unsigned long long)(std::vector<int>::size(a1) - i - 1); ++i )
{
v1 = *(_DWORD *)std::vector<int>::operator[](a1, i);
v2 = std::vect... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012be
LAB_0010126a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101b36
MOV EBX,dword ptr ... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
int *piVar2;
long lVar3;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int4 local_20;
int4 local_1c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
loc... |
293 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<int> arr){
int out=0;
for (int i=0;i<arr.size()-1-i;i++)
if (arr[i]!=arr[arr.size()-1-i])
out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({1,2,3,5,4,7,9,6}) == 4);
assert (func0({1, 2, 3, 4, 3, 2, 2}) == 1);
assert (func0({1, 4, 2}) == 1);
assert (func0({1, 4, 4, 2}) == 1);
assert (func0({1, 2, 3, 2, 1}) == 0);
assert (func0({3, 1, 1, 3}) == 0);
assert (func0({1}) == ... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rax
sub %rcx,%rax
sar $0x2,%rax
sub $0x1,%rax
je 1247 <_Z5func0St6vectorIiSaIiEE+0x3e>
mov $0x0,%edx
mov $0x0,%esi
jmp 123d <_Z5func0St6vectorIiSaIiEE+0x34>
add $0x1,%esi
add $0x1,%rdx
sub $0x1,%ra... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rcx, [rdi]
mov rax, [rdi+8]
sub rax, rcx
sar rax, 2
sub rax, 1
jz short loc_1247
mov edx, 0
mov esi, 0
jmp short loc_123A
loc_122D:
add rdx, 1
sub rax, 1
cmp rdx, rax
jnb short loc_124C
loc_123A:
mov edi, [rcx+rax*4]
cmp ... | long long func0(_QWORD *a1)
{
unsigned long long v1; // rax
unsigned long long v2; // rdx
unsigned int v3; // esi
v1 = ((long long)(a1[1] - *a1) >> 2) - 1;
if ( (long long)(a1[1] - *a1) >> 2 == 1 )
{
return 0;
}
else
{
v2 = 0LL;
v3 = 0;
do
{
if ( *(_DWORD *)(*a1 + 4 * v2) !... | func0:
ENDBR64
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RCX
SAR RAX,0x2
SUB RAX,0x1
JZ 0x00101247
MOV EDX,0x0
MOV ESI,0x0
JMP 0x0010123a
LAB_0010122d:
ADD RDX,0x1
SUB RAX,0x1
CMP RDX,RAX
JNC 0x0010124c
LAB_0010123a:
MOV EDI,dword ptr [RCX + RAX*0x4]
CMP dword ptr [RCX + RDX*0x4],EDI
JZ 0x0010122d
A... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
long lVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
int4 in_register_0000003c;
lVar1 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar2 = (((long *)CONCAT44(in_register_0000003c,param_1))[1] - lVar1 >> 2) - 1;
if (uV... |
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.