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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
66,500 | mysql_real_query_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_real_query_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_real_query,
(parms->mysql, parms->stmt_str, parms->length),
parms->mysql,
int,
r_int)
} | O3 | c | mysql_real_query_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %rbx
movq 0x10(%rdi), %rdx
movq %rax, %rdi
callq 0x1a242
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_real_query_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rsi, [rdi+8]
mov rcx, [rax+480h]
mov rbx, [rcx+28h]
mov rdx, [rdi+10h]
mov rdi, rax
call mysql_real_query
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop ... | long long mysql_real_query_start_internal(long long *a1)
{
_DWORD *v1; // rbx
long long result; // rax
v1 = *(_DWORD **)(*(_QWORD *)(*a1 + 1152) + 40LL);
result = mysql_real_query(*a1, a1[1], a1[2]);
v1[2] = result;
*v1 = 0;
return result;
}
| mysql_real_query_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV RDX,qword ptr [RDI + 0x10]
MOV RDI,RAX
CALL 0x0011a242
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RB... |
void mysql_real_query_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_real_query(*param_1,param_1[1],param_1[2]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
66,501 | Gis_multi_polygon::get_data_as_json(String*, unsigned int, char const**) const | eloqsql/sql/spatial.cc | bool Gis_multi_polygon::get_data_as_json(String *txt, uint max_dec_digits,
const char **end) const
{
uint32 n_polygons;
const char *data= m_data;
if (no_data(data, 4) || txt->reserve(1, 512))
return 1;
n_polygons= uint4korr(data);
data+= 4;
txt->q_append('[');
... | O0 | cpp | Gis_multi_polygon::get_data_as_json(String*, unsigned int, char const**) const:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rb... | _ZNK17Gis_multi_polygon16get_data_as_jsonEP6StringjPPKc:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_10]; this
mov [rbp+var_48], rdi
mov rax, [rdi+8]
mov [rbp+var_38], rax
mov ... | char Gis_multi_polygon::get_data_as_json(Gis_multi_polygon *this, String *a2, int a3, char **a4)
{
int v6; // eax
int v7; // eax
unsigned int v9; // [rsp+20h] [rbp-40h]
int v10; // [rsp+24h] [rbp-3Ch]
char *v11; // [rsp+28h] [rbp-38h]
char *appended; // [rsp+28h] [rbp-38h]
char *v13; // [rsp+28h] [rbp-38... | fix_length_and_dec:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xe],0x0
LEA RDI,[RBP + -0x20]
CALL 0x008f0210
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,q... |
/* Item_handled_func::Handler_slong::fix_length_and_dec(Item_handled_func*) const */
int8 __thiscall
Item_handled_func::Handler_slong::fix_length_and_dec(Handler_slong *this,Item_handled_func *param_1)
{
int8 local_28;
int8 local_20;
Item *local_18;
Handler_slong *local_10;
param_1[0xe] = (Item_handled_... | |
66,502 | testing::internal::WideStringToUtf8[abi:cxx11](wchar_t const*, int) | AlayaLite/build_O3/_deps/googletest-src/googletest/src/gtest.cc | std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
if (num_chars == -1) num_chars = static_cast<int>(wcslen(str));
::std::stringstream stream;
for (int i = 0; i < num_chars; ++i) {
uint32_t unicode_code_point;
if (str[i] == L'\0') {
break;
} else if (i + 1 < num_chars && IsUtf16... | O3 | cpp | testing::internal::WideStringToUtf8[abi:cxx11](wchar_t const*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
cmpl $-0x1, %edx
jne 0x60bd8
movq %r14, %rdi
callq 0x117a0
movq %rax, %r12
leaq 0x30(%rs... | _ZN7testing8internal16WideStringToUtf8B5cxx11EPKwi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1B8h
mov r12d, edx
mov r14, rsi
mov qword ptr [rsp+1E8h+var_1E0], rdi; int
cmp edx, 0FFFFFFFFh
jnz short loc_60BD8
mov rdi, r14
call _wcslen
mov r12, ra... | long long testing::internal::WideStringToUtf8[abi:cxx11](long long a1, long long a2, int a3)
{
int v3; // r12d
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
long long i; // rbx
int v10; // esi
void *v12; // [rsp+0h] [rbp-1E8h]
long long v13; // [rsp+8h] [rbp-1E0h]
void *v14; // [rsp+1... | WideStringToUtf8[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1b8
MOV R12D,EDX
MOV R14,RSI
MOV qword ptr [RSP + 0x8],RDI
CMP EDX,-0x1
JNZ 0x00160bd8
MOV RDI,R14
CALL 0x001117a0
MOV R12,RAX
LAB_00160bd8:
LEA RDI,[RSP + 0x30]
CALL 0x00111380
TEST R12D,R12D
JLE 0x00160c3c
LEA R15,[RSP + 0x40... |
/* testing::internal::WideStringToUtf8[abi:cxx11](wchar_t const*, int) */
internal * __thiscall
testing::internal::WideStringToUtf8_abi_cxx11_(internal *this,wchar_t *param_1,int param_2)
{
size_t sVar1;
ulong uVar2;
long *local_1d8;
long local_1d0;
long local_1c8 [2];
stringstream local_1b8 [16];
ostr... | |
66,503 | JS_GetPropertyInternalWithIC | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_GetPropertyInternalWithIC(JSContext *ctx, JSValue obj,
JSAtom prop, JSValue this_obj,
JSInlineCacheUpdate *icu,
BOOL throw_ref_error)
{
uint32_t tag, offset;
JSOb... | O1 | c | JS_GetPropertyInternalWithIC:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq 0x60(%rsp), %rbx
movq %rsi, 0x10(%rsp)
cmpl $-0x1, %r12d
jne 0x3fc54
leaq 0x10(%rsp), %rdi
leaq 0x18(%r... | JS_GetPropertyInternalWithIC:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_50], r9
mov r14, r8
mov ebp, ecx
mov r12, rdx
mov r13, rsi
mov r15, rdi
mov rbx, [rsp+58h+arg_0]
mov [rsp+58h+var_48], rsi
cmp r12d, 0FFFFFFFFh
jnz ... | unsigned long long JS_GetPropertyInternalWithIC(
long long a1,
long long a2,
long long a3,
unsigned int a4,
long long a5,
long long a6,
unsigned int *a7)
{
long long v12; // [rsp+10h] [rbp-48h] BYREF
long long v13; // [rsp+18h] [rbp-40h] BYREF
v12 = a2;
... | |||
66,504 | JS_GetPropertyInternalWithIC | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_GetPropertyInternalWithIC(JSContext *ctx, JSValue obj,
JSAtom prop, JSValue this_obj,
JSInlineCacheUpdate *icu,
BOOL throw_ref_error)
{
uint32_t tag, offset;
JSOb... | O2 | c | JS_GetPropertyInternalWithIC:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x40(%rsp), %r15
cmpl $-0x1, %r12d
jne 0x37ed5
movq 0x18(%r13), %rsi
movq %r15, %rdi
callq 0x39b04
cmpl $-0x1, %... | JS_GetPropertyInternalWithIC:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_38], r9
mov r14, r8
mov ebp, ecx
mov r12, rdx
mov r13, rsi
mov rbx, rdi
mov r15, [rsp+38h+arg_0]
cmp r12d, 0FFFFFFFFh
jnz short loc_37ED5
mov rsi, [r... | _DWORD * JS_GetPropertyInternalWithIC(
long long a1,
long long a2,
long long a3,
int a4,
long long a5,
long long a6,
long long a7)
{
unsigned int ic_prop_offset; // eax
long long v11; // rcx
long long v12; // rdx
_DWORD *result; // rax
if ( (_DWORD)a3 !... | JS_GetPropertyInternalWithIC:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RSP],R9
MOV R14,R8
MOV EBP,ECX
MOV R12,RDX
MOV R13,RSI
MOV RBX,RDI
MOV R15,qword ptr [RSP + 0x40]
CMP R12D,-0x1
JNZ 0x00137ed5
MOV RSI,qword ptr [R13 + 0x18]
MOV RDI,R15
CALL 0x00139b04
CMP EAX,-0x1
JZ 0x00137ed5... |
void JS_GetPropertyInternalWithIC
(int8 param_1,long param_2,int8 param_3,int4 param_4,
int8 param_5,int8 param_6,int8 param_7)
{
int *piVar1;
uint uVar2;
if (((int)param_3 == -1) &&
(uVar2 = get_ic_prop_offset(param_7,*(int8 *)(param_2 + 0x18)), uVar2 != 0xffffffff)) {
... | |
66,505 | ImPlot3D::ShowLegendEntries(ImPlot3DItemGroup&, ImRect const&, bool, ImVec2 const&, ImVec2 const&, bool, ImDrawList&) | zkingston[P]unknot/build_O1/_deps/implot3d-src/implot3d.cpp | void ShowLegendEntries(ImPlot3DItemGroup& items, const ImRect& legend_bb, bool hovered, const ImVec2& pad, const ImVec2& spacing, bool vertical, ImDrawList& draw_list) {
const float txt_ht = ImGui::GetTextLineHeight();
const float icon_size = txt_ht;
const float icon_shrink = 2;
ImU32 col_txt = GetStyle... | O1 | cpp | ImPlot3D::ShowLegendEntries(ImPlot3DItemGroup&, ImRect const&, bool, ImVec2 const&, ImVec2 const&, bool, ImDrawList&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %r9d, 0x24(%rsp)
movq %r8, 0x28(%rsp)
movq %rcx, %r14
movq %rsi, 0x60(%rsp)
movq %rdi, %r13
callq 0x22c54f
movaps... | _ZN8ImPlot3D17ShowLegendEntriesER17ImPlot3DItemGroupRK6ImRectbRK6ImVec2S7_bR10ImDrawList:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov [rsp+0F8h+var_D4], r9d
mov [rsp+0F8h+var_D0], r8
mov r14, rcx
mov [rsp+0F8h+var_98], rsi
mov r13, rdi
call _ZN5Im... | long long ImPlot3D::ShowLegendEntries(
long long a1,
unsigned int *a2,
int a3,
float *a4,
long long a5,
int a6,
__m128 a7,
ImDrawList *a8)
{
const double *v10; // rcx
long long result; // rax
bool v12; // cl
__m128 v13; // xmm1
__m128 v14; // xm... | ShowLegendEntries:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV dword ptr [RSP + 0x24],R9D
MOV qword ptr [RSP + 0x28],R8
MOV R14,RCX
MOV qword ptr [RSP + 0x60],RSI
MOV R13,RDI
CALL 0x0032c54f
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV RCX,qword ptr [0x00436c98]
MOVSS XMM0,dword ptr [RCX + 0x19c]... |
/* ImPlot3D::ShowLegendEntries(ImPlot3DItemGroup&, ImRect const&, bool, ImVec2 const&, ImVec2
const&, bool, ImDrawList&) */
void ImPlot3D::ShowLegendEntries
(ImPlot3DItemGroup *param_1,ImRect *param_2,bool param_3,ImVec2 *param_4,
ImVec2 *param_5,bool param_6,ImDrawList *param_7)
{
... | |
0 | func0 | #include<stdio.h>
#include<vector>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<float> numbers, float threshold){
int i,j;
for (i=0;i<numbers.size();i++)
for (j=i+1;j<numbers.size();j++)
if (abs(numbers[i]-numbers[j])<threshold)
return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
vector<float> a={1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
assert (func0(a, 0.3)==true);
assert (func0(a, 0.05) == false);
assert (func0({1.0, 2.0, 5.9, 4.0, 5.0}, 0.95) == true);
assert (func0({1.0, 2.0, 5.9, 4.0, 5.0}, 0.8) ==false);
assert (func0({1.0, 2.0,... | O0 | cpp | func0(std::vector<float, std::allocator<float> >, float):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movss %xmm0,-0x2c(%rbp)
movl $0x0,-0x18(%rbp)
mov -0x18(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1cbc <_ZNKSt6vectorIfSaIfEE4sizeE... | _Z5func0St6vectorIfSaIfEEf:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
movss [rbp+var_2C], xmm0
mov [rbp+var_18], 0
jmp loc_1301
loc_126B:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_12DD
loc_1276:
mov eax, [rbp+var_... | long long func0(long long a1, float a2)
{
__m128i v2; // xmm2
float v3; // xmm0_4
float v5; // [rsp+0h] [rbp-30h]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
for ( i = 0; i < (unsigned long long)std::vector<float>::size(a1); ++i )
{
for ( j = i + 1; j < (unsigned long long)std::vecto... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOVSS dword ptr [RBP + -0x2c],XMM0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101301
LAB_0010126b:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001012dd
LAB_00101276:
MOV EAX,dword ptr [RBP + -0x1... | /* func0(std::vector<float, std::allocator<float> >, float) */
int8 func0(vector param_1,float param_2)
{
float *pfVar1;
ulong uVar2;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
float fVar3;
int local_20;
int local_1c;
this = (vector<float,std::allocator<float>> *)CONCAT44... |
1 | func0 | #include<stdio.h>
#include<vector>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<float> numbers, float threshold){
int i,j;
for (i=0;i<numbers.size();i++)
for (j=i+1;j<numbers.size();j++)
if (abs(numbers[i]-numbers[j])<threshold)
return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
vector<float> a={1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
assert (func0(a, 0.3)==true);
assert (func0(a, 0.05) == false);
assert (func0({1.0, 2.0, 5.9, 4.0, 5.0}, 0.95) == true);
assert (func0({1.0, 2.0, 5.9, 4.0, 5.0}, 0.8) ==false);
assert (func0({1.0, 2.0,... | O1 | cpp | func0(std::vector<float, std::allocator<float> >, float):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rax
sub %rdx,%rax
sar $0x2,%rax
mov %rax,%rcx
je 12a8 <_Z5func0St6vectorIfSaIfEEf+0x5f>
mov $0x1,%esi
movss 0xfb3(%rip),%xmm3
cmp %rcx,%rsi
jae 1294 <_Z5func0St6vectorIfSaIfEEf+0x4b>
movss -0x4... | _Z5func0St6vectorIfSaIfEEf:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_129D
mov esi, 0
movss xmm3, cs:dword_2220
loc_1270:
add rsi, 1
cmp rsi, rcx
jnb short loc_12A3
movss xmm2, dword ptr [rdx+rsi*4-4]
movsxd r... | long long func0(_QWORD *a1, float a2)
{
unsigned long long v2; // rcx
long long v3; // rsi
long long v4; // rax
v2 = (long long)(a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 0LL;
v3 = 0LL;
LABEL_3:
if ( ++v3 >= v2 )
{
return 0LL;
}
else
{
v4 = (int)v3;
while ( a2 <= fabs(*(float... | 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 0x0010129d
MOV ESI,0x0
MOVSS XMM3,dword ptr [0x00102220]
LAB_00101270:
ADD RSI,0x1
CMP RSI,RCX
JNC 0x001012a3
MOVSS XMM2,dword ptr [RDX + RSI*0x4 + -0x4]
MOVSXD RAX,ESI
LAB_00101282:
MOVAPS XMM1,XMM2
... | /* func0(std::vector<float, std::allocator<float> >, float) */
int8 func0(vector param_1,float param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
int4 in_register_0000003c;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_register_00... |
2 | func0 | #include<stdio.h>
#include<vector>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<float> numbers, float threshold){
int i,j;
for (i=0;i<numbers.size();i++)
for (j=i+1;j<numbers.size();j++)
if (abs(numbers[i]-numbers[j])<threshold)
return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
vector<float> a={1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
assert (func0(a, 0.3)==true);
assert (func0(a, 0.05) == false);
assert (func0({1.0, 2.0, 5.9, 4.0, 5.0}, 0.95) == true);
assert (func0({1.0, 2.0, 5.9, 4.0, 5.0}, 0.8) ==false);
assert (func0({1.0, 2.0,... | O2 | cpp | func0(std::vector<float, std::allocator<float> >, float):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
je 182e <_Z5func0St6vectorIfSaIfEEf+0x6e>
mov $0x1,%esi
movss 0xa3f(%rip),%xmm3
cmp %rdx,%rsi
jae 1820 <_Z5func0St6vectorIfSaIfEEf+0x60>
movss -0x4(%rcx,%rsi,4),%xm... | _Z5func0St6vectorIfSaIfEEf:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_16BF
xor esi, esi
movss xmm3, cs:dword_2220
loc_1684:
add rsi, 1
cmp rsi, rcx
jnb short loc_16BF
movss xmm2, dword ptr [rdx+rsi*4-4]
mov ... | long long func0(_QWORD *a1, float a2)
{
unsigned long long v2; // rcx
long long v3; // rsi
long long v4; // rax
v2 = (long long)(a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 0LL;
v3 = 0LL;
LABEL_3:
if ( ++v3 >= v2 )
return 0LL;
v4 = v3;
while ( a2 <= fabs(*(float *)(*a1 + 4 * v3 - 4) - *(fl... | 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 0x001016bf
XOR ESI,ESI
MOVSS XMM3,dword ptr [0x00102220]
LAB_00101684:
ADD RSI,0x1
CMP RSI,RCX
JNC 0x001016bf
MOVSS XMM2,dword ptr [RDX + RSI*0x4 + -0x4]
MOV RAX,RSI
JMP 0x001016a9
LAB_001016a0:
ADD R... | /* func0(std::vector<float, std::allocator<float> >, float) */
int8 func0(vector param_1,float param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
int4 in_register_0000003c;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_register_00... |
3 | func0 | #include<stdio.h>
#include<vector>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(vector<float> numbers, float threshold){
int i,j;
for (i=0;i<numbers.size();i++)
for (j=i+1;j<numbers.size();j++)
if (abs(numbers[i]-numbers[j])<threshold)
return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
vector<float> a={1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
assert (func0(a, 0.3)==true);
assert (func0(a, 0.05) == false);
assert (func0({1.0, 2.0, 5.9, 4.0, 5.0}, 0.95) == true);
assert (func0({1.0, 2.0, 5.9, 4.0, 5.0}, 0.8) ==false);
assert (func0({1.0, 2.0,... | O3 | cpp | func0(std::vector<float, std::allocator<float> >, float):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
je 183e <_Z5func0St6vectorIfSaIfEEf+0x6e>
mov $0x1,%esi
movss 0xa3f(%rip),%xmm3
cmp %rsi,%rdx
jbe 1830 <_Z5func0St6vectorIfSaIfEEf+0x60>
movss -0x4(%rcx,%rsi,4),%xm... | _Z5func0St6vectorIfSaIfEEf:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rcx, rax
sub rcx, rdx
sar rcx, 2
cmp rax, rdx
jz short loc_16BF
xor esi, esi
movss xmm3, cs:dword_2220
loc_1684:
add rsi, 1
cmp rsi, rcx
jnb short loc_16BF
movss xmm2, dword ptr [rdx+rsi*4-4]
mov ... | long long func0(_QWORD *a1, float a2)
{
unsigned long long v2; // rcx
long long v3; // rsi
long long v4; // rax
v2 = (long long)(a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 0LL;
v3 = 0LL;
LABEL_3:
if ( ++v3 >= v2 )
return 0LL;
v4 = v3;
while ( a2 <= fabs(*(float *)(*a1 + 4 * v3 - 4) - *(fl... | 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 0x001016bf
XOR ESI,ESI
MOVSS XMM3,dword ptr [0x00102220]
LAB_00101684:
ADD RSI,0x1
CMP RSI,RCX
JNC 0x001016bf
MOVSS XMM2,dword ptr [RDX + RSI*0x4 + -0x4]
MOV RAX,RSI
JMP 0x001016a9
LAB_001016a0:
ADD R... | /* func0(std::vector<float, std::allocator<float> >, float) */
int8 func0(vector param_1,float param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
int4 in_register_0000003c;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_register_00... |
4 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(string paren_string){
vector<string> all_parens;
string current_paren;
int level=0;
char chr;
int i;
for (i=0;i<paren_string.length();i++)
{
chr=paren_string[i];
if (chr=='(')
{
level+=1;
current_paren+=chr;
}
if (c... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("(()()) ((())) () ((())()())"),{"(()())", "((()))", "()", "(... | 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 34f6 <_... | _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 _ZNSt6vectorINSt7__cxx1112... | long long func0(long long a1, long long a2)
{
char v3; // [rsp+17h] [rbp-49h]
int v4; // [rsp+18h] [rbp-48h]
int i; // [rsp+1Ch] [rbp-44h]
_BYTE v6[40]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v7; // [rsp+48h] [rbp-18h]
v7 = __readfsqword(0x28u);
std::vector<std::string>::vector(a1);
std::stri... | 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 0x00102f86
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x001023e0
MOV dword ptr [R... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,ulong param_2)
{
char cVar1;
char *pcVar2;
ulong uVar3;
long in_FS_OFFSET;
int local_50;
int local_4c;
string local_48 [40];
long local_20;
local_20 = *(long *... |
5 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(string paren_string){
vector<string> all_parens;
string current_paren;
int level=0;
char chr;
int i;
for (i=0;i<paren_string.length();i++)
{
chr=paren_string[i];
if (chr=='(')
{
level+=1;
current_paren+=chr;
}
if (c... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("(()()) ((())) () ((())()())"),{"(()())", "((()))", "()", "(... | 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 $0x48,%rsp
mov %rdi,%r13
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x1... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r13, rdi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rd... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
unsigned long long v3; // rbx
int v4; // r12d
unsigned long long v5; // r14
unsigned long long v6; // r15
unsigned long long v7; // rax
char v8; // al
unsigned long long v9; // r14
unsigned long long v10; // r15
unsigned long long v11; // rax
_QWORD *v12; // ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R13,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2)
{
char *pcVar1;
long *plVar2;
char *pcVar3;
char *pcVar4;
ulong uVar5;
int iVar6;
long in_FS_OFFSET;
char *local_68;
char *local_60;
char local_5... |
6 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(string paren_string){
vector<string> all_parens;
string current_paren;
int level=0;
char chr;
int i;
for (i=0;i<paren_string.length();i++)
{
chr=paren_string[i];
if (chr=='(')
{
level+=1;
current_paren+=chr;
}
if (c... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("(()()) ((())) () ((())()())"),{"(()())", "((()))", "()", "(... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r14
cmpq $0x0,0x8(%rsi)
movq $0x0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
lea r14, [rsp+78h+var_58]
cmp qword ptr [rsi+8], 0... | long long func0(long long a1, _QWORD *a2)
{
bool v3; // zf
unsigned long long v4; // rbx
_QWORD *v5; // rdi
int v6; // r12d
char v7; // al
unsigned long long v8; // r15
unsigned long long v9; // rax
unsigned long long v11; // r15
unsigned long long v12; // rax
_QWORD *v13; // rdi
unsigned long lo... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA R14,[RSP + 0x20]
CMP qword ptr [RSI + 0x8],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RSP + 0x10],R... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2)
{
char *pcVar1;
long *plVar2;
long lVar3;
char *pcVar4;
char *pcVar5;
ulong uVar6;
char *pcVar7;
int iVar8;
long in_FS_OFFSET;
char **local_70;
... |
7 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(string paren_string){
vector<string> all_parens;
string current_paren;
int level=0;
char chr;
int i;
for (i=0;i<paren_string.length();i++)
{
chr=paren_string[i];
if (chr=='(')
{
level+=1;
current_paren+=chr;
}
if (c... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("(()()) ((())) () ((())()())"),{"(()())", "((()))", "()", "(... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov 0x8(%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x30(%rs... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 68h
mov rdx, [rsi+8]
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
lea r14, [rsp+98h+var_58]
mov ... | long long func0(long long a1, _QWORD *a2)
{
unsigned long long v3; // rdx
unsigned long long v4; // rbx
_QWORD *v5; // rdi
int v6; // r12d
char v7; // al
unsigned long long v8; // r15
unsigned long long v9; // rax
unsigned long long v11; // r15
unsigned long long v12; // rax
long long *v13; // r15
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RDX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA R14,[RSP + 0x40]
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RSP + 0x30],R14
MOV qword ptr [RSP + 0x38],... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2)
{
char *pcVar1;
ulong *puVar2;
int *__src;
char *pcVar3;
char *pcVar4;
ulong *__dest;
ulong uVar5;
ulong uVar6;
int *puVar7;
int iVar8;
long in... |
8 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float number){
return number-int(number);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3.5) == 0.5);
assert (abs(func0(1.33) - 0.33) < 1e-4);
assert (abs(func0(123.456) - 0.456) < 1e-4);
} | O0 | cpp | func0(float):
endbr64
push %rbp
mov %rsp,%rbp
movss %xmm0,-0x4(%rbp)
movss -0x4(%rbp),%xmm0
cvttss2si %xmm0,%eax
cvtsi2ss %eax,%xmm1
movss -0x4(%rbp),%xmm0
subss %xmm1,%xmm0
pop %rbp
retq
| _Z5func0f:
endbr64
push rbp
mov rbp, rsp
movss [rbp+var_4], xmm0
movss xmm0, [rbp+var_4]
cvttss2si eax, xmm0
pxor xmm1, xmm1
cvtsi2ss xmm1, eax
movss xmm0, [rbp+var_4]
subss xmm0, xmm1
pop rbp
retn | float func0(float a1)
{
return a1 - (float)(int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS XMM0,dword ptr [RBP + -0x4]
CVTTSS2SI EAX,XMM0
PXOR XMM1,XMM1
CVTSI2SS XMM1,EAX
MOVSS XMM0,dword ptr [RBP + -0x4]
SUBSS XMM0,XMM1
POP RBP
RET | /* func0(float) */
float func0(float param_1)
{
return param_1 - (float)(int)param_1;
} |
9 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float number){
return number-int(number);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3.5) == 0.5);
assert (abs(func0(1.33) - 0.33) < 1e-4);
assert (abs(func0(123.456) - 0.456) < 1e-4);
} | O1 | cpp | func0(float):
endbr64
cvttss2si %xmm0,%eax
pxor %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
subss %xmm1,%xmm0
retq
| _Z5func0f:
endbr64
cvttss2si eax, xmm0
pxor xmm1, xmm1
cvtsi2ss xmm1, eax
subss xmm0, xmm1
retn | float func0(float a1)
{
return a1 - (float)(int)a1;
} | func0:
ENDBR64
CVTTSS2SI EAX,XMM0
PXOR XMM1,XMM1
CVTSI2SS XMM1,EAX
SUBSS XMM0,XMM1
RET | /* func0(float) */
float func0(float param_1)
{
return param_1 - (float)(int)param_1;
} |
10 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float number){
return number-int(number);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3.5) == 0.5);
assert (abs(func0(1.33) - 0.33) < 1e-4);
assert (abs(func0(123.456) - 0.456) < 1e-4);
} | O2 | cpp | func0(float):
endbr64
cvttss2si %xmm0,%eax
pxor %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
subss %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0f:
endbr64
cvttss2si eax, xmm0
pxor xmm1, xmm1
cvtsi2ss xmm1, eax
subss xmm0, xmm1
retn | float func0(float a1)
{
return a1 - (float)(int)a1;
} | func0:
ENDBR64
CVTTSS2SI EAX,XMM0
PXOR XMM1,XMM1
CVTSI2SS XMM1,EAX
SUBSS XMM0,XMM1
RET | /* func0(float) */
float func0(float param_1)
{
return param_1 - (float)(int)param_1;
} |
11 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(float number){
return number-int(number);
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3.5) == 0.5);
assert (abs(func0(1.33) - 0.33) < 1e-4);
assert (abs(func0(123.456) - 0.456) < 1e-4);
} | O3 | cpp | func0(float):
endbr64
cvttss2si %xmm0,%eax
pxor %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
subss %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0f:
endbr64
cvttss2si eax, xmm0
pxor xmm1, xmm1
cvtsi2ss xmm1, eax
subss xmm0, xmm1
retn | float func0(float a1)
{
return a1 - (float)(int)a1;
} | func0:
ENDBR64
CVTTSS2SI EAX,XMM0
PXOR XMM1,XMM1
CVTSI2SS XMM1,EAX
SUBSS XMM0,XMM1
RET | /* func0(float) */
float func0(float param_1)
{
return param_1 - (float)(int)param_1;
} |
12 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| bool func0(vector<int> operations){
int num=0;
for (int i=0;i<operations.size();i++)
{
num+=operations[i];
if (num<0) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == false);
assert (func0({1, 2, -3, 1, 2, -3}) == false);
assert (func0({1, 2, -4, 5, 6}) == true);
assert (func0({1, -1, 2, -2, 5, -5, 4, -4}) == false);
assert (func0({1, -1, 2, -2, 5, -5, 4, -5}) == true);
assert (func0({1, -2, 2... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1a46 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %r... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_1295
loc_126A:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vec... | long long 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::vector<int>::size(a1); ++i )
{
v2 += *(_DWORD *)std::vector<int>::operator[](a1, i);
if ( v2 < 0 )
return 1LL;
}
return 0LL;
} | 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 0x00101295
LAB_0010126a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101b44
MOV EAX,dword ptr ... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int *piVar1;
ulong uVar2;
int4 in_register_0000003c;
int local_20;
int local_1c;
local_20 = 0;
local_1c = 0;
while( true ) {
uVar2 = std::vector<int,std::allocator<int>>::size
((vector<int,std... |
13 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| bool func0(vector<int> operations){
int num=0;
for (int i=0;i<operations.size();i++)
{
num+=operations[i];
if (num<0) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == false);
assert (func0({1, 2, -3, 1, 2, -3}) == false);
assert (func0({1, 2, -4, 5, 6}) == true);
assert (func0({1, -1, 2, -2, 5, -5, 4, -4}) == false);
assert (func0({1, -1, 2, -2, 5, -5, 4, -5}) == true);
assert (func0({1, -2, 2... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%rax
sub %rsi,%rax
sar $0x2,%rax
mov %rax,%rdi
je 1247 <_Z5func0St6vectorIiSaIiEE+0x3e>
mov (%rsi),%ecx
test %ecx,%ecx
js 124d <_Z5func0St6vectorIiSaIiEE+0x44>
mov $0x1,%eax
cmp %rdi,%rax
je 1241 <... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rsi, [rdi]
mov rdi, rax
sub rdi, rsi
sar rdi, 2
cmp rax, rsi
jz short loc_124A
mov ecx, [rsi]
test ecx, ecx
js short loc_1250
mov eax, 1
loc_122E:
cmp rax, rdi
jnb short loc_1244
add ecx, [rsi+rax*4]
add ... | long long func0(int **a1)
{
int *v1; // rax
int *v2; // rsi
unsigned long long v3; // rdi
int v4; // ecx
unsigned long long v5; // rax
v1 = a1[1];
v2 = *a1;
v3 = v1 - *a1;
if ( v1 == v2 )
return 0LL;
v4 = *v2;
if ( *v2 < 0 )
return 1LL;
v5 = 1LL;
while ( v5 < v3 )
{
v4 += v2[v5... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
MOV RDI,RAX
SUB RDI,RSI
SAR RDI,0x2
CMP RAX,RSI
JZ 0x0010124a
MOV ECX,dword ptr [RSI]
TEST ECX,ECX
JS 0x00101250
MOV EAX,0x1
LAB_0010122e:
CMP RAX,RDI
JNC 0x00101244
ADD ECX,dword ptr [RSI + RAX*0x4]
ADD RAX,0x1
TEST ECX,ECX
JNS 0x0010122e
MOV EAX,0x1... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int *piVar1;
int *piVar2;
ulong uVar3;
int iVar4;
int4 in_register_0000003c;
piVar1 = (int *)((int8 *)CONCAT44(in_register_0000003c,param_1))[1];
piVar2 = *(int **)CONCAT44(in_register_0000003c,param_1);
if (piVar1 == ... |
14 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| bool func0(vector<int> operations){
int num=0;
for (int i=0;i<operations.size();i++)
{
num+=operations[i];
if (num<0) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == false);
assert (func0({1, 2, -3, 1, 2, -3}) == false);
assert (func0({1, 2, -4, 5, 6}) == true);
assert (func0({1, -1, 2, -2, 5, -5, 4, -4}) == false);
assert (func0({1, -1, 2, -2, 5, -5, 4, -5}) == true);
assert (func0({1, -2, 2... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%rcx
sub %rsi,%rcx
sar $0x2,%rcx
je 1728 <_Z5func0St6vectorIiSaIiEE+0x38>
mov (%rsi),%edx
test %edx,%edx
js 1730 <_Z5func0St6vectorIiSaIiEE+0x40>
mov $0x1,%eax
jmp 1723 <_Z5func0St6vectorIiSaIiEE+0x33>
no... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rcx, [rdi]
mov rsi, rax
sub rsi, rcx
sar rsi, 2
cmp rax, rcx
jz short loc_1560
mov edx, [rcx]
test edx, edx
js short loc_1568
mov eax, 1
jmp short loc_155B
loc_1550:
add edx, [rcx+rax*4]
add rax, 1
test e... | long long func0(int **a1)
{
int *v1; // rcx
int v2; // edx
unsigned long long v3; // rax
v1 = *a1;
if ( a1[1] == *a1 )
return 0LL;
v2 = *v1;
if ( *v1 >= 0 )
{
v3 = 1LL;
while ( v3 < a1[1] - *a1 )
{
v2 += v1[v3++];
if ( v2 < 0 )
return 1LL;
}
return 0LL;
}
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RSI,RAX
SUB RSI,RCX
SAR RSI,0x2
CMP RAX,RCX
JZ 0x00101560
MOV EDX,dword ptr [RCX]
TEST EDX,EDX
JS 0x00101568
MOV EAX,0x1
JMP 0x0010155b
LAB_00101550:
ADD EDX,dword ptr [RCX + RAX*0x4]
ADD RAX,0x1
TEST EDX,EDX
JS 0x00101568
LAB_0010155b:
CMP RAX,RS... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int *piVar1;
int *piVar2;
ulong uVar3;
int iVar4;
int4 in_register_0000003c;
piVar1 = *(int **)(CONCAT44(in_register_0000003c,param_1) + 8);
piVar2 = *(int **)CONCAT44(in_register_0000003c,param_1);
if (piVar1 == piVar... |
15 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| bool func0(vector<int> operations){
int num=0;
for (int i=0;i<operations.size();i++)
{
num+=operations[i];
if (num<0) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == false);
assert (func0({1, 2, -3, 1, 2, -3}) == false);
assert (func0({1, 2, -4, 5, 6}) == true);
assert (func0({1, -1, 2, -2, 5, -5, 4, -4}) == false);
assert (func0({1, -1, 2, -2, 5, -5, 4, -5}) == true);
assert (func0({1, -2, 2... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%rcx
sub %rsi,%rcx
sar $0x2,%rcx
je 16a8 <_Z5func0St6vectorIiSaIiEE+0x38>
mov (%rsi),%edx
test %edx,%edx
js 16b0 <_Z5func0St6vectorIiSaIiEE+0x40>
mov $0x1,%eax
jmp 16a3 <_Z5func0St6vectorIiSaIiEE+0x33>
no... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rax, [rdi+8]
mov rcx, [rdi]
mov rsi, rax
sub rsi, rcx
sar rsi, 2
cmp rax, rcx
jz short loc_16A0
mov edx, [rcx]
test edx, edx
js short loc_16A8
mov eax, 1
jmp short loc_169B
loc_1690:
add edx, [rcx+rax*4]
add rax, 1
test e... | long long func0(int **a1)
{
int *v1; // rcx
int v2; // edx
unsigned long long v3; // rax
v1 = *a1;
if ( a1[1] == *a1 )
return 0LL;
v2 = *v1;
if ( *v1 >= 0 )
{
v3 = 1LL;
while ( v3 < a1[1] - *a1 )
{
v2 += v1[v3++];
if ( v2 < 0 )
return 1LL;
}
return 0LL;
}
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RSI,RAX
SUB RSI,RCX
SAR RSI,0x2
CMP RAX,RCX
JZ 0x001016a0
MOV EDX,dword ptr [RCX]
TEST EDX,EDX
JS 0x001016a8
MOV EAX,0x1
JMP 0x0010169b
LAB_00101690:
ADD EDX,dword ptr [RCX + RAX*0x4]
ADD RAX,0x1
TEST EDX,EDX
JS 0x001016a8
LAB_0010169b:
CMP RAX,RS... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int *piVar1;
int *piVar2;
ulong uVar3;
int iVar4;
int4 in_register_0000003c;
piVar1 = *(int **)(CONCAT44(in_register_0000003c,param_1) + 8);
piVar2 = *(int **)CONCAT44(in_register_0000003c,param_1);
if (piVar1 == piVar... |
16 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(vector<float> numbers){
float sum=0;
float avg,msum,mavg;
int i=0;
for (i=0;i<numbers.size();i++)
sum+=numbers[i];
avg=sum/numbers.size();
msum=0;
for (i=0;i<numbers.size();i++)
msum+=abs(numbers[i]-avg);
return msum/numbers.size();
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({1.0, 2.0, 3.0}) - 2.0/3.0) < 1e-4);
assert (abs(func0({1.0, 2.0, 3.0, 4.0}) - 1.0) < 1e-4);
assert (abs(func0({1.0, 2.0, 3.0, 4.0, 5.0}) - 6.0/5.0) < 1e-4);
} | O0 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
pxor %xmm0,%xmm0
movss %xmm0,-0x20(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x18(%rbp)
mov -0x18(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
call... | _Z5func0St6vectorIfSaIfEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
pxor xmm0, xmm0
movss [rbp+var_20], xmm0
mov [rbp+var_18], 0
mov [rbp+var_18], 0
jmp short loc_129E
loc_1273:
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov ... | __int128 __usercall func0@<xmm0>(long long a1@<rdi>)
{
long long v1; // rax
float v2; // xmm0_4
__m128i v3; // xmm0
long long v4; // rax
float v5; // xmm0_4
__int128 v6; // xmm1
float v8; // [rsp+10h] [rbp-20h]
float v9; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+18h] [rbp-1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
PXOR XMM0,XMM0
MOVSS dword ptr [RBP + -0x20],XMM0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0010129e
LAB_00101273:
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,... | /* func0(std::vector<float, std::allocator<float> >) */
void func0(vector param_1)
{
ulong uVar1;
float *pfVar2;
ulong uVar3;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
float local_28;
int local_20;
this = (vector<float,std::allocator<float>> *)CONCAT44(in_register_000000... |
17 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(vector<float> numbers){
float sum=0;
float avg,msum,mavg;
int i=0;
for (i=0;i<numbers.size();i++)
sum+=numbers[i];
avg=sum/numbers.size();
msum=0;
for (i=0;i<numbers.size();i++)
msum+=abs(numbers[i]-avg);
return msum/numbers.size();
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({1.0, 2.0, 3.0}) - 2.0/3.0) < 1e-4);
assert (abs(func0({1.0, 2.0, 3.0, 4.0}) - 1.0) < 1e-4);
assert (abs(func0({1.0, 2.0, 3.0, 4.0, 5.0}) - 6.0/5.0) < 1e-4);
} | O1 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rcx
sub %rax,%rcx
mov %rcx,%rsi
sar $0x2,%rsi
je 1275 <_Z5func0St6vectorIfSaIfEE+0x6c>
mov %rax,%rdx
add %rax,%rcx
pxor %xmm0,%xmm0
addss (%rax),%xmm0
add $0x4,%rax
cmp %rcx,%rax
jne 122a <_Z5f... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rax, [rdi+8]
mov rdx, [rdi]
mov rsi, rax
sub rsi, rdx
mov rcx, rsi
sar rcx, 2
cmp rax, rdx
jz short loc_1286
mov eax, 0
pxor xmm0, xmm0
loc_122F:
addss xmm0, dword ptr [rdx+rax*4]
add rax, 1
cmp rax, rcx
jb short loc_122F
loc_... | __int128 __usercall func0@<xmm0>(float **a1@<rdi>)
{
long long v1; // rcx
unsigned long long v2; // rax
float v3; // xmm0_4
float v4; // xmm4_4
float v5; // xmm0_4
float *v6; // rax
__int128 v7; // xmm2
long long v9; // rax
v1 = a1[1] - *a1;
if ( a1[1] == *a1 )
{
v3 = 0.0;
}
else
{
... | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RSI,RAX
SUB RSI,RDX
MOV RCX,RSI
SAR RCX,0x2
CMP RAX,RDX
JZ 0x00101286
MOV EAX,0x0
PXOR XMM0,XMM0
LAB_0010122f:
ADDSS XMM0,dword ptr [RDX + RAX*0x4]
ADD RAX,0x1
CMP RAX,RCX
JC 0x0010122f
LAB_0010123d:
TEST RCX,RCX
JS 0x0010128c
PXOR XMM4,XMM4
CVTSI... | /* func0(std::vector<float, std::allocator<float> >) */
void func0(vector param_1)
{
long lVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
long lVar5;
int4 in_register_0000003c;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar3 = *(long *)CONCAT44(in_register_0000003c,param_1);
lVar5... |
18 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(vector<float> numbers){
float sum=0;
float avg,msum,mavg;
int i=0;
for (i=0;i<numbers.size();i++)
sum+=numbers[i];
avg=sum/numbers.size();
msum=0;
for (i=0;i<numbers.size();i++)
msum+=abs(numbers[i]-avg);
return msum/numbers.size();
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({1.0, 2.0, 3.0}) - 2.0/3.0) < 1e-4);
assert (abs(func0({1.0, 2.0, 3.0, 4.0}) - 1.0) < 1e-4);
assert (abs(func0({1.0, 2.0, 3.0, 4.0, 5.0}) - 6.0/5.0) < 1e-4);
} | O2 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rcx
sub %rax,%rcx
mov %rcx,%rsi
sar $0x2,%rsi
je 1480 <_Z5func0St6vectorIfSaIfEE+0x70>
add %rax,%rcx
mov %rax,%rdx
pxor %xmm0,%xmm0
nopl 0x0(%rax)
addss (%rdx),%xmm0
add $0x4,%rdx
cmp %rdx,%rcx
... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rdx, [rdi+8]
mov rax, [rdi]
pxor xmm0, xmm0
mov rcx, rdx
sub rcx, rax
mov rsi, rcx
sar rsi, 2
cmp rdx, rax
jz short loc_1434
lea rdx, [rsi-1]
addss xmm0, dword ptr [rax]
mov rdi, rdx
mov edx, 1
and edi, 1
cmp rdx, rsi
jnb ... | __int128 __usercall func0@<xmm0>(long long a1@<rdi>)
{
float *v1; // rax
float v2; // xmm0_4
unsigned long long v3; // rsi
unsigned long long v4; // rdx
float v5; // xmm4_4
float v6; // xmm0_4
__int128 v7; // xmm2
float v8; // xmm1_4
__int128 v10; // xmm2
v1 = *(float **)a1;
v2 = 0.0;
v3 = (lon... | func0:
ENDBR64
MOV RDX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RDI]
PXOR XMM0,XMM0
MOV RCX,RDX
SUB RCX,RAX
MOV RSI,RCX
SAR RSI,0x2
CMP RDX,RAX
JZ 0x00101434
LEA RDX,[RSI + -0x1]
ADDSS XMM0,dword ptr [RAX]
MOV RDI,RDX
MOV EDX,0x1
AND EDI,0x1
CMP RDX,RSI
JNC 0x00101434
TEST RDI,RDI
JZ 0x00101420
MOV EDX,0x2
ADDSS XMM0,d... | /* func0(std::vector<float, std::allocator<float> >) */
void func0(vector param_1)
{
long lVar1;
long lVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
int4 in_register_0000003c;
lVar1 = ((long *)CONCAT44(in_register_0000003c,param_1))[1];
lVar2 = *(long *)CONCAT44(in_register_0000003c,param_1);
lVar3... |
19 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| float func0(vector<float> numbers){
float sum=0;
float avg,msum,mavg;
int i=0;
for (i=0;i<numbers.size();i++)
sum+=numbers[i];
avg=sum/numbers.size();
msum=0;
for (i=0;i<numbers.size();i++)
msum+=abs(numbers[i]-avg);
return msum/numbers.size();
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (abs(func0({1.0, 2.0, 3.0}) - 2.0/3.0) < 1e-4);
assert (abs(func0({1.0, 2.0, 3.0, 4.0}) - 1.0) < 1e-4);
assert (abs(func0({1.0, 2.0, 3.0, 4.0, 5.0}) - 6.0/5.0) < 1e-4);
} | O3 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
je 1578 <_Z5func0St6vectorIfSaIfEE+0x198>
lea -0x1(%rdx),%rdi
cmp $0x2,%rdi
jbe 158d <_Z5func0St6vectorIfSaIfEE+0x1ad>
mov %rdx,%rsi
pxor %xmm0,%xmm0
mov %rcx,%rax
s... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov rsi, [rdi+8]
mov rdx, [rdi]
mov rax, rsi
sub rax, rdx
mov rcx, rax
sar rcx, 2
cmp rsi, rdx
jz loc_1570
test rax, rax
mov edi, 1
cmovnz rdi, rcx
cmp rax, 0Ch
jbe loc_1592
mov rsi, rdi
pxor xmm1, xmm1
mov rax, rdx
shr r... | float func0(float **a1)
{
float *v1; // rdx
long long v2; // rax
unsigned long long v3; // rcx
unsigned long long v4; // rdi
__m128 v5; // xmm1
float *v6; // rax
float v7; // xmm1_4
unsigned long long v8; // rdi
int v9; // eax
unsigned long long v10; // rsi
float v11; // xmm4_4
__m128 v12; // x... | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
MOV RAX,RSI
SUB RAX,RDX
MOV RCX,RAX
SAR RCX,0x2
CMP RSI,RDX
JZ 0x00101570
TEST RAX,RAX
MOV EDI,0x1
CMOVNZ RDI,RCX
CMP RAX,0xc
JBE 0x00101592
MOV RSI,RDI
PXOR XMM1,XMM1
MOV RAX,RDX
SHR RSI,0x2
SHL RSI,0x4
ADD RSI,RDX
NOP dword ptr [RAX]
LAB_00101420:
A... | /* func0(std::vector<float, std::allocator<float> >) */
int8 func0(vector param_1)
{
float *pfVar1;
float fVar2;
float *pfVar3;
float *pfVar4;
uint uVar5;
ulong uVar6;
float *pfVar7;
float *pfVar8;
ulong uVar9;
ulong uVar10;
int4 in_register_0000003c;
float fVar11;
int auVar12 [16];
int au... |
20 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers, int delimeter){
vector<int> out={};
if (numbers.size()>0) out.push_back(numbers[0]);
for (int i=1;i<numbers.size();i++)
{
out.push_back(delimeter);
out.push_back(numbers[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({}, 7), {}));
assert (issame(func0({}, 4), {}));
assert ... | O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %edx,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x28(%rbp),%rax
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
mo... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_34], edx
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... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rax
long long v4; // rax
unsigned long long v5; // rbx
int v7; // [rsp+Ch] [rbp-34h] BYREF
long long v8; // [rsp+10h] [rbp-30h]
long long v9; // [rsp+18h] [rbp-28h]
int i; // [rsp+2Ch] [rbp-14h]
v9 = a1;
v8 = a2;
v7 = a3;
*(_... | 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 dword ptr [RBP + -0x34],EDX
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 0x00101... | /* func0(std::vector<int, std::allocator<int> >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
long lVar1;
int *piVar2;
ulong uVar3;
ulong uVar4;
int4 in_register_00000034;
int4 in_register_0000003c;
int local_3c;
vector<int,std::allocator<int>> *local_38;
vector<int,... |
21 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers, int delimeter){
vector<int> out={};
if (numbers.size()>0) out.push_back(numbers[0]);
for (int i=1;i<numbers.size();i++)
{
out.push_back(delimeter);
out.push_back(numbers[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({}, 7), {}));
assert (issame(func0({}, 4), {}));
assert ... | O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %rsi,%r12
mov %edx,0xc(%rsp)
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp 0x8(%rsi),%rdx
je 12c2 <_Z5func0St6vectorIiS... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov r12, rsi
mov [rsp+38h+var_2C], edx
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp [rsi+8], rdx
jz short loc_12BD
mov es... | long long func0(long long a1, _QWORD *a2, int a3)
{
unsigned long long v4; // rbp
_DWORD *v5; // rsi
_DWORD *v6; // rsi
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
if ( a2[1] != *a2 )
std::vector<int>::_M_realloc_insert<int const&>(a1, 0LL);
if ( a2[1] - *a2 > 4uLL )
{
v4 = 1LL;
do
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R12,RSI
MOV dword ptr [RSP + 0xc],EDX
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 0x001012bd
MOV ESI,0x0
LAB_001012b8:
CALL 0x001019f8
LAB_001012bd:
MO... | /* func0(std::vector<int, std::allocator<int> >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
int *piVar1;
int *piVar2;
int in_EDX;
ulong uVar3;
int4 in_register_00000034;
long *plVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int local_2c [3... |
22 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers, int delimeter){
vector<int> out={};
if (numbers.size()>0) out.push_back(numbers[0]);
for (int i=1;i<numbers.size();i++)
{
out.push_back(delimeter);
out.push_back(numbers[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({}, 7), {}));
assert (issame(func0({}, 4), {}));
assert ... | O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movq $0x0,(%rdi)
mov %edx,0xc(%rsp)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp 0x8(%rsi),%rdx
je 18e8 <_Z5func0St6vectorIiSaIiEEi+0xf8>
mov ... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
movups xmmword ptr [rdi], xmm0
mov [rsp+38h+var_2C], edx
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rdx
jz loc_1828
mov r12, rsi
xor esi, esi... | long long func0(long long a1, long long *a2, int a3)
{
long long v3; // rdx
unsigned long long i; // rbp
long long v6; // rsi
long long v7; // rdx
_DWORD *v8; // rcx
long long v9; // rsi
long long v10; // rsi
long long v11; // rax
*(_OWORD *)a1 = 0LL;
v3 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if (... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOVUPS xmmword ptr [RDI],XMM0
MOV dword ptr [RSP + 0xc],EDX
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x00101828
MOV R12,RSI
XOR ESI,ESI
LAB_00101776:
CALL 0x00101960
MOV RAX,qword pt... | /* func0(std::vector<int, std::allocator<int> >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
int *piVar1;
int *piVar2;
int in_EDX;
long lVar3;
ulong uVar4;
int4 in_register_00000034;
long *plVar5;
int *piVar6;
int4 in_register_0000003c;
vector<int,std::allocator<i... |
23 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers, int delimeter){
vector<int> out={};
if (numbers.size()>0) out.push_back(numbers[0]);
for (int i=1;i<numbers.size();i++)
{
out.push_back(delimeter);
out.push_back(numbers[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({}, 7), {}));
assert (issame(func0({}, 4), {}));
assert ... | O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movq $0x0,0x10(%rdi)
mov %edx,0xc(%rsp)
movups %xmm0,(%rdi)
mov (%rsi),%rdx
cmp 0x8(%rsi),%rdx
je 18a0 <_Z5func0St6vectorIiSaIiEEi+0xf0>
mov ... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
movups xmmword ptr [rdi], xmm0
mov [rsp+38h+var_2C], edx
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rdx
jz loc_18A8
mov r12, rsi
xor esi, esi... | long long func0(long long a1, long long *a2, int a3)
{
long long v3; // rdx
long long v5; // rdx
unsigned long long i; // rbp
long long v7; // rsi
_DWORD *v8; // rcx
long long v9; // rsi
long long v10; // rsi
long long v11; // rax
*(_OWORD *)a1 = 0LL;
v3 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if (... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOVUPS xmmword ptr [RDI],XMM0
MOV dword ptr [RSP + 0xc],EDX
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001018a8
MOV R12,RSI
XOR ESI,ESI
LAB_001017f6:
CALL 0x001019e0
MOV RDX,qword pt... | /* func0(std::vector<int, std::allocator<int> >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
int *piVar1;
int *piVar2;
int in_EDX;
long lVar3;
ulong uVar4;
int4 in_register_00000034;
long *plVar5;
int *piVar6;
int4 in_register_0000003c;
vector<int,std::allocator<i... |
24 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(string paren_string){
vector<int> all_levels;
string current_paren;
int level=0,max_level=0;
char chr;
int i;
for (i=0;i<paren_string.length();i++)
{
chr=paren_string[i];
if (chr=='(')
{
level+=1;
if (level>max_level) max_level=level;... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("(()()) ((())) () ((())()())"),{2, 3, 1, 3}));
assert (issa... | 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 2cbe <_... | _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 _ZNSt6vectorIiSaIiEEC2Ev; ... | long long func0(long long a1, long long a2)
{
unsigned long long v2; // rbx
char v4; // [rsp+13h] [rbp-4Dh]
int v5; // [rsp+14h] [rbp-4Ch] BYREF
int v6; // [rsp+18h] [rbp-48h]
int i; // [rsp+1Ch] [rbp-44h]
_BYTE v8[40]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v9; // [rsp+48h] [rbp-18h]
v9 = __... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
CALL 0x00102c6e
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00102310
MOV dword ptr [R... | /* func0(std::string) */
vector<int,std::allocator<int>> * func0(vector<int,std::allocator<int>> *param_1,ulong param_2)
{
char cVar1;
char *pcVar2;
ulong uVar3;
ulong uVar4;
long in_FS_OFFSET;
int local_54;
int local_50;
int local_4c;
string local_48 [40];
long local_20;
local_20 = *(long *)... |
25 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(string paren_string){
vector<int> all_levels;
string current_paren;
int level=0,max_level=0;
char chr;
int i;
for (i=0;i<paren_string.length();i++)
{
chr=paren_string[i];
if (chr=='(')
{
level+=1;
if (level>max_level) max_level=level;... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("(()()) ((())) () ((())()())"),{2, 3, 1, 3}));
assert (issa... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%r14
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x1... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov r14, rdi
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rd... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
unsigned long long v3; // rbx
int v4; // r12d
unsigned long long v5; // r13
unsigned long long v6; // r15
unsigned long long v7; // rax
char v8; // al
unsigned long long v9; // r13
unsigned long long v10; // r15
unsigned long long v11; // rax
int *v12; // rsi... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP... | /* func0(std::string) */
vector<int,std::allocator<int>> * func0(vector<int,std::allocator<int>> *param_1,long *param_2)
{
char *pcVar1;
int *piVar2;
char *pcVar3;
char *pcVar4;
ulong uVar5;
int iVar6;
long in_FS_OFFSET;
int local_6c;
int *local_68;
char *local_60;
int local_58;
int7 uStack_57... |
26 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(string paren_string){
vector<int> all_levels;
string current_paren;
int level=0,max_level=0;
char chr;
int i;
for (i=0;i<paren_string.length();i++)
{
chr=paren_string[i];
if (chr=='(')
{
level+=1;
if (level>max_level) max_level=level;... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("(()()) ((())) () ((())()())"),{2, 3, 1, 3}));
assert (issa... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
cmpq $0x0,0x8(%rsi)
movq $0x0,0x8... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_90], rdi
lea r14, [rsp+98h+var_58]
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
lea rax, [r... | long long func0(long long a1, _QWORD *a2)
{
bool v2; // zf
unsigned long long v4; // rbx
_QWORD *v5; // rdi
int v6; // r12d
char v7; // al
unsigned long long v8; // r13
unsigned long long v9; // r15
unsigned long long v10; // rax
unsigned long long v12; // r13
unsigned long long v13; // r15
unsig... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x8],RDI
LEA R14,[RSP + 0x40]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x30]
CMP qword ptr [RSI + 0x8],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI +... | /* func0(std::string) */
vector<int,std::allocator<int>> * func0(vector<int,std::allocator<int>> *param_1,long *param_2)
{
char *pcVar1;
int *piVar2;
long lVar3;
char *pcVar4;
char *pcVar5;
ulong uVar6;
int *puVar7;
int iVar8;
long in_FS_OFFSET;
int local_6c;
int *local_68;
char *local_60;
i... |
27 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(string paren_string){
vector<int> all_levels;
string current_paren;
int level=0,max_level=0;
char chr;
int i;
for (i=0;i<paren_string.length();i++)
{
chr=paren_string[i];
if (chr=='(')
{
level+=1;
if (level>max_level) max_level=level;... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("(()()) ((())) () ((())()())"),{2, 3, 1, 3}));
assert (issa... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov 0x8(%rsi),%rdx
mov %rdi,0x8(%rsp)
lea 0x30(%rsp),%r14
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov rdx, [rsi+8]
mov [rsp+98h+var_90], rdi
lea r14, [rsp+98h+var_58]
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax... | long long func0(long long a1, _QWORD *a2)
{
unsigned long long v2; // rdx
unsigned long long v4; // rbx
_QWORD *v5; // rdi
int v6; // r12d
char v7; // al
unsigned long long v8; // r13
unsigned long long v9; // r15
unsigned long long v10; // rax
unsigned long long v12; // r13
unsigned long long v13;... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],RDI
LEA R14,[RSP + 0x40]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x30]
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RSP ... | /* func0(std::string) */
vector<int,std::allocator<int>> * func0(vector<int,std::allocator<int>> *param_1,long *param_2)
{
char *pcVar1;
int *piVar2;
char *pcVar3;
char *pcVar4;
ulong uVar5;
ulong uVar6;
int *puVar7;
int iVar8;
long in_FS_OFFSET;
int local_6c;
int *local_68;
char *local_60;
... |
28 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(vector<string> strings, string substring){
vector<string> out;
for (int i=0;i<strings.size();i++)
{
if (strings[i].find(substring)!=strings[i].npos)
out.push_back(strings[i]);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({}, "a"),{}));
assert (issame(func0({}, "john"),{}));
... | O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
pu... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rbx
long long v5; // rax
int i; // [rsp+2Ch] [rbp-14h]
std::vector<std::string>::vector(a1);
for ( i = 0; i < (unsigned long long)std::vector<std::string>::size(a2); ++i )
{
v3 = std::vector<std::string... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001034ea
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00102571
LAB_001024f7:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EA... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,
vector<std::string,std::allocator<std::string>> *param_2,ulong param_3)
{
string *psVar1;
long lVar2;
ulong uVa... |
29 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(vector<string> strings, string substring){
vector<string> out;
for (int i=0;i<strings.size();i++)
{
if (strings[i].find(substring)!=strings[i].npos)
out.push_back(strings[i]);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({}, "a"),{}));
assert (issame(func0({}, "john"),{}));
... | O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rdi, [rsi]
cmp [rsi+8], rdi
jz loc_1498
mov ... | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v4; // rdi
unsigned long long v6; // rbx
_QWORD *v7; // rdx
_QWORD *v8; // rdi
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v4 = *a2;
if ( a2[1] != *a2 )
{
v6 = 0LL;
do
{
if ( std::string::find(32 * v6 + v4, *a3, 0LL, a3[1]... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RDI,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDI
JZ 0x00101498
MOV RBP,RSI
MOV R13,RDX
MOV EBX,0x0
JMP 0x00101424
LAB_00101406:
ADD qword ptr [R12 + 0x8],0x20... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2,ulong *param_3)
{
long *plVar1;
long lVar2;
string *psVar3;
ulong uVar4;
*(int8 *)param_1 = 0;
... |
30 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(vector<string> strings, string substring){
vector<string> out;
for (int i=0;i<strings.size();i++)
{
if (strings[i].find(substring)!=strings[i].npos)
out.push_back(strings[i]);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({}, "a"),{}));
assert (issame(func0({}, "john"),{}));
... | O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rdi, [rsi]
cmp [rsi+8], rdi
jz loc_1D48
mov rbp, ... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rdi
unsigned long long v6; // rbx
long long v7; // rax
_QWORD *v8; // rdx
_QWORD *v9; // rdi
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v4 = *a2;
if ( a2[1] != *a2 )
{
v6 = 0LL;
do
{
v7 = std::strin... | func0:
ENDBR64
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDI
JZ 0x00101d48
MOV RBP,RSI
MOV R13,RDX
XOR EBX,EBX
JMP 0x00101cff
LAB_00101cc8:
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2,ulong *param_3)
{
string *psVar1;
long *plVar2;
long lVar3;
ulong uVar4;
long lVar5;
*(int8 *)... |
31 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(vector<string> strings, string substring){
vector<string> out;
for (int i=0;i<strings.size();i++)
{
if (strings[i].find(substring)!=strings[i].npos)
out.push_back(strings[i]);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({}, "a"),{}));
assert (issame(func0({}, "john"),{}));
... | O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES5_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
lea rax, [rsp+58h+var_48]
mov ... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rdi
long long v6; // rbx
_BYTE *v7; // rdi
size_t v8; // r15
_BYTE *v9; // rax
long long v10; // rax
long long v11; // rdx
long long *v12; // r12
long long v14; // rax
void *src; // [rsp+0h] [rbp-58h]
_QWORD v16[9]; // [r... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x10]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,qword ptr [RSI]
MOV qword ptr [RSP + 0x8],RAX
CMP ... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2,ulong *param_3)
{
string *psVar1;
ulong __n;
int *__src;
ulong *puVar2;
long lVar3;
ulong *__dest... |
32 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
int sum=0,product=1;
for (int i=0;i<numbers.size();i++)
{
sum+=numbers[i];
product*=numbers[i];
}
return {sum,product};
}
| #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({}) ,{0, 1}));
assert (issame(func0({1, 2, 3,4}), {10, 24}))... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movl $0x0,-0x3c(%rbp)
movl $0x1,-0x38(%rbp)
movl $0x0,-0x34(%rbp)
... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov [rbp+var_44], 0
mov [rbp+var_40], 1
mov [rbp+var_3C], 0
jmp short lo... | long long func0(long long a1, long long a2)
{
char v3; // [rsp+1Bh] [rbp-45h] BYREF
int v4; // [rsp+1Ch] [rbp-44h]
int v5; // [rsp+20h] [rbp-40h]
int i; // [rsp+24h] [rbp-3Ch]
char *v7; // [rsp+28h] [rbp-38h]
_DWORD v8[2]; // [rsp+30h] [rbp-30h] BYREF
unsigned long long v9; // [rsp+38h] [rbp-28h]
v9 =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x44],0x0
MOV dword ptr [RBP + -0x40],0x1
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x001012... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int *piVar1;
ulong uVar2;
ulong uVar3;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
long in_FS_OFFSET;
__new_allocator<int> local_4d;
int local_4c;
int local_48;
int local_44;
__new_allocator<... |
33 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
int sum=0,product=1;
for (int i=0;i<numbers.size();i++)
{
sum+=numbers[i];
product*=numbers[i];
}
return {sum,product};
}
| #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({}) ,{0, 1}));
assert (issame(func0({1, 2, 3,4}), {10, 24}))... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rsi),%rdx
mov 0x8(%rsi),%rsi
sub %rdx,%rsi
mov %rsi,%rax
shr $0x2,%rax
je 1289 <_Z5func0St6vectorIiSaIiEE+0x80>
mov %r... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rax, [rsi+8]
mov rdi, [rsi]
mov r8, rax
sub r8, rdi
sar r8, 2
cmp rdi, rax
jz short loc_12D3
mov eax, 0
mov esi, 1
mov ecx, 0
loc_1295:
mov edx, [rdi+rax*4]
add ecx, edx
imul ... | long long ** func0(long long **a1, long long *a2)
{
long long v3; // rdi
unsigned long long v4; // r8
unsigned long long v5; // rax
long long v6; // rsi
unsigned int v7; // ecx
int v8; // edx
long long v9; // rbx
long long *v10; // rax
v3 = *a2;
v4 = (a2[1] - *a2) >> 2;
if ( *a2 == a2[1] )
{
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RAX,qword ptr [RSI + 0x8]
MOV RDI,qword ptr [RSI]
MOV R8,RAX
SUB R8,RDI
SAR R8,0x2
CMP RDI,RAX
JZ 0x001012d3
MOV EAX,0x0
MOV ESI,0x1
MOV ECX,0x0
LAB_00101295:
MOV EDX,dword ptr [RDI + RAX*0x4]
ADD ECX,EDX
IMUL ESI,EDX
ADD RAX,0x1
CMP RAX,R8
JC 0x00101295
LAB_... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1)
{
int iVar1;
long lVar2;
ulong uVar3;
int8 *puVar4;
int iVar5;
int iVar6;
long *in_RSI;
int4 in_register_0000003c;
int8 *puVar7;
puVar7 = (int8 *)CONCAT44(in_register_0000003c,param_1);
lVar2 = *in_RSI;
if (lVa... |
34 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
int sum=0,product=1;
for (int i=0;i<numbers.size();i++)
{
sum+=numbers[i];
product*=numbers[i];
}
return {sum,product};
}
| #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({}) ,{0, 1}));
assert (issame(func0({1, 2, 3,4}), {10, 24}))... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rsi),%rax
mov 0x8(%rsi),%rsi
sub %rax,%rsi
mov %rsi,%rdi
shr $0x2,%rdi
je 19c8 <_Z5func0St6vectorIiSaIiEE+0xb... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
mov rax, [rsi+8]
mov rdi, [rsi]
mov r8, rax
sub r8, rdi
sar r8, 2
cmp rdi, rax
jz short loc_1828
xor eax, eax
mov esi, 1
xor ecx, ecx
nop dword ptr [rax+00h]
loc_17D0:
mov edx, [rd... | long long func0(long long a1, long long *a2)
{
long long v3; // rdi
unsigned long long v4; // r8
unsigned long long v5; // rax
long long v6; // rsi
unsigned int v7; // ecx
int v8; // edx
long long v9; // rbx
long long *v10; // rax
_QWORD *v11; // rdx
long long result; // rax
v3 = *a2;
v4 = (a2... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
MOV RAX,qword ptr [RSI + 0x8]
MOV RDI,qword ptr [RSI]
MOV R8,RAX
SUB R8,RDI
SAR R8,0x2
CMP RDI,RAX
JZ 0x00101828
XOR EAX,EAX
MOV ESI,0x1
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_001017d0:
MOV EDX,dword ptr [RDI + RAX*0x4]
ADD RAX,0x1
IMUL ESI,EDX
ADD ECX,EDX
CMP RAX,R... | /* func0(std::vector<int, std::allocator<int> >) */
int (*) [16] func0(vector param_1)
{
int iVar1;
long lVar2;
ulong uVar3;
int8 *puVar4;
int iVar5;
int iVar6;
long *in_RSI;
int4 in_register_0000003c;
int (*pauVar7) [16];
pauVar7 = (int (*) [16])CONCAT44(in_register_0000003c,param_1);
lVar2 ... |
35 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
int sum=0,product=1;
for (int i=0;i<numbers.size();i++)
{
sum+=numbers[i];
product*=numbers[i];
}
return {sum,product};
}
| #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({}) ,{0, 1}));
assert (issame(func0({1, 2, 3,4}), {10, 24}))... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov (%rsi),%rdi
mov 0x8(%rsi),%rsi
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
sub %rdi,%rsi
sar $0x2,%rsi
je 1a68 <_Z5func0St6vectorIiSaIiEE+0x178>
lea -0x1(%... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
mov rdx, [rsi+8]
mov rdi, [rsi]
mov rax, rdx
sub rax, rdi
mov r8, rax
sar r8, 2
cmp rdi, rdx
jz loc_19D0
test rax, rax
mov edx, 1
cmovnz rdx, r8
cmp rax, 58h ; 'X'
jbe loc_19D9
mov... | long long func0(long long a1, const __m128i **a2)
{
const __m128i *v3; // rdi
long long v4; // rax
unsigned long long v5; // r8
unsigned long long v6; // rdx
__m128i si128; // xmm0
__m128i v8; // xmm1
const __m128i *v9; // rax
__m128i v10; // xmm2
__m128i v11; // xmm2
__m128i v12; // xmm3
__m128i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
MOV RDX,qword ptr [RSI + 0x8]
MOV RDI,qword ptr [RSI]
MOV RAX,RDX
SUB RAX,RDI
MOV R8,RAX
SAR R8,0x2
CMP RDI,RDX
JZ 0x001019d0
TEST RAX,RAX
MOV EDX,0x1
CMOVNZ RDX,R8
CMP RAX,0x58
JBE 0x001019d9
MOV RCX,RDX
MOVDQA XMM0,xmmword ptr [0x00102160]
PXOR XMM1,XMM1
MOV RA... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >) */
int (*) [16] func0(vector param_1)
{
int auVar1 [16];
int (*pauVar2) [16];
ulong uVar3;
int (*pauVar4) [16];
ulong *puVar5;
ulong uVar6;
ulong uVar7;
int8 *in_RSI;
... |
36 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
vector<int> out;
int max=0;
for (int i=0;i<numbers.size();i++)
{
if (numbers[i]>max) max=numbers[i];
out.push_back(max);
}
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({}),{}));
assert (issame(func0({1, 2, 3, 2, 3, 4, 2}),{1, ... | O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1d74 <_ZNSt6vectorIiSaIiEEC1Ev>
movl $0x0,-0x2... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
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]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov ... | long long func0(long long a1, long long a2)
{
_DWORD *v2; // rax
unsigned long long v3; // rbx
int v5; // [rsp+10h] [rbp-20h] BYREF
int i; // [rsp+14h] [rbp-1Ch]
unsigned long long v7; // [rsp+18h] [rbp-18h]
v7 = __readfsqword(0x28u);
std::vector<int>::vector(a1);
v5 = 0;
for ( i = 0; ; ++i )
{
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101e0c
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
JM... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int *piVar1;
ulong uVar2;
ulong uVar3;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_28;
int local_2... |
37 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
vector<int> out;
int max=0;
for (int i=0;i<numbers.size();i++)
{
if (numbers[i]>max) max=numbers[i];
out.push_back(max);
}
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({}),{}));
assert (issame(func0({1, 2, 3, 2, 3, 4, 2}),{1, ... | O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
movl $0x0,0x4(%rsp)
mov (%rsi),%rdx
cmp %rdx,0x8(%... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_34], 0
mov rdx, [rsi]
cm... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v2; // rdx
unsigned long long v4; // rbp
_DWORD *v5; // rsi
int v7; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v8; // [rsp+8h] [rbp-30h]
v8 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v7 = 0;
v2 = *a2;
if ( a2[1] != *a2 ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x4],0x0
MOV RDX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDX
JZ 0x... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int iVar1;
int *piVar2;
long lVar3;
ulong uVar4;
long *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_34;
long local_30;
this =... |
38 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
vector<int> out;
int max=0;
for (int i=0;i<numbers.size();i++)
{
if (numbers[i]>max) max=numbers[i];
out.push_back(max);
}
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({}),{}));
assert (issame(func0({1, 2, 3, 2, 3, 4, 2}),{1, ... | O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
movl $0x0,0x4(%rsp)
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
mov [rsp+38h+var_34], 0
cmp ... | long long func0(long long a1, long long *a2)
{
long long v3; // rdx
long long v5; // rbx
long long v6; // rdi
long long v7; // rsi
int v8; // ecx
long long v9; // rsi
int v11; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v12; // [rsp+4h] [rbp-30h]
v12 = __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 qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x4],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x00101800
... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int iVar1;
long lVar2;
ulong uVar3;
long *in_RSI;
int *piVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int *piVar5;
long in_FS_OFFSET;
int local_34;
long local_... |
39 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(vector<int> numbers){
vector<int> out;
int max=0;
for (int i=0;i<numbers.size();i++)
{
if (numbers[i]>max) max=numbers[i];
out.push_back(max);
}
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({}),{}));
assert (issame(func0({1, 2, 3, 2, 3, 4, 2}),{1, ... | O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rcx
movl $0x0,0x4(%rsp)
cmp %rcx,0x8(%rs... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
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
mov [rsp+38h+var_34... | long long func0(long long a1, long long *a2)
{
long long v2; // rdx
long long v4; // rbx
_DWORD *v5; // rcx
_DWORD *v6; // rsi
int v7; // r12d
int v8; // eax
int v10; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+4h] [rbp-30h]
v11 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v2 = *... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
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
MOV dword ptr [RSP + 0x4],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
int iVar1;
int *piVar2;
long lVar3;
ulong uVar4;
long *in_RSI;
int *piVar5;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int iVar6;
long in_FS_OFFSET;
int local_34;
... |
40 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
bool is_palindrome(string str){
string s(str.rbegin(),str.rend());
return s==str;
}
| string func0(string str){
int i;
for (i=0;i<str.length();i++)
{
string rstr=str.substr(i);
if (is_palindrome(rstr))
{
string nstr;
nstr=str.substr(0,i);
string n2str(nstr.rbegin(),nstr.rend());
return str+n2str;
}
}
string n2... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("x") == "x");
assert (func0("xyz") == "xyzyx");
assert (func0("xyx") == "xyx") ;
assert (func0("jerry") == "jerryrrej");
assert (func0("cat") == "catac");
assert (func0("cata") == "catac");
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xc8,%rsp
mov %rdi,-0xc8(%rbp)
mov %rsi,-0xd0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0xb4(%rbp)
mov -0xb4(%rbp),%eax
movslq ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0B8h
mov [rbp+var_B8], rdi
mov [rbp+var_C0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_A4], 0
jmp loc_277F
loc_260D:
mov eax, [rbp+var_A4]... | long long func0(long long a1, long long a2)
{
char v2; // bl
int v3; // ebx
unsigned long long v4; // rbx
char v6; // [rsp+1Bh] [rbp-A5h] BYREF
int i; // [rsp+1Ch] [rbp-A4h]
_BYTE v8[8]; // [rsp+20h] [rbp-A0h] BYREF
_BYTE v9[8]; // [rsp+28h] [rbp-98h] BYREF
char *v10; // [rsp+30h] [rbp-90h]
char *v11... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RBP + -0xb8],RDI
MOV qword ptr [RBP + -0xc0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0xa4],0x0
JMP 0x0010277f
LAB_0010260d:
MOV EAX,dword ptr [RBP + -0xa4]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x... | /* func0(std::string) */
int8 func0(int8 param_1,ulong param_2)
{
char cVar1;
ulong uVar2;
ulong uVar3;
long in_FS_OFFSET;
allocator local_ad;
int local_ac;
int local_a8 [8];
int local_a0 [8];
allocator *local_98;
allocator *local_90;
string local_88 [32];
string local_68 [32];
string local_... |
41 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
bool is_palindrome(string str){
string s(str.rbegin(),str.rend());
return s==str;
}
| string func0(string str){
int i;
for (i=0;i<str.length();i++)
{
string rstr=str.substr(i);
if (is_palindrome(rstr))
{
string nstr;
nstr=str.substr(0,i);
string n2str(nstr.rbegin(),nstr.rend());
return str+n2str;
}
}
string n2... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("x") == "x");
assert (func0("xyz") == "xyzyx");
assert (func0("xyx") == "xyx") ;
assert (func0("jerry") == "jerryrrej");
assert (func0("cat") == "catac");
assert (func0("cata") == "catac");
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa0,%rsp
mov %rdi,%r13
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
mov 0x8(%rsi),%rdx
test %rdx,%rdx
je 156c ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov r12, rdi
mov rbp, rsi
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
mov rdx, [rsi+8]
test rdx, rdx
jz loc_1833
mov ... | long long func0(long long a1, size_t *a2)
{
unsigned long long v4; // rdx
unsigned long long v5; // rbx
_QWORD *v6; // rdi
char v7; // r14
void *v8; // r15
size_t v9; // r14
char v10; // al
unsigned long long v11; // rax
char *v12; // rax
long long v13; // rcx
size_t v14; // rdx
unsigned long l... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV R12,RDI
MOV RBP,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RSI + 0x8]
TEST RDX,RDX
JZ 0x00101833
MOV EBX,0x0
LEA R13,[RSP + 0x10]
JMP 0x0010147f
LAB_001013e2:
LEA RSI,[RSP + 0x8]
LEA ... | /* func0(std::string) */
long * func0(long *param_1,ulong *param_2)
{
long *__src;
ulong *puVar1;
ulong **ppuVar2;
ulong **ppuVar3;
ulong uVar4;
char cVar5;
uint uVar6;
ulong uVar7;
long lVar8;
int8 uVar9;
uint uVar10;
ulong uVar11;
long in_FS_OFFSET;
int *local_b8;
ulong **local_b0;
l... |
42 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
bool is_palindrome(string str){
string s(str.rbegin(),str.rend());
return s==str;
}
| string func0(string str){
int i;
for (i=0;i<str.length();i++)
{
string rstr=str.substr(i);
if (is_palindrome(rstr))
{
string nstr;
nstr=str.substr(0,i);
string n2str(nstr.rbegin(),nstr.rend());
return str+n2str;
}
}
string n2... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("x") == "x");
assert (func0("xyz") == "xyzyx");
assert (func0("xyx") == "xyx") ;
assert (func0("jerry") == "jerryrrej");
assert (func0("cat") == "catac");
assert (func0("cata") == "catac");
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0xc8,%rsp
mov 0x8(%rsi),%rcx
mov %rdi,0x10(%rsp)
mov %fs:0x28,%rax
mov %rax,0xb8(%rsp)
xor %eax,%eax
test %rcx... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
push rbp
push rbx
sub rsp, 0A8h
mov rbx, [rsi+8]
mov [rsp+0D8h+var_C8], rdi
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
xor eax, eax
test rbx, rbx
jz ... | long long func0(long long a1, long long *a2)
{
size_t v3; // rbx
unsigned long long v4; // rbp
double *v5; // rax
char v6; // bl
long long v7; // rsi
size_t v8; // rbx
void *v9; // r15
double *v10; // rdi
unsigned long long v11; // rax
long long v12; // rsi
double *v13; // rdi
size_t v14; // xm... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV RBX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
TEST RBX,RBX
JZ 0x00101dff
LEA RAX,[RSP + 0x30]
XOR EBP,EBP
LEA R14,[RSP + 0x40]
MOV qword ptr... | /* func0(std::string) */
long * func0(long *param_1,ulong *param_2)
{
int *puVar1;
ulong uVar2;
long *__src;
char cVar3;
ulong uVar4;
ulong *puVar5;
ulong *puVar6;
ulong *puVar7;
ulong *puVar8;
int8 uVar9;
int *puVar10;
ulong uVar11;
long in_FS_OFFSET;
ulong local_b0;
long *local_a8;
u... |
43 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
bool is_palindrome(string str){
string s(str.rbegin(),str.rend());
return s==str;
}
| string func0(string str){
int i;
for (i=0;i<str.length();i++)
{
string rstr=str.substr(i);
if (is_palindrome(rstr))
{
string nstr;
nstr=str.substr(0,i);
string n2str(nstr.rbegin(),nstr.rend());
return str+n2str;
}
}
string n2... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("x") == "x");
assert (func0("xyz") == "xyzyx");
assert (func0("xyx") == "xyx") ;
assert (func0("jerry") == "jerryrrej");
assert (func0("cat") == "catac");
assert (func0("cata") == "catac");
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xc8,%rsp
mov 0x8(%rsi),%r12
mov (%rsi),%rbp
mov %rdi,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0xb8(%rsp)
xor %ea... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0C8h
mov rbx, [rsi+8]
mov [rsp+0F8h+var_D0], rdi
mov [rsp+0F8h+var_E8], rsi
mov rax, fs:28h
mov [rsp+0F8h+var_40], rax
xor eax, eax
test r... | long long func0(long long a1, __int8 **a2)
{
size_t v2; // rbx
size_t v3; // r12
size_t v4; // rbx
__int8 *v5; // rbp
_QWORD *v6; // rax
size_t v7; // rbx
void *v8; // rbp
__int8 *v9; // rax
long long v10; // rbp
char *v11; // r14
size_t *v12; // rax
size_t v13; // rdx
char *v14; // rbx
cha... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xc8
MOV RBX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
TEST RBX,RBX
JZ 0x0010210e
LEA RAX,[RSP + 0x50]
XOR R12D,R12D
LEA R15,[RSP ... | /* func0(std::string) */
long * func0(long *param_1,ulong *param_2)
{
int *puVar1;
ulong uVar2;
int iVar3;
uint uVar4;
ulong *puVar5;
ulong *puVar6;
ulong *puVar7;
ulong *puVar8;
ulong uVar9;
long lVar10;
uint uVar11;
int *puVar12;
size_t sVar13;
ulong *puVar14;
ulong uVar15;
ulong *pu... |
44 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string a,string b){
string output="";
for (int i=0;(i<a.length() and i<b.length());i++)
{
if (i<a.length() and i<b.length())
{
if (a[i]== b[i])
{
output+='0';
}
else output+='1';
}
else
{
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("111000", "101010") == "010010");
assert (func0("1", "1") == "0");
assert (func0("0101", "0000") == "0101");
assert (func0("010", "110") == "100");
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %rdx,-0x38(%rbp)
mov %fs:0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
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
lea rax, [rbp+var_25]
mov [rbp+var_20], ... | long long func0(long long a1, long long a2, long long a3)
{
unsigned long long v3; // rbx
unsigned long long v4; // rbx
char v6; // bl
unsigned long long v7; // rbx
char *v8; // rax
unsigned long long v9; // rbx
unsigned long long v10; // rbx
char v14; // [rsp+2Bh] [rbp-25h] BYREF
int i; // [rsp+2Ch]... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x25]
MOV qword ptr [RBP + -0x20],RAX
NOP
NOP
LEA RDX,[RBP + -0x25]
MOV RAX,qw... | /* func0(std::string, std::string) */
string * func0(string *param_1,ulong param_2,ulong param_3)
{
char cVar1;
bool bVar2;
char *pcVar3;
ulong uVar4;
ulong uVar5;
long in_FS_OFFSET;
allocator local_2d;
int local_2c;
allocator *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28... |
45 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string a,string b){
string output="";
for (int i=0;(i<a.length() and i<b.length());i++)
{
if (i<a.length() and i<b.length())
{
if (a[i]== b[i])
{
output+='0';
}
else output+='1';
}
else
{
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("111000", "101010") == "010010");
assert (func0("1", "1") == "0");
assert (func0("0101", "0000") == "0101");
assert (func0("010", "110") == "100");
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %rsi,%r13
mov %rdx,%r14
le... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov r13, rsi
mov r14, rdx
lea rax, [rdi+10h]
mov [rsp+48h+var_40], rax
mov [rdi], rax
lea rsi, aFunc0110+16h; ""
mov ... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
unsigned long long i; // rbp
long long v6; // r12
unsigned long long v7; // r15
unsigned long long v8; // rax
unsigned long long v9; // rax
long long v10; // r12
unsigned long long v11; // r15
_QWORD *v12; // [rsp+8h] [rbp-40h]
v12 = a1 + 2;
*a1 ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R13,RSI
MOV R14,RDX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RDI],RAX
LEA RSI,[0x1020e6]
MOV RDX,RSI
LAB_0010129a:
CALL 0x0010178a
MOV EBP,0x0
CMP qword ptr [R13 + 0x8],0x0
JNZ 0x00101342
LAB_00101... | /* func0(std::string, std::string) */
long * func0(long *param_1,long *param_2,long *param_3)
{
long *plVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
plVar1 = param_1 + 2;
*param_1 = (long)plVar1;
std::string::_M_construct<char_const*>((char *)param_1,"",0x1020e6);
uVar4 = 0;
if (param_2[1] != 0) ... |
46 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string a,string b){
string output="";
for (int i=0;(i<a.length() and i<b.length());i++)
{
if (i<a.length() and i<b.length())
{
if (a[i]== b[i])
{
output+='0';
}
else output+='1';
}
else
{
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("111000", "101010") == "010010");
assert (func0("1", "1") == "0");
assert (func0("0101", "0000") == "0101");
assert (func0("010", "110") == "100");
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
lea 0x10(%rdi),%rax
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
cmpq $0x0,0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
lea rax, [rdi+10h]
mov r15, rdx
push r14
mov r14, rsi
push r13
push r12
push rbp
xor ebp, ebp
push rbx
mov rbx, rdi
sub rsp, 18h
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
cmp ... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
unsigned long long v4; // rbp
bool v5; // zf
unsigned long long v6; // rdx
_BYTE *v7; // rax
long long v8; // r12
unsigned long long v9; // r13
unsigned long long v10; // rdx
_BYTE *v11; // rax
_QWORD *v13; // rax
_QWORD *v14; // [rsp+8h] [rbp-40h... | func0:
ENDBR64
PUSH R15
LEA RAX,[RDI + 0x10]
MOV R15,RDX
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
XOR EBP,EBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],0x0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RDI],RAX
JNZ 0x0010161c
JMP 0x0010... | /* func0(std::string, std::string) */
long * func0(long *param_1,long *param_2,long *param_3)
{
long *plVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
long *plVar5;
ulong uVar6;
ulong uVar7;
plVar1 = param_1 + 2;
uVar7 = 0;
param_1[1] = 0;
*(int *)(param_1 + 2) = 0;
lVar4 = param_2[1];
*para... |
47 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string a,string b){
string output="";
for (int i=0;(i<a.length() and i<b.length());i++)
{
if (i<a.length() and i<b.length())
{
if (a[i]== b[i])
{
output+='0';
}
else output+='1';
}
else
{
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("111000", "101010") == "010010");
assert (func0("1", "1") == "0");
assert (func0("0101", "0000") == "0101");
assert (func0("010", "110") == "100");
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
lea 0x10(%rdi),%rax
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
cmpq $0x0,0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
lea rax, [rdi+10h]
mov r15, rdx
push r14
mov r14, rsi
push r13
push r12
push rbp
xor ebp, ebp
push rbx
mov rbx, rdi
sub rsp, 18h
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
cmp ... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
unsigned long long v4; // rbp
bool v5; // zf
unsigned long long v6; // rdx
_BYTE *v7; // rax
long long v8; // r12
unsigned long long v9; // r13
unsigned long long v10; // rdx
_BYTE *v11; // rax
_QWORD *v13; // rax
_QWORD *v14; // [rsp+8h] [rbp-40h... | func0:
ENDBR64
PUSH R15
LEA RAX,[RDI + 0x10]
MOV R15,RDX
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
XOR EBP,EBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],0x0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RDI],RAX
JNZ 0x001016ac
JMP 0x0010... | /* func0(std::string, std::string) */
long * func0(long *param_1,long *param_2,long *param_3)
{
long *plVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
long *plVar5;
ulong uVar6;
ulong uVar7;
plVar1 = param_1 + 2;
uVar7 = 0;
param_1[1] = 0;
*(int *)(param_1 + 2) = 0;
lVar4 = param_2[1];
*para... |
48 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(vector<string> strings){
string out;
for (int i=0;i<strings.size();i++)
{
if (strings[i].length()>out.length()) out=strings[i];
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == "");
assert (func0({"x", "y", "z"}) == "x");
assert (func0({"x", "yyy", "zzzz", "www", "kkkk", "abc"}) == "zzzz");
assert (func0({"a", "b", "c"}) == "a");
assert (func0({"a", "bb", "ccc"}) == "ccc");
}
| O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
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]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string... | long long func0(long long a1, long long a2)
{
long long v2; // rax
unsigned long long v3; // rbx
long long v4; // rax
int i; // [rsp+1Ch] [rbp-14h]
std::string::basic_string(a1);
for ( i = 0; i < (unsigned long long)std::vector<std::string>::size(a2); ++i )
{
v2 = std::vector<std::string>::operator[... | 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]
MOV RDI,RAX
CALL 0x00102370
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00102554
LAB_001024f3:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
string * func0(vector param_1)
{
ulong uVar1;
string *psVar2;
ulong uVar3;
vector<std::string,std::allocator<std::string>> *in_RSI;
int4 in_register_0000003c;
string *this;
int4 local_1c;
this = (string *)CONCAT44(in_register_0000... |
49 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(vector<string> strings){
string out;
for (int i=0;i<strings.size();i++)
{
if (strings[i].length()>out.length()) out=strings[i];
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == "");
assert (func0({"x", "y", "z"}) == "x");
assert (func0({"x", "yyy", "zzzz", "www", "kkkk", "abc"}) == "zzzz");
assert (func0({"a", "b", "c"}) == "a");
assert (func0({"a", "bb", "ccc"}) == "ccc");
}
| O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r12
mov %rsi,%rbp
lea 0x10(%... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r12
push rbp
push rbx
mov r12, rdi
mov rbp, rsi
lea rax, [rdi+10h]
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rsi, [rsi]
cmp [rbp+8], rsi
jz short loc_13A... | long long func0(long long a1, long long *a2)
{
long long v3; // rsi
unsigned long long v4; // rbx
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v3 = *a2;
if ( a2[1] != v3 )
{
v4 = 0LL;
do
{
if ( *(_QWORD *)(a1 + 8) < *(_QWORD *)(32 * v4 + v3 + 8) )
... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV RBP,RSI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RSI,qword ptr [RSI]
CMP qword ptr [RBP + 0x8],RSI
JZ 0x001013a8
MOV EBX,0x0
JMP 0x00101372
LAB_0010135a:
MOV RSI,qword ptr [RBP]
ADD RBX,0x1
MOV ... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
string * func0(vector param_1)
{
ulong uVar1;
long *in_RSI;
long lVar2;
int4 in_register_0000003c;
string *psVar3;
psVar3 = (string *)CONCAT44(in_register_0000003c,param_1);
*(string **)psVar3 = psVar3 + 0x10;
*(int8 *)(psVar3 + 8... |
50 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(vector<string> strings){
string out;
for (int i=0;i<strings.size();i++)
{
if (strings[i].length()>out.length()) out=strings[i];
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == "");
assert (func0({"x", "y", "z"}) == "x");
assert (func0({"x", "yyy", "zzzz", "www", "kkkk", "abc"}) == "zzzz");
assert (func0({"a", "b", "c"}) == "a");
assert (func0({"a", "bb", "ccc"}) == "ccc");
}
| O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r13
lea 0x10(%rdi),%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
lea rax, [rdi+10h]
push r12
push rbp
mov rbp, rdi
push rbx
mov byte ptr [rdi+10h], 0
mov rdx, [rsi]
mov [rdi], rax
mov qword ptr [rdi+8], 0
cmp [rsi+8], rdx
jz short loc_1780
mov r12, rs... | long long func0(long long a1, long long *a2)
{
long long v2; // rdx
long long v3; // rbx
unsigned long long i; // rax
*(_BYTE *)(a1 + 16) = 0;
v2 = *a2;
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
if ( a2[1] != v2 )
{
v3 = 0LL;
for ( i = 0LL; ; i = *(_QWORD *)(a1 + 8) )
{
i... | func0:
ENDBR64
LEA RAX,[RDI + 0x10]
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV byte ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x00101780
MOV R12,RSI
XOR EBX,EBX
XOR EAX,EAX
JMP 0x00101759
LAB_00101740:
MOV RAX,qword ptr [R12 + 0x8... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
string * func0(vector param_1)
{
ulong uVar1;
long lVar2;
ulong uVar3;
long *in_RSI;
int4 in_register_0000003c;
string *psVar4;
psVar4 = (string *)CONCAT44(in_register_0000003c,param_1);
psVar4[0x10] = (string)0x0;
lVar2 = *in_R... |
51 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(vector<string> strings){
string out;
for (int i=0;i<strings.size();i++)
{
if (strings[i].length()>out.length()) out=strings[i];
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == "");
assert (func0({"x", "y", "z"}) == "x");
assert (func0({"x", "yyy", "zzzz", "www", "kkkk", "abc"}) == "zzzz");
assert (func0({"a", "b", "c"}) == "a");
assert (func0({"a", "bb", "ccc"}) == "ccc");
}
| O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r13
lea 0x10(%rdi),%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r12
lea rax, [rdi+10h]
push rbp
mov rbp, rdi
push rbx
mov byte ptr [rdi+10h], 0
mov rcx, [rsi+8]
mov rdx, [rsi]
mov [rdi], rax
mov qword ptr [rdi+8], 0
cmp rcx, rdx
jz short loc_178... | long long func0(long long a1, long long *a2)
{
long long v2; // rcx
long long v3; // rdx
long long v4; // rbx
unsigned long long i; // rax
*(_BYTE *)(a1 + 16) = 0;
v2 = a2[1];
v3 = *a2;
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
if ( v2 != v3 )
{
v4 = 0LL;
for ( i = 0LL; ; i = *... | func0:
ENDBR64
PUSH R12
LEA RAX,[RDI + 0x10]
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV byte ptr [RDI + 0x10],0x0
MOV RCX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
CMP RCX,RDX
JZ 0x00101788
MOV R12,RSI
XOR EBX,EBX
XOR EAX,EAX
JMP 0x0010175f
LAB_00101748:
MOV RAX,RCX
ADD ... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
string * func0(vector param_1)
{
ulong uVar1;
long lVar2;
long lVar3;
ulong uVar4;
long *in_RSI;
int4 in_register_0000003c;
string *psVar5;
psVar5 = (string *)CONCAT44(in_register_0000003c,param_1);
psVar5[0x10] = (string)0x0;
... |
52 | func0 | #include<stdio.h>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| int func0(int a, int b){
int out,m;
while (true){
if (a<b)
{
m=a;a=b;b=m;
}
a=a%b;
if (a==0) return b;
}
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 7) == 1);
assert (func0(10, 15) == 5);
assert (func0(49, 14) == 7);
assert (func0(144, 60) == 12);
assert (func0(3, 5) == 1);
assert (func0(25, 15) == 5);
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jge 1171 <_Z5func0ii+0x28>
mov -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0x18(%rbp... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
loc_1157:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jge short loc_1171
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
mov eax, [rbp+var_18]
mov [rbp+var_14], eax
mov eax, [rbp+var_4]
mov ... | long long func0(signed int a1, signed int a2)
{
signed int v5; // [rsp+14h] [rbp-4h]
do
{
if ( a1 < a2 )
{
v5 = a1;
a1 = a2;
a2 = v5;
}
a1 %= a2;
}
while ( a1 );
return (unsigned int)a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
LAB_00101157:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JGE 0x00101171
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x14],EAX
... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
int4 local_20;
int4 local_1c;
local_20 = param_2;
local_1c = param_1;
do {
iVar1 = local_1c;
if (local_1c < local_20) {
local_1c = local_20;
local_20 = iVar1;
}
local_1c = local_1c % local_20;
} while (l... |
53 | func0 | #include<stdio.h>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| int func0(int a, int b){
int out,m;
while (true){
if (a<b)
{
m=a;a=b;b=m;
}
a=a%b;
if (a==0) return b;
}
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 7) == 1);
assert (func0(10, 15) == 5);
assert (func0(49, 14) == 7);
assert (func0(144, 60) == 12);
assert (func0(3, 5) == 1);
assert (func0(25, 15) == 5);
}
| O1 | cpp | func0(int, int):
endbr64
mov %edi,%eax
jmp 115a <_Z5func0ii+0x11>
cltd
idiv %esi
mov %edx,%eax
test %edx,%edx
je 1166 <_Z5func0ii+0x1d>
cmp %esi,%eax
jge 1151 <_Z5func0ii+0x8>
mov %eax,%edx
mov %esi,%eax
mov %edx,%esi
jmp 1151 <_Z5func0ii+0x8>
mov %esi,%eax
retq
| _Z5func0ii:
endbr64
mov eax, edi
jmp short loc_115A
loc_1151:
cdq
idiv esi
mov eax, edx
test edx, edx
jz short loc_1166
loc_115A:
cmp eax, esi
jge short loc_1151
mov edx, eax
mov eax, esi
mov esi, edx
jmp short loc_1151
loc_1166:
mov eax, esi
retn | long long func0(signed int a1, signed int a2)
{
signed int v3; // edx
do
{
if ( a1 < a2 )
{
v3 = a1;
a1 = a2;
a2 = v3;
}
a1 %= a2;
}
while ( a1 );
return (unsigned int)a2;
} | func0:
ENDBR64
MOV EAX,EDI
JMP 0x0010115a
LAB_00101151:
CDQ
IDIV ESI
MOV EAX,EDX
TEST EDX,EDX
JZ 0x00101166
LAB_0010115a:
CMP EAX,ESI
JGE 0x00101151
MOV EDX,EAX
MOV EAX,ESI
MOV ESI,EDX
JMP 0x00101151
LAB_00101166:
MOV EAX,ESI
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
do {
iVar1 = param_1;
if (param_1 < param_2) {
iVar1 = param_2;
param_2 = param_1;
}
param_1 = iVar1 % param_2;
} while (param_1 != 0);
return param_2;
} |
54 | func0 | #include<stdio.h>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| int func0(int a, int b){
int out,m;
while (true){
if (a<b)
{
m=a;a=b;b=m;
}
a=a%b;
if (a==0) return b;
}
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 7) == 1);
assert (func0(10, 15) == 5);
assert (func0(49, 14) == 7);
assert (func0(144, 60) == 12);
assert (func0(3, 5) == 1);
assert (func0(25, 15) == 5);
}
| O2 | cpp | func0(int, int):
endbr64
mov %esi,%r8d
nopw 0x0(%rax,%rax,1)
cmp %r8d,%edi
jge 134d <_Z5func0ii+0x1d>
mov %edi,%eax
mov %r8d,%edi
mov %eax,%r8d
mov %edi,%eax
cltd
idiv %r8d
mov %edx,%edi
test %edx,%edx
jne 1340 <_Z5func0ii+0x10>
mov %r8d,%eax
retq
nopl (%rax)
| _Z5func0ii:
endbr64
nop dword ptr [rax+00h]
loc_1328:
cmp edi, esi
jge short loc_1332
mov eax, edi
mov edi, esi
mov esi, eax
loc_1332:
mov eax, edi
cdq
idiv esi
mov edi, edx
test edx, edx
jnz short loc_1328
mov eax, esi
retn | long long func0(signed int a1, signed int a2)
{
signed int v2; // eax
do
{
if ( a1 < a2 )
{
v2 = a1;
a1 = a2;
a2 = v2;
}
a1 %= a2;
}
while ( a1 );
return (unsigned int)a2;
} | func0:
ENDBR64
NOP dword ptr [RAX]
LAB_00101328:
CMP EDI,ESI
JGE 0x00101332
MOV EAX,EDI
MOV EDI,ESI
MOV ESI,EAX
LAB_00101332:
MOV EAX,EDI
CDQ
IDIV ESI
MOV EDI,EDX
TEST EDX,EDX
JNZ 0x00101328
MOV EAX,ESI
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
do {
iVar1 = param_2;
if (param_1 < param_2) {
iVar1 = param_1;
param_1 = param_2;
}
param_2 = iVar1;
param_1 = param_1 % param_2;
} while (param_1 != 0);
return param_2;
} |
55 | func0 | #include<stdio.h>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| int func0(int a, int b){
int out,m;
while (true){
if (a<b)
{
m=a;a=b;b=m;
}
a=a%b;
if (a==0) return b;
}
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 7) == 1);
assert (func0(10, 15) == 5);
assert (func0(49, 14) == 7);
assert (func0(144, 60) == 12);
assert (func0(3, 5) == 1);
assert (func0(25, 15) == 5);
}
| O3 | cpp | func0(int, int):
endbr64
mov %esi,%r8d
cmp %edi,%r8d
jg 12e1 <_Z5func0ii+0x21>
nopl 0x0(%rax)
mov %edi,%eax
cltd
idiv %r8d
test %edx,%edx
je 12ee <_Z5func0ii+0x2e>
mov %edx,%edi
cmp %edi,%r8d
jle 12d0 <_Z5func0ii+0x10>
mov %r8d,%eax
mov %edi,%r8d
cltd
idiv %edi
test %edx,%edx
j... | _Z5func0ii:
endbr64
nop dword ptr [rax+00h]
loc_1328:
cmp edi, esi
jge short loc_1332
mov eax, edi
mov edi, esi
mov esi, eax
loc_1332:
mov eax, edi
cdq
idiv esi
mov edi, edx
test edx, edx
jnz short loc_1328
mov eax, esi
retn | long long func0(signed int a1, signed int a2)
{
signed int v2; // eax
do
{
if ( a1 < a2 )
{
v2 = a1;
a1 = a2;
a2 = v2;
}
a1 %= a2;
}
while ( a1 );
return (unsigned int)a2;
} | func0:
ENDBR64
NOP dword ptr [RAX]
LAB_00101328:
CMP EDI,ESI
JGE 0x00101332
MOV EAX,EDI
MOV EDI,ESI
MOV ESI,EAX
LAB_00101332:
MOV EAX,EDI
CDQ
IDIV ESI
MOV EDI,EDX
TEST EDX,EDX
JNZ 0x00101328
MOV EAX,ESI
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
do {
iVar1 = param_2;
if (param_1 < param_2) {
iVar1 = param_1;
param_1 = param_2;
}
param_2 = iVar1;
param_1 = param_1 % param_2;
} while (param_1 != 0);
return param_2;
} |
56 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(string str){
vector<string> out;
string current="";
for (int i=0;i<str.length();i++)
{
current=current+str[i];
out.push_back(current);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(""),{}));
assert (issame(func0("asdfgh") ,{"a", "as", "asd... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %rsi,-0x80(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq 3454 <_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_78]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112... | long long func0(long long a1, long long a2)
{
char *v2; // rax
unsigned long long v3; // rbx
char v5; // [rsp+13h] [rbp-6Dh] BYREF
int i; // [rsp+14h] [rbp-6Ch]
char *v7; // [rsp+18h] [rbp-68h]
_BYTE v8[32]; // [rsp+20h] [rbp-60h] BYREF
_BYTE v9[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v10;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDI,RAX
CALL 0x00102fe2
LEA RAX,[RBP + -0x6d]
MOV qword ptr [RBP + -0x68],RAX
NOP
NOP
LEA ... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,ulong param_2)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
long in_FS_OFFSET;
allocator local_75;
int local_74;
allocator *local_70;
string local_68 [32];
string lo... |
57 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(string str){
vector<string> out;
string current="";
for (int i=0;i<str.length();i++)
{
current=current+str[i];
out.push_back(current);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(""),{}));
assert (issame(func0("asdfgh") ,{"a", "as", "asd... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %rdi,%rbx
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov rbx, rdi
mov r13, rsi
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov ... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
long long v4; // rbp
char *v5; // rax
long long v6; // rcx
_QWORD *v7; // rdi
unsigned long long v8; // rdx
unsigned long long v9; // rdi
char *v10; // rax
char *v11; // rsi
unsigned int v12; // ecx
unsigned int v13; // eax
unsigned long long v14; // r12
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RBX,RDI
MOV R13,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA RDI,[RSP + 0x10]
LEA RAX,[RSP + 0x20]
MOV qword ptr [R... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2)
{
long *plVar1;
ulong *puVar2;
uint uVar3;
int8 uVar4;
long lVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
ulong uVar9;
long in_FS_OFFSET;
int lo... |
58 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(string str){
vector<string> out;
string current="";
for (int i=0;i<str.length();i++)
{
current=current+str[i];
out.push_back(current);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(""),{}));
assert (issame(func0("asdfgh") ,{"a", "as", "asd... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rsi
cmpq $0x0,0x8(... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rsi
lea rsi, function+0Ah; ""
push r14
mov rdx, rsi
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor ea... | long long func0(long long a1, _QWORD *a2)
{
long long v3; // rbp
unsigned long long v4; // rdx
size_t v5; // r12
char v6; // al
double *v7; // rdi
size_t v8; // rdx
__m128 v9; // xmm0
double v10; // rdx
_QWORD *v11; // rdi
void *v13; // [rsp+0h] [rbp-C0h]
char v14; // [rsp+37h] [rbp-89h] BYREF
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV R15,RSI
LEA RSI,[0x103192]
PUSH R14
MOV RDX,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RSP + 0x50]
MOVUPS xmmword ptr [RDI],XMM0
LEA RDI,[RSP + ... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2)
{
long *plVar1;
ulong *puVar2;
ulong uVar3;
ulong uVar4;
long in_FS_OFFSET;
int local_89;
ulong *local_88;
ulong local_80;
ulong auStack_78 [2];
... |
59 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<string> func0(string str){
vector<string> out;
string current="";
for (int i=0;i<str.length();i++)
{
current=current+str[i];
out.push_back(current);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(""),{}));
assert (issame(func0("asdfgh") ,{"a", "as", "asd... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %rsi,(%rsp)
lea 0x50(%rsp),%r14
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor %eax,... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 0A8h
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
xor eax, eax
lea rbp, [rsp+0D8h+n+8]
cmp qword ptr [rsi+8], 0... | long long func0(long long a1, _QWORD *a2)
{
size_t *v3; // rbp
bool v4; // zf
unsigned long long v5; // r13
size_t i; // rbx
void *v7; // rdi
size_t v8; // rbp
char v9; // al
double *v10; // rdi
size_t v11; // rdx
__m128 v12; // xmm0
double v13; // rdx
long long *v14; // rbx
long long v16; //... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x60]
CMP qword ptr [RSI + 0x8],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RSP + 0x20],R... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,long *param_2)
{
ulong *puVar1;
ulong *__src;
ulong uVar2;
ulong *__dest;
long lVar3;
long in_FS_OFFSET;
ulong local_90;
ulong *local_88;
ulong local_80;
ulong ... |
60 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int n){
string out="0";
for (int i=1;i<=n;i++)
out=out+" "+to_string(i);
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0) == "0");
assert (func0(3) == "0 1 2 3");
assert (func0(10) == "0 1 2 3 4 5 6 7 8 9 10");
assert (func0(5) == "0 1 2 3 4 5");
}
| O0 | cpp | func0[abi:cxx11](int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x98,%rsp
mov %rdi,-0x98(%rbp)
mov %esi,-0x9c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x85(%rbp),%rax
mov %rax,%rdi
callq 23b0 <_ZNSaIcEC1Ev@plt>
lea -0x85(%rbp),%rdx
mov -0x98(%rbp),%rax
... | _Z5func0B5cxx11i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov [rbp+var_98], rdi
mov [rbp+var_9C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_8D]
mov [rbp+var_88], rax
nop
nop
lea rdx, [rbp+var_8D]
mov rax, [rbp+var_98]
lea r... | long long func0[abi:cxx11](long long a1, int a2)
{
char v3; // [rsp+13h] [rbp-8Dh] BYREF
int i; // [rsp+14h] [rbp-8Ch]
char *v5; // [rsp+18h] [rbp-88h]
_BYTE v6[32]; // [rsp+20h] [rbp-80h] BYREF
_BYTE v7[32]; // [rsp+40h] [rbp-60h] BYREF
_BYTE v8[40]; // [rsp+60h] [rbp-40h] BYREF
unsigned long long v9; /... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0x98],RDI
MOV dword ptr [RBP + -0x9c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x8d]
MOV qword ptr [RBP + -0x88],RAX
NOP
NOP
LEA RDX,[RBP + -0x8d]
MOV RAX,qword ptr [RBP + -0x98]... | /* func0[abi:cxx11](int) */
string * func0_abi_cxx11_(int param_1)
{
int in_ESI;
int4 in_register_0000003c;
string *this;
long in_FS_OFFSET;
allocator local_95;
int local_94;
allocator *local_90;
string local_88 [32];
string local_68 [32];
string local_48 [40];
long local_20;
this = (string... |
61 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int n){
string out="0";
for (int i=1;i<=n;i++)
out=out+" "+to_string(i);
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0) == "0");
assert (func0(3) == "0 1 2 3");
assert (func0(10) == "0 1 2 3 4 5 6 7 8 9 10");
assert (func0(5) == "0 1 2 3 4 5");
}
| O1 | cpp | func0[abi:cxx11](int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x70,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%r14
mov %r14,(%rdi)
movb $0x30,0x10(%rdi)
movq $0x1,0x8(%rdi)
movb $0x0,0x11(%rdi)
test %esi,%esi
jle ... | _Z5func0B5cxx11i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 158h
mov r13, rdi
mov [rsp+188h+var_17C], esi
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
lea r15, [rdi+10h]
mov [rdi], r15
mov byte ptr [rdi+10h], 30h ; '0'
mov ... | void ** func0[abi:cxx11](void **a1, int a2)
{
long long *v3; // r15
int i; // r14d
unsigned int v5; // ebx
char *v6; // r12
int v7; // ebp
char v8; // bp
unsigned long long v9; // rbx
void *v10; // rbp
unsigned int v11; // eax
unsigned int v12; // ecx
unsigned int v13; // ebp
unsigned long long ... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x158
MOV R13,RDI
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
LEA R15,[RDI + 0x10]
MOV qword ptr [RDI],R15
MOV byte ptr [RDI + 0x10],0x30
MOV qword ptr [RDI + 0x8],0x1
MOV by... | /* func0[abi:cxx11](int) */
ulong * func0_abi_cxx11_(int param_1)
{
ulong *puVar1;
uint uVar2;
int8 *puVar3;
int8 uVar4;
long lVar5;
uint uVar6;
ulong *puVar7;
ulong uVar8;
uint uVar9;
char cVar10;
ulong uVar11;
int in_ESI;
int4 in_register_0000003c;
ulong *puVar12;
ulong *puVar13;
uin... |
62 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int n){
string out="0";
for (int i=1;i<=n;i++)
out=out+" "+to_string(i);
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0) == "0");
assert (func0(3) == "0 1 2 3");
assert (func0(10) == "0 1 2 3 4 5 6 7 8 9 10");
assert (func0(5) == "0 1 2 3 4 5");
}
| O2 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %esi,0x4(%rsp)
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x1,0x8(%rdi)
mov %rax,0x8(%rsp)
mov %rax,(%rdi)
mov $0x30,... | _Z5func0B5cxx11i:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 168h
mov [rsp+198h+var_17C], esi
mov rax, fs:28h
mov [rsp+198h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov qword ptr [rdi+8], 1
mov [rsp+198h+var_188], rax
mov... | void ** func0[abi:cxx11](void **a1, int a2)
{
int v3; // ebx
unsigned int v4; // r15d
unsigned int v5; // r12d
long long v6; // rsi
_BYTE *v7; // rcx
unsigned int v8; // eax
unsigned int v9; // esi
long long v10; // rax
long long v11; // rdi
long long v12; // rdx
__int8 v13; // r15
unsigned long... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x168
MOV dword ptr [RSP + 0x1c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x158],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI + 0x8],0x1
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RDI],RAX
MOV E... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int) */
ulong * func0_abi_cxx11_(int param_1)
{
uint uVar1;
int uVar2;
uint uVar3;
int8 *puVar4;
uint uVar5;
ulong uVar6;
ulong *puVar7;
ulong uVar8;
ulong uVar9;
uint uVar10;
int in_ESI;
u... |
63 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(int n){
string out="0";
for (int i=1;i<=n;i++)
out=out+" "+to_string(i);
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(0) == "0");
assert (func0(3) == "0 1 2 3");
assert (func0(10) == "0 1 2 3 4 5 6 7 8 9 10");
assert (func0(5) == "0 1 2 3 4 5");
}
| O3 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %esi,0x14(%rsp)
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x1,0x8(%rdi)
mov %rax,0x18(%rsp)
mov %rax,(%rdi)
mov $0x3... | _Z5func0B5cxx11i:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 168h
mov [rsp+198h+var_17C], esi
mov rax, fs:28h
mov [rsp+198h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov qword ptr [rdi+8], 1
mov [rsp+198h+var_188], rax
mov... | void ** func0[abi:cxx11](void **a1, int a2)
{
int v3; // ebx
unsigned int v4; // r15d
unsigned int v5; // r12d
long long v6; // rsi
_BYTE *v7; // rcx
unsigned int v8; // eax
unsigned int v9; // esi
long long v10; // rax
long long v11; // rdi
long long v12; // rdx
__int8 v13; // r15
unsigned long... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x168
MOV dword ptr [RSP + 0x1c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x158],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI + 0x8],0x1
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RDI],RAX
MOV E... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int) */
ulong * func0_abi_cxx11_(int param_1)
{
uint uVar1;
int uVar2;
uint uVar3;
int8 *puVar4;
ulong uVar5;
ulong *puVar6;
ulong uVar7;
int iVar8;
ulong uVar9;
uint uVar10;
int in_ESI;
ul... |
64 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string str){
vector<char> distinct={};
transform(str.begin(),str.end(),str.begin(),::tolower);
for (int i=0;i<str.size();i++)
{
bool isin=false;
for (int j=0;j<distinct.size();j++)
if (distinct[j]==str[i])
isin=true;
if (isin==false) distinc... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("abcde") == 5);
assert (func0("abcdecadeCADE") == 5);
assert (func0("aaaaAAAAaaaa") == 1);
assert (func0("Jerry jERRY JeRRRY") == 5);
assert (func0("xyzXYZ") == 3);
assert (func0("Jerry") == 4);
}
| 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 $0x40,%rsp
mov %rdi,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movq $0x0,-0x30(%rbp)
movq $0x0,-0x28(%rbp)
movq $0x0,-0x20(%... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 40h
mov [rbp+var_48], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
pxor xmm0, xmm0
movaps [rbp+var_30], xmm0
movq [rbp+var_20], xmm0
lea rax, [rbp+... | long long func0(long long a1)
{
long long v1; // r12
long long v2; // rbx
long long v3; // rax
char v4; // bl
long long v5; // rax
unsigned int v6; // ebx
char v8; // [rsp+17h] [rbp-39h]
int i; // [rsp+18h] [rbp-38h]
int j; // [rsp+1Ch] [rbp-34h]
__int128 v11; // [rsp+20h] [rbp-30h] BYREF
long lo... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x30],XMM0
MOVQ qword ptr [RBP + -0x20],XMM0
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00102bf4
MOV RAX,qwor... | /* func0(std::string) */
int4 func0(ulong param_1)
{
char cVar1;
bool bVar2;
__normal_iterator _Var3;
__normal_iterator _Var4;
__normal_iterator _Var5;
int4 uVar6;
char *pcVar7;
ulong uVar8;
long in_FS_OFFSET;
int local_40;
int local_3c;
vector<char,std::allocator<char>> local_38 [16];
int8 ... |
65 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string str){
vector<char> distinct={};
transform(str.begin(),str.end(),str.begin(),::tolower);
for (int i=0;i<str.size();i++)
{
bool isin=false;
for (int j=0;j<distinct.size();j++)
if (distinct[j]==str[i])
isin=true;
if (isin==false) distinc... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("abcde") == 5);
assert (func0("abcdecadeCADE") == 5);
assert (func0("aaaaAAAAaaaa") == 1);
assert (func0("Jerry jERRY JeRRRY") == 5);
assert (func0("xyzXYZ") == 3);
assert (func0("Jerry") == 4);
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
mov (%rdi),%r... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r12
push rbp
push rbx
sub rsp, 20h
mov r12, rdi
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
mov [rsp+38h+var_38], 0
mov [rsp+38h+var_30], 0
mov [rsp+38h+var_28], 0
mov rbx, [rdi]
mov rb... | long long func0(long long a1)
{
_BYTE *v1; // rbx
_BYTE *v2; // rbp
unsigned long long v3; // rbp
_BYTE *v4; // r8
_BYTE *v5; // rdx
unsigned long long v6; // rax
char v7; // dl
unsigned int v8; // ebx
void *v10; // [rsp+0h] [rbp-38h] BYREF
_BYTE *v11; // [rsp+8h] [rbp-30h]
_BYTE *v12; // [rsp+10... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV RBX,qword ptr [RDI]
MOV RBP,RBX
ADD RBP,qword ptr [RDI + 0x8]
CMP RBP,RBX
JZ 0x00101425
LAB_0... | /* func0(std::string) */
int func0(long *param_1)
{
bool bVar1;
int iVar2;
ulong uVar3;
char *pcVar4;
char *pcVar5;
ulong uVar6;
long in_FS_OFFSET;
char *local_38;
char *local_30;
char *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_38 = (char *)0x0;
local_30 ... |
66 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string str){
vector<char> distinct={};
transform(str.begin(),str.end(),str.begin(),::tolower);
for (int i=0;i<str.size();i++)
{
bool isin=false;
for (int j=0;j<distinct.size();j++)
if (distinct[j]==str[i])
isin=true;
if (isin==false) distinc... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("abcde") == 5);
assert (func0("abcdecadeCADE") == 5);
assert (func0("aaaaAAAAaaaa") == 1);
assert (func0("Jerry jERRY JeRRRY") == 5);
assert (func0("xyzXYZ") == 3);
assert (func0("Jerry") == 4);
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x20,%rsp
mov (%rdi),%r14
mov 0x8(%rdi),%r13
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rsp)
movq $... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
push rbx
sub rsp, 28h
mov rbx, [rdi]
mov rbp, [rdi+8]
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
movaps [rsp+48h+var_48], xmm0
mov [rsp+48h+var_38], 0
... | long long func0(char **a1)
{
char *v1; // rbx
char *v2; // rbp
char *v3; // rbp
int v5; // edi
unsigned long long v6; // rbp
_BYTE *v7; // r8
char *v8; // r9
char *v9; // rsi
char *v10; // rdx
unsigned long long v11; // r13
unsigned long long v12; // rcx
char v13; // di
char *v15; // rdx
__... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBX,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
ADD RBP,RBX
CMP RBP,RBX
JZ 0x001016fe
MOV R12,RDI
NOP d... | /* func0(std::string) */
ulong func0(long *param_1)
{
bool bVar1;
int iVar2;
ulong uVar3;
char *pcVar4;
char *pcVar5;
char *pcVar6;
char *pcVar7;
ulong uVar8;
char *pcVar9;
ulong uVar10;
long in_FS_OFFSET;
int local_48 [16];
char *local_38;
long local_30;
pcVar5 = (char *)*param_1;
... |
67 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(string str){
vector<char> distinct={};
transform(str.begin(),str.end(),str.begin(),::tolower);
for (int i=0;i<str.size();i++)
{
bool isin=false;
for (int j=0;j<distinct.size();j++)
if (distinct[j]==str[i])
isin=true;
if (isin==false) distinc... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("abcde") == 5);
assert (func0("abcdecadeCADE") == 5);
assert (func0("aaaaAAAAaaaa") == 1);
assert (func0("Jerry jERRY JeRRRY") == 5);
assert (func0("xyzXYZ") == 3);
assert (func0("Jerry") == 4);
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x20,%rsp
mov (%rdi),%r14
mov 0x8(%rdi),%r12
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movaps %... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
push rbx
sub rsp, 28h
mov rbx, [rdi]
mov rbp, [rdi+8]
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
movaps [rsp+48h+var_48], xmm0
mov [rsp+48h+var_38], 0
... | long long func0(char **a1)
{
char *v1; // rbx
char *v2; // rbp
char *v3; // rbp
int v5; // edi
unsigned long long v6; // rbp
char *v7; // r9
_BYTE *v8; // r8
char *v9; // rsi
char *v10; // rdx
unsigned long long v11; // r13
unsigned long long v12; // rcx
char v13; // di
char *v15; // rdx
__... | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBX,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
ADD RBP,RBX
CMP RBP,RBX
JZ 0x001017b5
MOV R12,RDI
NOP d... | /* func0(std::string) */
ulong func0(long *param_1)
{
bool bVar1;
int iVar2;
ulong uVar3;
char *pcVar4;
char *pcVar5;
char *pcVar6;
char *pcVar7;
ulong uVar8;
char *pcVar9;
ulong uVar10;
long in_FS_OFFSET;
int local_48 [16];
char *local_38;
long local_30;
pcVar5 = (char *)*param_1;
... |
68 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(string music_string){
string current="";
vector<int> out={};
if (music_string.length()>0)
music_string=music_string+' ';
for (int i=0;i<music_string.length();i++)
{
if (music_string[i]==' ')
{
if (current=="o") out.push_back(4);
if (... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("") , {}));
assert (issame(func0("o o o o") ,{4, 4, 4, 4}))... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %rsi,-0x80(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x68(%rbp),%rax
mov %rax,%rdi
callq 2420 <_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_70]
mov [rbp+var_68], rax
nop
nop
lea rdx, [rbp... | long long func0(long long a1, long long a2)
{
char *v2; // rax
unsigned long long v3; // rbx
int v5; // [rsp+10h] [rbp-70h] BYREF
int i; // [rsp+14h] [rbp-6Ch]
int *v7; // [rsp+18h] [rbp-68h]
_BYTE v8[32]; // [rsp+20h] [rbp-60h] BYREF
_BYTE v9[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v10; /... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x70]
MOV qword ptr [RBP + -0x68],RAX
NOP
NOP
LEA RDX,[RBP + -0x70]
LEA RAX,[RBP + -0x60]
LEA RCX,[0x105008]
M... | /* func0(std::string) */
vector<int,std::allocator<int>> * func0(vector<int,std::allocator<int>> *param_1,string *param_2)
{
bool bVar1;
long lVar2;
char *pcVar3;
ulong uVar4;
ulong uVar5;
long in_FS_OFFSET;
int local_78;
int local_74;
int *local_70;
string local_68 [32];
string local_48 [40];
... |
69 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(string music_string){
string current="";
vector<int> out={};
if (music_string.length()>0)
music_string=music_string+' ';
for (int i=0;i<music_string.length();i++)
{
if (music_string[i]==' ')
{
if (current=="o") out.push_back(4);
if (... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("") , {}));
assert (issame(func0("o o o o") ,{4, 4, 4, 4}))... | 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,%r15
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rdi
lea 0x30(%rsp... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r15, rdi
mov rbp, rsi
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rdi, [rsp+0A8h+s1]
lea rax, [rsp+0A8h+var_78]
m... | long long func0(long long a1, void **a2)
{
unsigned long long v4; // rbx
_BYTE *v6; // r12
_BYTE *v7; // rax
void *v8; // rcx
long long v9; // rbx
char *v10; // rcx
unsigned long long v11; // rdi
_BYTE *v12; // rax
char *v13; // rsi
unsigned int v14; // edx
unsigned int v15; // eax
unsigned lon... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R15,RDI
MOV RBP,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x20]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LEA RSI,[0x10320c]
MOV RDX,RSI
LAB_001013e4:
CALL 0x00101fd4
PXOR XMM0... | /* func0(std::string) */
vector<int,std::allocator<int>> * func0(vector<int,std::allocator<int>> *param_1,ulong *param_2)
{
char *pcVar1;
char cVar2;
ulong uVar3;
ulong *puVar4;
char *pcVar5;
uint uVar6;
int iVar7;
int8 uVar8;
long lVar9;
char *pcVar10;
uint uVar11;
ulong uVar12;
long in_FS_... |
70 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(string music_string){
string current="";
vector<int> out={};
if (music_string.length()>0)
music_string=music_string+' ';
for (int i=0;i<music_string.length();i++)
{
if (music_string[i]==' ')
{
if (current=="o") out.push_back(4);
if (... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("") , {}));
assert (issame(func0("o o o o") ,{4, 4, 4, 4}))... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov 0x8(%rsi),%r13
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%rax
movb $0x0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 88h
mov r14, [rsi+8]
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rax, [rsp+0B8h+var_78]
mov ... | long long func0(long long a1, void **a2)
{
size_t v3; // r14
double *v5; // r15
double *v7; // rdi
size_t v8; // xmm0_8
__m128 v9; // xmm0
double v10; // rdx
unsigned long long i; // rbx
_WORD *v12; // rax
_DWORD *v13; // rsi
_DWORD *v14; // rsi
long long v15; // rbp
char v16; // r14
_BYTE *v... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV R14,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x30],R... | /* func0(std::string) */
vector<int,std::allocator<int>> * func0(vector<int,std::allocator<int>> *param_1,ulong *param_2)
{
char *pcVar1;
char cVar2;
ulong uVar3;
int4 *puVar4;
char *pcVar5;
char *pcVar6;
ulong uVar7;
ulong *__dest;
long in_FS_OFFSET;
int local_8c;
short *local_88;
char *local... |
71 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(string music_string){
string current="";
vector<int> out={};
if (music_string.length()>0)
music_string=music_string+' ';
for (int i=0;i<music_string.length();i++)
{
if (music_string[i]==' ')
{
if (current=="o") out.push_back(4);
if (... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("") , {}));
assert (issame(func0("o o o o") ,{4, 4, 4, 4}))... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov 0x8(%rsi),%r12
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x30(%rs... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 88h
mov r14, [rsi+8]
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rax, [rsp+0B8h+var_78]
mov ... | long long func0(long long a1, void **a2)
{
size_t v3; // r14
double *v5; // r15
double *v7; // rdi
size_t v8; // xmm0_8
__m128 v9; // xmm0
double v10; // rdx
unsigned long long i; // rbx
_WORD *v12; // rax
_DWORD *v13; // rsi
_DWORD *v14; // rsi
long long v15; // rbp
char v16; // r14
_BYTE *v... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV R14,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x30],R... | /* func0(std::string) */
vector<int,std::allocator<int>> * func0(vector<int,std::allocator<int>> *param_1,ulong *param_2)
{
char *pcVar1;
char cVar2;
ulong uVar3;
int4 *puVar4;
char *pcVar5;
ulong uVar6;
char *pcVar7;
ulong *__dest;
long in_FS_OFFSET;
int local_8c;
short *local_88;
char *local... |
72 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string str,string substring){
int out=0;
if (str.length()==0) return 0;
for (int i=0;i<=str.length()-substring.length();i++)
if (str.substr(i,substring.length())==substring)
out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("", "x") == 0);
assert (func0("xyxyxyx", "x") == 4);
assert (func0("cacacacac", "cac") == 4);
assert (func0("john doe", "john") == 1);
assert (func0("", "a") == 0);
assert (func0("aaa", "a") == 3);
assert (func0("aaaa", "aa") == 3)... | 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 $0x50,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 50h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_48], 0
mov rax, [rbp+var_58]
mov rdi,... | long long func0(long long a1, long long a2)
{
long long v3; // rax
char v4; // bl
long long v5; // r12
unsigned int v6; // [rsp+18h] [rbp-48h]
int i; // [rsp+1Ch] [rbp-44h]
_BYTE v8[40]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v9; // [rsp+48h] [rbp-18h]
v9 = __readfsqword(0x28u);
v6 = 0;
i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x50
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 dword ptr [RBP + -0x48],0x0
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
CALL 0x00101280
TEST RAX,RAX
SETZ AL
TEST... | /* func0(std::string, std::string) */
int func0(ulong param_1,string *param_2)
{
bool bVar1;
long lVar2;
long lVar3;
long in_FS_OFFSET;
int local_50;
int local_4c;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_50 = 0;
lVar2 = std::string::length();
if... |
73 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string str,string substring){
int out=0;
if (str.length()==0) return 0;
for (int i=0;i<=str.length()-substring.length();i++)
if (str.substr(i,substring.length())==substring)
out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("", "x") == 0);
assert (func0("xyxyxyx", "x") == 4);
assert (func0("cacacacac", "cac") == 4);
assert (func0("john doe", "john") == 1);
assert (func0("", "a") == 0);
assert (func0("aaa", "a") == 3);
assert (func0("aaaa", "aa") == 3)... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %e... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov rcx, [rdi+8]
test rcx, rcx
jz short loc_131E
mov r12, rdi
mov rbp, ... | long long func0(_QWORD *a1, long long a2)
{
unsigned long long v2; // rcx
unsigned long long v4; // rax
unsigned long long v5; // rbx
unsigned int v6; // r13d
void *v7; // rdi
bool v8; // r15
unsigned long long v10; // rcx
void *s1; // [rsp+0h] [rbp-68h] BYREF
size_t n; // [rsp+8h] [rbp-60h]
_QWORD... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RCX,qword ptr [RDI + 0x8]
TEST RCX,RCX
JZ 0x0010131e
MOV R12,RDI
MOV RBP,RSI
MOV RAX,qword ptr [RSI + 0x8]
MOV EBX,0x0
MOV R13D,0x0
MOV R14,RSP
JMP 0x00101376
LAB_... | /* func0(std::string, std::string) */
int func0(long *param_1,int8 *param_2)
{
int iVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
int iVar6;
long in_FS_OFFSET;
bool bVar7;
long *local_68;
size_t local_60;
long local_58 [3];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x... |
74 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string str,string substring){
int out=0;
if (str.length()==0) return 0;
for (int i=0;i<=str.length()-substring.length();i++)
if (str.substr(i,substring.length())==substring)
out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("", "x") == 0);
assert (func0("xyxyxyx", "x") == 4);
assert (func0("cacacacac", "cac") == 4);
assert (func0("john doe", "john") == 1);
assert (func0("", "a") == 0);
assert (func0("aaa", "a") == 3);
assert (func0("aaaa", "aa") == 3)... | 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> >) [clone .part.0]:
push %r15
xor %r15d,%r15d
push %r14
push %r13
xor %r13d,%r13d
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4__part_0:
push r15
push r14
xor r14d, r14d
push r13
xor r13d, r13d
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 68h
mov rcx, [rdi+8]
mov r15, [rsi+8]
mov rax, fs:28h
mov [rsp+98h+var_40],... | long long func0(long long *a1, long long a2)
{
unsigned long long v2; // r14
unsigned int v3; // r13d
unsigned long long v5; // rcx
size_t v6; // r15
_QWORD *v7; // rdi
long long v8; // r9
size_t v9; // rcx
_BYTE *v10; // r9
_QWORD *v11; // rax
_QWORD *v12; // rdi
void *v13; // rax
_QWORD *v15;... | func0:
PUSH R15
PUSH R14
XOR R14D,R14D
PUSH R13
XOR R13D,R13D
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x68
MOV RCX,qword ptr [RDI + 0x8]
MOV R15,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x30]
LEA R12,[RSP + 0x40]
MOV qword ptr [RSP + ... | /* func0(std::string, std::string) [clone .part.0] */
int func0(long *param_1,int8 *param_2)
{
long lVar1;
size_t *psVar2;
int iVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
ulong __n;
long in_FS_OFFSET;
size_t local_70;
size_t *local_68;
size_t local_60;
size_t local_58 [3];
long local_40;
... |
75 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string str,string substring){
int out=0;
if (str.length()==0) return 0;
for (int i=0;i<=str.length()-substring.length();i++)
if (str.substr(i,substring.length())==substring)
out+=1;
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("", "x") == 0);
assert (func0("xyxyxyx", "x") == 4);
assert (func0("cacacacac", "cac") == 4);
assert (func0("john doe", "john") == 1);
assert (func0("", "a") == 0);
assert (func0("aaa", "a") == 3);
assert (func0("aaaa", "aa") == 3)... | 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> >) [clone .part.0]:
push %r15
xor %r15d,%r15d
push %r14
xor %r14d,%r14d
push %r13
mov %rdi,%r13
push %r12
push %rbp
mov %rsi,%rbp
pus... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4__part_0:
push r15
push r14
xor r14d, r14d
push r13
xor r13d, r13d
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 68h
mov rcx, [rdi+8]
mov r15, [rsi+8]
mov rax, fs:28h
mov [rsp+98h+var_40],... | long long func0(long long *a1, long long a2)
{
unsigned long long v2; // r14
unsigned int v3; // r13d
unsigned long long v5; // rcx
size_t v6; // r15
_QWORD *v7; // rdi
long long v8; // r9
size_t v9; // rcx
_BYTE *v10; // r9
_QWORD *v11; // rax
_QWORD *v12; // rdi
void *v13; // rax
_QWORD *v15;... | func0:
PUSH R15
PUSH R14
XOR R14D,R14D
PUSH R13
XOR R13D,R13D
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x68
MOV RCX,qword ptr [RDI + 0x8]
MOV R15,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x30]
LEA R12,[RSP + 0x40]
MOV qword ptr [RSP + ... | /* func0(std::string, std::string) [clone .part.0] */
int func0(long *param_1,int8 *param_2)
{
long lVar1;
size_t *psVar2;
int iVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
ulong __n;
long in_FS_OFFSET;
size_t local_70;
size_t *local_68;
size_t local_60;
size_t local_58 [3];
long local_40;
... |
76 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string numbers){
map<string,int> tonum={{"zero",0},{"one",1},{"two",2},{"three",3},{"four",4},{"five",5},{"six",6},{"seven",7},{"eight",8},{"nine",9}};
map<int,string> numto={{0,"zero"},{1,"one"},{2,"two"},{3,"three"},{4,"four"},{5,"five"},{6,"six"},{7,"seven"},{8,"eight"},{9,"nine"}};
int coun... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("three") == "three");
assert (func0("three five nine") == "three five nine");
assert (func0("five zero four seven nine eight") == "zero four five seven eight nine");
assert (func0("six five four three two one ze... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x2b8,%rsp
mov %rdi,-0x2d8(%rbp)
mov %rsi,-0x2e0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movl... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2E8h
mov [rbp+var_2F8], rdi
mov [rbp+var_300], rsi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea r13, [rbp+var_1D0]... | long long func0(long long a1, long long a2)
{
_DWORD *i; // rbx
_DWORD *j; // rbx
int *v4; // rax
char *v5; // rax
unsigned long long v6; // rbx
long long v7; // rax
char v9; // [rsp+2Ah] [rbp-2E6h] BYREF
char v10; // [rsp+2Bh] [rbp-2E5h] BYREF
int v11; // [rsp+2Ch] [rbp-2E4h] BYREF
int v12; // [rs... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2e8
MOV qword ptr [RBP + -0x2f8],RDI
MOV qword ptr [RBP + -0x300],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA R13,[RBP + -0x1d0]
MOV EBX,0x9
MOV RCX,R13
MOV dword ptr [RBP + -0x2e0],0x0
LEA RAX... | /* func0(std::string) */
string * func0(string *param_1,string *param_2)
{
long lVar1;
char *pcVar2;
int *piVar3;
ulong uVar4;
int8 uVar5;
pair<std::string_const,int> *this;
pair<int_const,std::string> *this_00;
ulong uVar6;
long in_FS_OFFSET;
__new_allocator<std::pair<int_const,std::string>> loca... |
77 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string numbers){
map<string,int> tonum={{"zero",0},{"one",1},{"two",2},{"three",3},{"four",4},{"five",5},{"six",6},{"seven",7},{"eight",8},{"nine",9}};
map<int,string> numto={{0,"zero"},{1,"one"},{2,"two"},{3,"three"},{4,"four"},{5,"five"},{6,"six"},{7,"seven"},{8,"eight"},{9,"nine"}};
int coun... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("three") == "three");
assert (func0("three five nine") == "three five nine");
assert (func0("five zero four seven nine eight") == "zero four five seven eight nine");
assert (func0("six five four three two one ze... | 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 $0x298,%rsp
mov %rdi,%rbp
mov %rsi,%r15
mov %fs:0x28,%rax
mov %rax,0x288(%rsp)
xor %eax,%eax
lea 0xf0(%rsp),%rbx
lea 0x100(%... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 2A8h
mov r15, rdi
mov r13, rsi
mov rax, fs:28h
mov [rsp+2D8h+var_40], rax
xor eax, eax
lea rdi, [rsp+2D8h+var_1D8]
lea rax, [rsp+2D8h+var... | void ** func0(void **a1, void **a2)
{
void **v3; // r13
char *v4; // rbx
long long insert_hint_unique_pos; // rax
long long v6; // rdx
void **i; // rbx
char *v8; // rbx
char *v9; // rbx
char *v10; // rdi
char **v11; // rax
unsigned long long v12; // rbx
void *v13; // rbp
_BYTE *v14; // rdx
voi... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x2a8
MOV R15,RDI
MOV R13,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x298],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x100]
LEA RAX,[RSP + 0x110]
MOV qword ptr [RSP + 0x100],RAX
LEA RDX,[0x1051f8]
LEA RSI,[RDX + -0x4]
LAB_0010247a:
CALL 0x0010... | /* func0(std::string) */
ulong * func0(ulong *param_1,ulong *param_2)
{
char *pcVar1;
int *piVar2;
char cVar3;
ulong uVar4;
ulong uVar5;
char **__s2;
char *pcVar6;
_Rb_tree_iterator _Var7;
uint uVar8;
int **ppuVar9;
ulong uVar10;
int4 extraout_var;
char *pcVar11;
int4 extraout_var_00;
in... |
78 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string numbers){
map<string,int> tonum={{"zero",0},{"one",1},{"two",2},{"three",3},{"four",4},{"five",5},{"six",6},{"seven",7},{"eight",8},{"nine",9}};
map<int,string> numto={{0,"zero"},{1,"one"},{2,"two"},{3,"three"},{4,"four"},{5,"five"},{6,"six"},{7,"seven"},{8,"eight"},{9,"nine"}};
int coun... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("three") == "three");
assert (func0("three five nine") == "three five nine");
assert (func0("five zero four seven nine eight") == "zero four five seven eight nine");
assert (func0("six five four three two one ze... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
mov $0x6973,%r8d
push %r14
push %r13
push %r12
mov %rdi,%r12
mov $0x7774,%edi
push %rbp
push %rbx
sub $0x2c8,%rsp
mov %rsi,0x10(%rsp)
lea 0x120(%rsp),%rbx
mov $0x6e6f,%esi
lea 0x... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
mov r15, rdi
mov edi, 7774h
mov r8d, 6973h
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 2E8h
mov [rsp+318h+var_2F8], rsi
lea rbx, [rsp+318h+var_1D8]
mov esi, 6E6Fh
mov rax, fs:28h
mo... | __m128i ** func0(__m128i **a1, void **a2)
{
__int128 *v3; // rbx
long long v4; // r12
long long v5; // rdx
long long insert_hint_unique_pos; // rax
int *v7; // rdx
const void **v8; // rbp
unsigned int v9; // r13d
size_t v10; // r12
size_t v11; // r14
size_t v12; // rdx
unsigned int v13; // eax
l... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
MOV EDI,0x7774
MOV R8D,0x6973
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x2e8
MOV qword ptr [RSP + 0x20],RSI
LEA RBX,[RSP + 0x140]
MOV ESI,0x6e6f
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x2d8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x150]
MOV qword ptr [RSP + 0x58],RBX
MO... | /* WARNING: Restarted to delay deadcode elimination for space: stack */
/* func0(std::string) */
ulong * func0(ulong *param_1,ulong *param_2)
{
char *pcVar1;
char cVar2;
int iVar3;
int8 uVar4;
ulong uVar5;
int auVar6 [16];
int iVar7;
uint uVar8;
_Rb_tree_node_base *p_Var9;
_Rb_tree_node_base *p_Va... |
79 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| string func0(string numbers){
map<string,int> tonum={{"zero",0},{"one",1},{"two",2},{"three",3},{"four",4},{"five",5},{"six",6},{"seven",7},{"eight",8},{"nine",9}};
map<int,string> numto={{0,"zero"},{1,"one"},{2,"two"},{3,"three"},{4,"four"},{5,"five"},{6,"six"},{7,"seven"},{8,"eight"},{9,"nine"}};
int coun... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == "");
assert (func0("three") == "three");
assert (func0("three five nine") == "three five nine");
assert (func0("five zero four seven nine eight") == "zero four five seven eight nine");
assert (func0("six five four three two one ze... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
mov %rdi,%r15
mov $0x7774,%edi
mov $0x6973,%r8d
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x2c8,%rsp
mov %rsi,0x18(%rsp)
lea 0x120(%rsp),%rbx
mov $0x6e6f,%esi
mov %f... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
mov r15, rdi
mov edi, 7774h
mov r8d, 6973h
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 2E8h
mov [rsp+318h+var_2F8], rsi
lea rbx, [rsp+318h+var_1D8]
mov esi, 6E6Fh
mov rax, fs:28h
mo... | size_t ** func0(size_t **a1, void **a2)
{
__int128 *v3; // rbx
long long insert_hint_unique_pos; // rax
int *v5; // rdx
const void **v6; // r12
unsigned int v7; // r13d
long long v8; // rbp
size_t v9; // r14
_BYTE *v10; // rdi
_BYTE *v11; // rcx
long long v12; // rax
size_t v13; // rbp
size_t v1... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
MOV EDI,0x7774
MOV R8D,0x6973
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x2e8
MOV qword ptr [RSP + 0x20],RSI
LEA RBX,[RSP + 0x140]
MOV ESI,0x6e6f
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x2d8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x150]
MOV qword ptr [RSP + 0x58],RBX
MO... | /* WARNING: Restarted to delay deadcode elimination for space: stack */
/* func0(std::string) */
ulong * func0(ulong *param_1,ulong *param_2)
{
_Rb_tree_node_base _Var1;
int iVar2;
int iVar3;
ulong uVar4;
char *pcVar5;
int auVar6 [16];
uint uVar7;
int iVar8;
_Rb_tree_node_base *p_Var9;
_Rb_tree_no... |
80 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> numbers){
vector<float> out={};
for (int i=0;i<numbers.size();i++)
for (int j=i+1;j<numbers.size();j++)
if (out.size()==0 or abs(numbers[i]-numbers[j])<abs(out[0]-out[1]))
out={numbers[i],numbers[j]};
if (out[0]>out[1])
out={out[1],out[0]};
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({1.0, 2.0, 3.9, 4.0, 5.0, 2.2}) , {3.9, 4.0}));
... | O0 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x48,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov -0x58(%rbp),%rax
movq $0x0,(%rax)
m... | _Z5func0St6vectorIfSaIfEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
mov rax, [rbp+var_58]
pxor xmm0, xmm0
movups xmmword ptr... | long long func0(long long a1, long long a2)
{
__m128i v2; // xmm1
float v3; // xmm0_4
__m128i v4; // xmm2
__m128i v5; // xmm0
char v6; // al
float v8; // [rsp+8h] [rbp-68h]
float v9; // [rsp+Ch] [rbp-64h]
float v10; // [rsp+Ch] [rbp-64h]
float v11; // [rsp+Ch] [rbp-64h]
int i; // [rsp+28h] [rbp-48h... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x58]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword pt... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
bool bVar1;
long lVar2;
ulong uVar3;
float *pfVar4;
int4 *puVar5;
vector<float,std::allocator<float>> *in_RSI;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
l... |
81 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> numbers){
vector<float> out={};
for (int i=0;i<numbers.size();i++)
for (int j=i+1;j<numbers.size();j++)
if (out.size()==0 or abs(numbers[i]-numbers[j])<abs(out[0]-out[1]))
out={numbers[i],numbers[j]};
if (out[0]>out[1])
out={out[1],out[0]};
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({1.0, 2.0, 3.9, 4.0, 5.0, 2.2}) , {3.9, 4.0}));
... | O1 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%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),%rax
cmp %rax,0x8(%rsi)
j... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
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 rax, [rsi]
cmp [rsi+8], rax
jz... | int ** func0(int **a1, long long *a2)
{
long long v2; // r13
unsigned long long v3; // r14
long long v4; // rdx
unsigned long long v5; // rax
unsigned long long v6; // rbx
int *v7; // rax
int v9; // [rsp+0h] [rbp-38h] BYREF
int v10; // [rsp+4h] [rbp-34h]
_QWORD v11[6]; // [rsp+8h] [rbp-30h] BYREF
v... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RAX
JZ 0x00101391
MOV R12,RSI
MOV R13D,... | /* func0(std::vector<float, std::allocator<float> >) */
int (*) [16] func0(vector param_1)
{
float *pfVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
long *in_RSI;
int4 in_register_0000003c;
int (*pauVar5) [16];
long lVar6;
ulong uVar7;
long in_FS_OFFSET;
float local_38;
float local_34;
long loc... |
82 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> numbers){
vector<float> out={};
for (int i=0;i<numbers.size();i++)
for (int j=i+1;j<numbers.size();j++)
if (out.size()==0 or abs(numbers[i]-numbers[j])<abs(out[0]-out[1]))
out={numbers[i],numbers[j]};
if (out[0]>out[1])
out={out[1],out[0]};
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({1.0, 2.0, 3.9, 4.0, 5.0, 2.2}) , {3.9, 4.0}));
... | O2 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
mov ... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r14
pxor xmm0, xmm0
xor ecx, ecx
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rsi, [rsi+8]
mov rdx, [r12]... | long long func0(long long a1, long long *a2)
{
float *v2; // rcx
long long v4; // rsi
long long v5; // rdx
unsigned long long v6; // r14
long long v7; // r13
unsigned long long v8; // rbx
float *v9; // rax
unsigned long long v10; // rax
int v12; // [rsp+0h] [rbp-38h] BYREF
float v13; // [rsp+4h] [r... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
XOR ECX,ECX
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RSI,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [R12]
MOV qword ptr [RDI + 0x10],0x0
CMP RSI,RDX... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
float *pfVar1;
float fVar2;
ulong uVar3;
float *pfVar4;
long lVar5;
ulong uVar6;
long *in_RSI;
long lVar7;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
u... |
83 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> numbers){
vector<float> out={};
for (int i=0;i<numbers.size();i++)
for (int j=i+1;j<numbers.size();j++)
if (out.size()==0 or abs(numbers[i]-numbers[j])<abs(out[0]-out[1]))
out={numbers[i],numbers[j]};
if (out[0]>out[1])
out={out[1],out[0]};
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<float> a,vector<float>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (abs(a[i]-b[i])>1e-4) return false;
}
return true;
}
int main(){
assert (issame(func0({1.0, 2.0, 3.9, 4.0, 5.0, 2.2}) , {3.9, 4.0}));
... | O3 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
mov %rsi,%r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi+8]
mov rdx, [rsi]
mov qword ptr [rd... | long long * func0(long long *a1, long long *a2)
{
long long v3; // rcx
long long v4; // rdx
long long v6; // rbx
unsigned long long v7; // r15
unsigned long long v8; // rbp
long long v9; // r8
long long v10; // rbx
unsigned long long v11; // rax
double *v12; // rax
__m128 v13; // xmm2
unsigned int... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],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 RDX,RCX
JZ 0x00101ae0... | /* func0(std::vector<float, std::allocator<float> >) */
int (*) [16] func0(vector param_1)
{
int8 *puVar1;
int4 uVar2;
void *pvVar3;
uint uVar4;
ulong uVar5;
float *__dest;
float *pfVar6;
long *plVar7;
long lVar8;
long lVar9;
int8 *puVar10;
ulong uVar11;
long *in_RSI;
ulong uVar12;
uint ... |
84 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> numbers){
float min=100000,max=-100000;
for (int i=0;i<numbers.size();i++)
{
if (numbers[i]<min) min=numbers[i];
if (numbers[i]>max) max=numbers[i];
}
for (int i=0;i<numbers.size();i++)
numbers[i]=(numbers[i]-min)/(max-min);
... | #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({2.0, 49.9}) , {0.0, 1.0}));
assert (issame(fu... | 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)
movss 0x1faa(%rip),%xmm0
movss %xmm0,-0x20(%rbp)
movss 0x1fa1(%rip),%xmm0
movss %xmm0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
mov -0x18(%rbp),%eax
movs... | _Z5func0St6vectorIfSaIfEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
movss xmm0, cs:dword_31D0
movss [rbp+var_20], xmm0
movss xmm0, cs:dword_31D4
movss [rbp+var_1C], xmm0
mov [rbp+var_18], 0
jmp loc_1310
loc_1284:
mov eax, [... | long long func0(long long a1, long long a2)
{
float v3; // [rsp+Ch] [rbp-34h]
float v4; // [rsp+20h] [rbp-20h]
float v5; // [rsp+24h] [rbp-1Ch]
int i; // [rsp+28h] [rbp-18h]
int j; // [rsp+2Ch] [rbp-14h]
v4 = 100000.0;
v5 = -100000.0;
for ( i = 0; i < (unsigned long long)std::vector<float>::size(a2); ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOVSS XMM0,dword ptr [0x001031d0]
MOVSS dword ptr [RBP + -0x20],XMM0
MOVSS XMM0,dword ptr [0x001031d4]
MOVSS dword ptr [RBP + -0x1c],XMM0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101310
LAB_00101284:... | /* func0(std::vector<float, std::allocator<float> >) */
vector<float,std::allocator<float>> * func0(vector param_1)
{
float fVar1;
ulong uVar2;
float *pfVar3;
vector<float,std::allocator<float>> *in_RSI;
int4 in_register_0000003c;
int4 local_28;
int4 local_24;
int4 local_20;
int4 local_1c;
loca... |
85 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> numbers){
float min=100000,max=-100000;
for (int i=0;i<numbers.size();i++)
{
if (numbers[i]<min) min=numbers[i];
if (numbers[i]>max) max=numbers[i];
}
for (int i=0;i<numbers.size();i++)
numbers[i]=(numbers[i]-min)/(max-min);
... | #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({2.0, 49.9}) , {0.0, 1.0}));
assert (issame(fu... | O1 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov %rdi,%rax
mov (%rsi),%rcx
mov 0x8(%rsi),%r8
sub %rcx,%r8
mov %r8,%rdi
shr $0x2,%rdi
je 1274 <_Z5func0St6vectorIfSaIfEE+0x6b>
mov %rcx,%rdx
add %rcx,%r8
movss 0xf93(%rip),%xmm0
movss 0xf8f(%rip),%xmm2
movss (%rcx),%xmm1
movaps ... | _Z5func0St6vectorIfSaIfEE:
endbr64
mov r8, rdi
mov rdx, [rsi+8]
mov rax, [rsi]
mov rcx, rdx
sub rcx, rax
sar rcx, 2
cmp rdx, rax
jz loc_12BF
mov edx, 0
movss xmm0, cs:dword_2004
movss xmm2, cs:dword_2008
loc_123F:
movss xmm1, dword ptr [rax+rdx*4]
movaps xmm3, xmm1
minss xm... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v3; // rax
unsigned long long v4; // rdx
float v5; // xmm0_4
float v6; // xmm2_4
float v7; // xmm3_4
float v8; // xmm1_4
unsigned long long v9; // rdx
float v10; // xmm1_4
long long v11; // rdi
v3 = *a2;
if ( a2[1] == *a2 )
{
v11 = *a2;
... | func0:
ENDBR64
MOV R8,RDI
MOV RDX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RSI]
MOV RCX,RDX
SUB RCX,RAX
SAR RCX,0x2
CMP RDX,RAX
JZ 0x001012bf
MOV EDX,0x0
MOVSS XMM0,dword ptr [0x00102004]
MOVSS XMM2,dword ptr [0x00102008]
LAB_0010123f:
MOVSS XMM1,dword ptr [RAX + RDX*0x4]
MOVAPS XMM3,XMM1
MINSS XMM3,XMM2
MOVAPS XMM2,XM... | /* func0(std::vector<float, std::allocator<float> >) */
long * func0(vector param_1)
{
float *pfVar1;
float fVar2;
float fVar3;
long lVar4;
ulong uVar5;
long *in_RSI;
int4 in_register_0000003c;
long *plVar6;
long lVar7;
float fVar8;
float fVar9;
plVar6 = (long *)CONCAT44(in_register_0000003... |
86 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> numbers){
float min=100000,max=-100000;
for (int i=0;i<numbers.size();i++)
{
if (numbers[i]<min) min=numbers[i];
if (numbers[i]>max) max=numbers[i];
}
for (int i=0;i<numbers.size();i++)
numbers[i]=(numbers[i]-min)/(max-min);
... | #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({2.0, 49.9}) , {0.0, 1.0}));
assert (issame(fu... | O2 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov 0x8(%rsi),%r9
mov %rdi,%rax
mov (%rsi),%rdi
mov %r9,%r8
sub %rdi,%r8
mov %r8,%rcx
shr $0x2,%rcx
je 17a2 <_Z5func0St6vectorIfSaIfEE+0x82>
movss 0xa7f(%rip),%xmm0
mov %rdi,%rdx
add %rdi,%r8
mov %rdi,%rcx
movss 0xa72(%rip),%... | _Z5func0St6vectorIfSaIfEE:
endbr64
movdqu xmm3, xmmword ptr [rsi]
mov rax, rdi
movhlps xmm5, xmm3
movq rdx, xmm3
movq rcx, xmm5
mov r9, rcx
sub r9, rdx
mov r10, r9
sar r10, 2
cmp rdx, rcx
jz loc_16E8
movss xmm0, cs:dword_2004
movss xmm2, cs:dword_2008
mov r8, rdx
xor ecx,... | __m128 * func0(
__m128 *a1,
const __m128i *a2,
double a3,
double a4,
double a5,
double a6,
double a7,
__m128 a8)
{
__m128 v8; // xmm3
__m128 *result; // rax
unsigned long long v10; // xmm5_8
float *v11; // rdx
unsigned long long v12; // r10
flo... | func0:
ENDBR64
MOVDQU XMM3,xmmword ptr [RSI]
MOV RAX,RDI
MOVHLPS XMM5,XMM3
MOVQ RDX,XMM3
MOVQ RCX,XMM5
MOV R9,RCX
SUB R9,RDX
MOV R10,R9
SAR R10,0x2
CMP RDX,RCX
JZ 0x001016e8
MOVSS XMM0,dword ptr [0x00102004]
MOVSS XMM2,dword ptr [0x00102008]
MOV R8,RDX
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101678:
MOVSS XMM1,... | /* func0(std::vector<float, std::allocator<float> >) */
void func0(vector param_1)
{
float fVar1;
int8 uVar2;
int8 *puVar3;
float fVar4;
float *pfVar5;
float *pfVar6;
ulong uVar7;
float *pfVar8;
float *pfVar9;
int (*in_RSI) [16];
int4 in_register_0000003c;
ulong uVar10;
float fVar11;
float... |
87 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<float> func0(vector<float> numbers){
float min=100000,max=-100000;
for (int i=0;i<numbers.size();i++)
{
if (numbers[i]<min) min=numbers[i];
if (numbers[i]>max) max=numbers[i];
}
for (int i=0;i<numbers.size();i++)
numbers[i]=(numbers[i]-min)/(max-min);
... | #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({2.0, 49.9}) , {0.0, 1.0}));
assert (issame(fu... | O3 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
mov 0x8(%rsi),%r10
mov (%rsi),%r9
mov %rdi,%rax
mov %r10,%r8
sub %r9,%r8
mov %r8,%rdi
sar $0x2,%rdi
je 1806 <_Z5func0St6vectorIfSaIfEE+0x106>
movss 0xa9f(%rip),%xmm1
mov %r9,%rcx
add %r9,%r8
mov %r9,%rdx
movss 0xa92(%rip),%xm... | _Z5func0St6vectorIfSaIfEE:
endbr64
movdqu xmm5, xmmword ptr [rsi]
mov r8, rsi
movhlps xmm7, xmm5
movq rax, xmm5
movq rdx, xmm7
mov r9, rax
mov rsi, rdx
sub rsi, rax
sar rsi, 2
cmp rdx, rax
jz loc_17F0
movss xmm1, cs:dword_2004
movss xmm2, cs:dword_2008
mov rcx, rax
xor ed... | __m128 * func0(
__m128 *a1,
const __m128i *a2,
double a3,
double a4,
double a5,
double a6,
double a7,
double a8,
double a9,
__m128 a10)
{
__m128 v10; // xmm5
__m128 *v12; // rax
unsigned long long v13; // rdx
unsigned long long v14;... | func0:
ENDBR64
MOVDQU XMM5,xmmword ptr [RSI]
MOV R8,RSI
MOVHLPS XMM7,XMM5
MOVQ RAX,XMM5
MOVQ RDX,XMM7
MOV R9,RAX
MOV RSI,RDX
SUB RSI,RAX
SAR RSI,0x2
CMP RDX,RAX
JZ 0x001017f0
MOVSS XMM1,dword ptr [0x00102004]
MOVSS XMM2,dword ptr [0x00102008]
MOV RCX,RAX
XOR EDX,EDX
NOP dword ptr [RAX + RAX*0x1]
LAB_001016f8:
MOVSS XMM... | /* func0(std::vector<float, std::allocator<float> >) */
int8 func0(vector param_1)
{
float fVar1;
int8 uVar2;
int auVar3 [16];
int (*pauVar4) [16];
int (*pauVar5) [16];
float fVar6;
int (*pauVar7) [16];
int (*pauVar8) [16];
ulong uVar9;
int (*in_RSI) [16];
ulong uVar10;
int4 in_register_000000... |
88 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<boost/any.hpp>
#include<list>
typedef std::list<boost::any> list_any;
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(list_any values){
list_any::iterator it;
boost::any anyone;
vector<int> out;
for (it=values.begin();it!=values.end();it++)
{
anyone=*it;
if( anyone.type() == typeid(int) )
out.push_back(boost::any_cast<int>(*it));
}
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({}),{}));
assert (issame(func0({4, {},23.2, 9, string("ada... | O0 | cpp | func0(std::__cxx11::list<boost::any, std::allocator<boost::any> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 4eb0 <_ZNSt14_List_iterator... | _Z5func0NSt7__cxx114listIN5boost3anyESaIS2_EEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt14_List_iteratorIN5boost3anyEEC2Ev;... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rax
long long i; // [rsp+10h] [rbp-30h] BYREF
long long v7; // [rsp+18h] [rbp-28h] BYREF
_QWORD v8[3]; // [rsp+20h] [rbp-20h] BYREF
v8[1] = __readfsqword(0x28u);
std::_List_iterator<boost::any>::_L... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
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
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00103f98
MOV qword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
... | /* func0(std::list<boost::any, std::allocator<boost::any> >) */
vector<int,std::allocator<int>> * func0(list param_1)
{
char cVar1;
int iVar2;
any *paVar3;
type_info *this;
list<boost::any,std::allocator<boost::any>> *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this_00;
long in... |
89 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<boost/any.hpp>
#include<list>
typedef std::list<boost::any> list_any;
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(list_any values){
list_any::iterator it;
boost::any anyone;
vector<int> out;
for (it=values.begin();it!=values.end();it++)
{
anyone=*it;
if( anyone.type() == typeid(int) )
out.push_back(boost::any_cast<int>(*it));
}
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({}),{}));
assert (issame(func0({4, {},23.2, 9, string("ada... | O1 | cpp | func0(std::__cxx11::list<boost::any, std::allocator<boost::any> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi)... | _Z5func0NSt7__cxx114listIN5boost3anyESaIS2_EEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 20h
mov r12, rdi
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov [rsp+48h+var_38], 0
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
_QWORD *v3; // rbp
long long v5; // rbx
long long v6; // rdi
void *v7; // rax
int *v8; // rdi
long long v9; // rax
int v10; // eax
_DWORD *v11; // rsi
int v13; // [rsp+Ch] [rbp-3Ch] BYREF
long long v14; // [rsp+10h] [rbp-38h]
unsigned long long v15; // [rsp... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x20
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBP,qword ptr [RSI]
CMP RBP,RSI
JZ 0x001024d... | /* func0(std::list<boost::any, std::allocator<boost::any> >) */
vector<int,std::allocator<int>> * func0(list param_1)
{
char *__s1;
int *piVar1;
int iVar2;
int1 *puVar3;
long *plVar4;
long *plVar5;
long *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long *plVar6;
long... |
90 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<boost/any.hpp>
#include<list>
typedef std::list<boost::any> list_any;
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(list_any values){
list_any::iterator it;
boost::any anyone;
vector<int> out;
for (it=values.begin();it!=values.end();it++)
{
anyone=*it;
if( anyone.type() == typeid(int) )
out.push_back(boost::any_cast<int>(*it));
}
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({}),{}));
assert (issame(func0({4, {},23.2, 9, string("ada... | O2 | cpp | func0(std::__cxx11::list<boost::any, std::allocator<boost::any> >):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov (%rsi),%rbx
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10... | _Z5func0NSt7__cxx114listIN5boost3anyESaIS2_EEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
mov rbx, [rsi]
mov r14, cs:s2
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
mov... | long long func0(long long a1, _QWORD *a2)
{
_QWORD *v3; // rbx
long long v5; // rdi
long long v6; // rax
long long v7; // rdi
long long v8; // rbp
void *v9; // rax
int *v10; // rdi
long long v11; // rdi
int *v12; // rdi
char *exception; // rax
_DWORD *v14; // rsi
int v15; // eax
long long v17... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBX,qword ptr [RSI]
MOV R14,qword ptr [0x00105b48]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RSP + 0x8],0x0
MOVUPS xmmword ptr [RDI]... | /* func0(std::list<boost::any, std::allocator<boost::any> >) */
vector<int,std::allocator<int>> * func0(list param_1)
{
int4 *puVar1;
int8 uVar2;
int iVar3;
long *plVar4;
int1 *puVar5;
long lVar6;
int8 *puVar7;
long *plVar8;
char *pcVar9;
long *in_RSI;
int4 in_register_0000003c;
vector<int,std... |
91 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<boost/any.hpp>
#include<list>
typedef std::list<boost::any> list_any;
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(list_any values){
list_any::iterator it;
boost::any anyone;
vector<int> out;
for (it=values.begin();it!=values.end();it++)
{
anyone=*it;
if( anyone.type() == typeid(int) )
out.push_back(boost::any_cast<int>(*it));
}
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({}),{}));
assert (issame(func0({4, {},23.2, 9, string("ada... | O3 | cpp | func0(std::__cxx11::list<boost::any, std::allocator<boost::any> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov (%rsi),%rbx
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%... | _Z5func0NSt7__cxx114listIN5boost3anyESaIS2_EEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, [rsi]
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [r... | long long func0(long long a1, _QWORD *a2)
{
_QWORD *v3; // rbx
long long v5; // r12
long long v6; // rdi
long long v7; // rbp
void *v8; // rax
int *v9; // rdi
long long v10; // rdi
int *v11; // rdi
char *exception; // rax
_DWORD *v13; // rsi
int v14; // eax
long long v16; // rax
long long v17... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
CMP RBX,RSI
JZ 0x001032ed
MOV R14,RSI
XOR R12D,R12D
NOP ... | /* func0(std::list<boost::any, std::allocator<boost::any> >) */
vector<int,std::allocator<int>> * func0(list param_1)
{
int4 *puVar1;
int iVar2;
long *plVar3;
int1 *puVar4;
long lVar5;
int8 *puVar6;
long *plVar7;
char *__s2;
long *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>... |
92 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string str){
return str.length();
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("x") == 1);
assert (func0("asdasnakj") == 9);
assert (func0("abc") == 3);
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1280 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv@plt>
leaveq
retq
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
leave
retn | long long func0(long long a1)
{
return std::string::length(a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101200
LEAVE
RET | /* func0(std::string) */
void func0(void)
{
std::string::length();
return;
} |
93 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(string str){
return str.length();
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("") == 0);
assert (func0("x") == 1);
assert (func0("asdasnakj") == 9);
assert (func0("abc") == 3);
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
retq
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov eax, [rdi+8]
retn | long long func0(long long a1)
{
return *(unsigned int *)(a1 + 8);
} | func0:
ENDBR64
MOV EAX,dword ptr [RDI + 0x8]
RET | /* func0(std::string) */
int4 func0(long param_1)
{
return *(int4 *)(param_1 + 8);
} |
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.