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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
382 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(int n) {
int x = 0;
for(int i = 1; i <= n; i++){
if (n % i == 0) {
x++;
}
}
return x;
}
| int main() {
assert(func0(15) == 4);
assert(func0(12) == 6);
assert(func0(9) == 3);
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
jle 12f0 <_Z5func0i+0x30>
lea 0x1(%rdi),%esi
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
cmp $0x1,%edx
adc $0x0,%r8d
add $0x1,%ecx
cmp %esi,%ecx
jne 12d8 <_Z5func0i+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov ... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1260
lea r8d, [rdi+1]
mov ecx, 1
xor esi, esi
nop dword ptr [rax+rax+00h]
loc_1248:
mov eax, edi
cdq
idiv ecx
cmp edx, 1
adc esi, 0
add ecx, 1
cmp r8d, ecx
jnz short loc_1248
mov eax, esi
retn
loc_1260:
xor esi, esi... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 0 )
return 0LL;
v1 = 1;
v2 = 0;
do
v2 += a1 % v1++ == 0;
while ( a1 + 1 != v1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101260
LEA R8D,[RDI + 0x1]
MOV ECX,0x1
XOR ESI,ESI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101248:
MOV EAX,EDI
CDQ
IDIV ECX
CMP EDX,0x1
ADC ESI,0x0
ADD ECX,0x1
CMP R8D,ECX
JNZ 0x00101248
MOV EAX,ESI
RET
LAB_00101260:
XOR ESI,ESI
MOV EAX,ESI
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if (0 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(param_1 % iVar1 == 0);
iVar1 = iVar1 + 1;
} while (param_1 + 1 != iVar1);
return iVar2;
}
return 0;
} |
383 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(int n) {
int x = 0;
for(int i = 1; i <= n; i++){
if (n % i == 0) {
x++;
}
}
return x;
}
| int main() {
assert(func0(15) == 4);
assert(func0(12) == 6);
assert(func0(9) == 3);
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11f0 <_Z5func0i+0x30>
lea 0x1(%rdi),%esi
mov $0x1,%ecx
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
cmp $0x1,%edx
adc $0x0,%r8d
add $0x1,%ecx
cmp %ecx,%esi
jne 11d8 <_Z5func0i+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov ... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1170
lea r8d, [rdi+1]
mov ecx, 1
xor esi, esi
nop dword ptr [rax+rax+00h]
loc_1158:
mov eax, edi
cdq
idiv ecx
cmp edx, 1
adc esi, 0
add ecx, 1
cmp r8d, ecx
jnz short loc_1158
mov eax, esi
retn
loc_1170:
xor esi, esi... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 0 )
return 0LL;
v1 = 1;
v2 = 0;
do
v2 += a1 % v1++ == 0;
while ( a1 + 1 != v1 );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
LEA R8D,[RDI + 0x1]
MOV ECX,0x1
XOR ESI,ESI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EAX,EDI
CDQ
IDIV ECX
CMP EDX,0x1
ADC ESI,0x0
ADD ECX,0x1
CMP R8D,ECX
JNZ 0x00101158
MOV EAX,ESI
RET
LAB_00101170:
XOR ESI,ESI
MOV EAX,ESI
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if (0 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(param_1 % iVar1 == 0);
iVar1 = iVar1 + 1;
} while (param_1 + 1 != iVar1);
return iVar2;
}
return 0;
} |
384 | func0 | #include <cassert>
#include <vector>
#include <map>
| std::map<int, int> func0(const std::vector<std::vector<int>>& list1) {
std::map<int, int> dic_data;
for (const auto& sublist : list1) {
for (int num : sublist) {
++dic_data[num];
}
}
return dic_data;
}
| int main() {
{
std::map<int, int> expected = {
{1, 1}, {2, 3}, {3, 1}, {4, 1}, {5, 2},
{6, 1}, {7, 1}, {8, 1}, {9, 1}
};
auto result = func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 8, 9, 5}});
assert(result == expected);
}
{
std::map<i... | O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x68(%rbp)... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_68]
mov rdi, rax
call _ZNSt3mapIiiSt4lessIiESaISt4pairIKiiEEEC2Ev; std... | long long func0(long long a1, long long a2)
{
_DWORD *v2; // rax
int v4; // [rsp+1Ch] [rbp-54h] BYREF
long long v5; // [rsp+20h] [rbp-50h] BYREF
long long v6; // [rsp+28h] [rbp-48h] BYREF
long long v7; // [rsp+30h] [rbp-40h] BYREF
_QWORD v8[2]; // [rsp+38h] [rbp-38h] BYREF
long long v9; // [rsp+48h] [rbp... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RDI,RAX
CALL 0x001024ea
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x30],RAX
MO... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
bool bVar1;
int *piVar2;
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*in_RSI;
long in_F... |
385 | func0 | #include <cassert>
#include <vector>
#include <map>
| std::map<int, int> func0(const std::vector<std::vector<int>>& list1) {
std::map<int, int> dic_data;
for (const auto& sublist : list1) {
for (int num : sublist) {
++dic_data[num];
}
}
return dic_data;
}
| int main() {
{
std::map<int, int> expected = {
{1, 1}, {2, 3}, {3, 1}, {4, 1}, {5, 2},
{6, 1}, {7, 1}, {8, 1}, {9, 1}
};
auto result = func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 8, 9, 5}});
assert(result == expected);
}
{
std::map<i... | O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r14
movl $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
lea 0x8(%rdi),%r13
mov %r13,0... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r13, rdi
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
lea r14, [rdi+8]
mov [rdi+18h], r14
mov [rdi+20h], r14
mov qword ptr [rdi+28h], 0
mov ... | long long func0(long long a1, int ***a2)
{
_DWORD *v3; // r14
long long v4; // rax
_DWORD *v5; // rbx
long long insert_hint_unique_pos; // rax
_DWORD *v7; // rdx
bool v8; // di
int *v9; // r12
int v10; // ebp
int *v11; // r15
_DWORD *v13; // [rsp+8h] [rbp-50h]
_DWORD *v14; // [rsp+8h] [rbp-50h]
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R13,RDI
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA R14,[RDI + 0x8]
MOV qword ptr [RDI + 0x18],R14
MOV qword ptr [RDI + 0x20],R14
MOV qword ptr [RDI + 0x28],0x0
MOV RAX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
_Rb_tree_node_base *p_Var1;
int iVar2;
int8 *puVar3;
int8 *puVar4;
int *piVar5;
bool bVar6;
_Rb_tree_node_base *p_Var7;
_Rb_tree_node_b... |
386 | func0 | #include <cassert>
#include <vector>
#include <map>
| std::map<int, int> func0(const std::vector<std::vector<int>>& list1) {
std::map<int, int> dic_data;
for (const auto& sublist : list1) {
for (int num : sublist) {
++dic_data[num];
}
}
return dic_data;
}
| int main() {
{
std::map<int, int> expected = {
{1, 1}, {2, 3}, {3, 1}, {4, 1}, {5, 2},
{6, 1}, {7, 1}, {8, 1}, {9, 1}
};
auto result = func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 8, 9, 5}});
assert(result == expected);
}
{
std::map<i... | O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
lea 0x8(%rdi),%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov 0x8(%rsi),%rax
mov (%rsi),%rcx
mov %r12,0x18(... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
lea r13, [rdi+8]
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
mov dword ptr [rdi+8], 0
mov rax, [rsi+8]
mov qword ptr [rdi+10h], 0
mov [rdi+18h], r13
mov [rdi+20h], r13
mov qword ptr ... | long long func0(long long a1, signed int ***a2)
{
_DWORD *v2; // r13
signed int **v4; // rax
signed int *v5; // rbp
long long v6; // rax
signed int v7; // ebx
_DWORD *v8; // r14
long long v9; // rdx
long long v10; // rcx
_DWORD *v11; // rax
_DWORD *v12; // rsi
long long insert_hint_unique_pos; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
LEA R13,[RDI + 0x8]
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RDI + 0x8],0x0
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x18],R13
MOV qword ptr [RDI + 0x20],R13
MOV qword ptr [RDI + 0x28],0x0
MOV RDI,qword ptr [RSI... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
_Rb_tree_node_base *p_Var1;
uint uVar2;
int8 *puVar3;
int8 *puVar4;
uint *puVar5;
_Rb_tree_node_base *p_Var6;
_Rb_tree_node_base *p_Var7;... |
387 | func0 | #include <cassert>
#include <vector>
#include <map>
| std::map<int, int> func0(const std::vector<std::vector<int>>& list1) {
std::map<int, int> dic_data;
for (const auto& sublist : list1) {
for (int num : sublist) {
++dic_data[num];
}
}
return dic_data;
}
| int main() {
{
std::map<int, int> expected = {
{1, 1}, {2, 3}, {3, 1}, {4, 1}, {5, 2},
{6, 1}, {7, 1}, {8, 1}, {9, 1}
};
auto result = func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 8, 9, 5}});
assert(result == expected);
}
{
std::map<i... | O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
lea 0x8(%rdi),%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov 0x8(%rsi),%rax
mov (%rsi),%rcx
mov %r12,0x18(... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
lea r14, [rdi+8]
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, [rsi+8]
mov rsi, [rsi]
mov [rdi+18h], r14
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov [rdi+20h], r14... | long long func0(long long a1, long long *a2)
{
long long v2; // r14
int **v4; // rax
long long v5; // rsi
int *v6; // r15
int *v7; // r12
_QWORD *v8; // rbx
int v9; // ebp
_QWORD *v10; // rcx
_QWORD *v11; // rdx
_QWORD *v12; // rax
_DWORD *v13; // rax
long long v14; // rdx
void *v15; // rcx
... | func0:
ENDBR64
PUSH R15
PUSH R14
LEA R14,[RDI + 0x8]
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RSI + 0x8]
MOV RSI,qword ptr [RSI]
MOV qword ptr [RDI + 0x18],R14
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x20],R14
MOV qword ptr [RDI + 0x28],0x... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
_Rb_tree_node_base *p_Var1;
int iVar2;
int iVar3;
int8 *puVar4;
int8 *puVar5;
int *piVar6;
_Rb_tree_node_base *p_Var7;
long lVar8;
_R... |
388 | func0 |
#include <vector>
#include <cassert>
| double func0(const std::vector<int>& numbers) {
double total = 1;
for (int x : numbers) {
total *= x;
}
return total / numbers.size();
}
| int main() {
assert(func0({8, 2, 3, -1, 7}) == -67.2);
assert(func0({-10, -20, -30}) == -2000.0);
assert(func0({19, 15, 18}) == 1710.0);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movsd 0x1eb0(%rip),%xmm0
movsd %xmm0,-0x18(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsd xmm0, cs:qword_30E0
movsd [rbp+var_18], xmm0
mov rax, [rbp+var_38]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rdi, rax... | unsigned long long func0(long long a1)
{
int *v1; // rax
long long v3; // [rsp+18h] [rbp-28h] BYREF
long long v4; // [rsp+20h] [rbp-20h] BYREF
double v5; // [rsp+28h] [rbp-18h]
long long v6; // [rsp+30h] [rbp-10h]
unsigned long long v7; // [rsp+38h] [rbp-8h]
v7 = __readfsqword(0x28u);
v5 = 1.0;
v6 =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSD XMM0,qword ptr [0x001030e0]
MOVSD qword ptr [RBP + -0x18],XMM0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV... | /* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
bool bVar1;
int *piVar2;
ulong uVar3;
long in_FS_OFFSET;
int8 local_30;
int8 local_28;
double local_20;
vector<int,std::allocator<int>> *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);... |
389 | func0 |
#include <vector>
#include <cassert>
| double func0(const std::vector<int>& numbers) {
double total = 1;
for (int x : numbers) {
total *= x;
}
return total / numbers.size();
}
| int main() {
assert(func0({8, 2, 3, -1, 7}) == -67.2);
assert(func0({-10, -20, -30}) == -2000.0);
assert(func0({19, 15, 18}) == 1710.0);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
cmp %rcx,%rdx
je 1250 <_Z5func0RKSt6vectorIiSaIiEE+0x47>
mov %rcx,%rax
movsd 0xedc(%rip),%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl (%rax),%xmm1
mulsd %xmm1,%xmm0
add $0x4,%rax
cmp %rax,%rdx
jne 1224 <_Z5... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rcx, [rdi]
mov rdx, [rdi+8]
cmp rcx, rdx
jz short loc_1250
mov rax, rcx
movsd xmm0, cs:qword_20D8
loc_1224:
pxor xmm1, xmm1
cvtsi2sd xmm1, dword ptr [rax]
mulsd xmm0, xmm1
add rax, 4
cmp rax, rdx
jnz short loc_1224
loc_1239:
sub rdx, r... | double func0(int **a1)
{
int *v1; // rdx
int *v2; // rax
double v3; // xmm0_8
long long v4; // rdx
double v5; // xmm1_8
v1 = a1[1];
if ( *a1 == v1 )
{
v3 = 1.0;
}
else
{
v2 = *a1;
v3 = 1.0;
do
v3 = v3 * (double)*v2++;
while ( v2 != v1 );
}
v4 = v1 - *a1;
if ( v4 <... | func0:
ENDBR64
MOV RCX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RCX,RDX
JZ 0x00101250
MOV RAX,RCX
MOVSD XMM0,qword ptr [0x001020d8]
LAB_00101224:
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RAX]
MULSD XMM0,XMM1
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101224
LAB_00101239:
SUB RDX,RCX
SAR RDX,0x2
JS 0x0010125a
PXOR XMM1,XMM... | /* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
int *piVar1;
double dVar2;
dVar2 = DAT_001020d8;
for (piVar1 = *(int **)param_1; piVar1 != *(int **)(param_1 + 8); piVar1 = piVar1 + 1) {
dVar2 = dVar2 * (double)*piVar1;
}
return dVar2 / (double)(ulong)((lon... |
390 | func0 |
#include <vector>
#include <cassert>
| double func0(const std::vector<int>& numbers) {
double total = 1;
for (int x : numbers) {
total *= x;
}
return total / numbers.size();
}
| int main() {
assert(func0({8, 2, 3, -1, 7}) == -67.2);
assert(func0({-10, -20, -30}) == -2000.0);
assert(func0({19, 15, 18}) == 1710.0);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
cmp %rdx,%rcx
je 1590 <_Z5func0RKSt6vectorIiSaIiEE+0x70>
movsd 0xbc8(%rip),%xmm0
mov %rcx,%rax
nopl 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
add $0x4,%rax
cvtsi2sdl -0x4(%rax),%xmm1
mulsd %xmm1,%xmm0
cmp ... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rcx, [rdi]
mov rdx, [rdi+8]
cmp rcx, rdx
jz short loc_1400
movsd xmm0, cs:qword_20D8
mov rax, rcx
nop dword ptr [rax+rax+00h]
loc_13B0:
pxor xmm1, xmm1
add rax, 4
cvtsi2sd xmm1, dword ptr [rax-4]
mulsd xmm0, xmm1
cmp rax, rdx
jnz short... | double func0(long long *a1)
{
long long v1; // rdx
double v2; // xmm0_8
long long v3; // rax
long long v4; // rdx
v1 = a1[1];
if ( *a1 == v1 )
{
v2 = 1.0;
}
else
{
v2 = 1.0;
v3 = *a1;
do
{
v3 += 4LL;
v2 = v2 * (double)*(int *)(v3 - 4);
}
while ( v3 != v1 );
... | func0:
ENDBR64
MOV RCX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RCX,RDX
JZ 0x00101400
MOVSD XMM0,qword ptr [0x001020d8]
MOV RAX,RCX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013b0:
PXOR XMM1,XMM1
ADD RAX,0x4
CVTSI2SD XMM1,dword ptr [RAX + -0x4]
MULSD XMM0,XMM1
CMP RAX,RDX
JNZ 0x001013b0
LAB_001013c6:
SUB RDX,RCX
SA... | /* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
int *piVar1;
ulong uVar2;
double dVar3;
dVar3 = DAT_001020d8;
for (piVar1 = *(int **)param_1; piVar1 != *(int **)(param_1 + 8); piVar1 = piVar1 + 1) {
dVar3 = dVar3 * (double)*piVar1;
}
uVar2 = (long)*(int ... |
391 | func0 |
#include <vector>
#include <cassert>
| double func0(const std::vector<int>& numbers) {
double total = 1;
for (int x : numbers) {
total *= x;
}
return total / numbers.size();
}
| int main() {
assert(func0({8, 2, 3, -1, 7}) == -67.2);
assert(func0({-10, -20, -30}) == -2000.0);
assert(func0({19, 15, 18}) == 1710.0);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
cmp %rdx,%rcx
je 1580 <_Z5func0RKSt6vectorIiSaIiEE+0x70>
movsd 0xbd8(%rip),%xmm0
mov %rcx,%rax
nopl 0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
add $0x4,%rax
cvtsi2sdl -0x4(%rax),%xmm1
mulsd %xmm1,%xmm0
cmp ... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rcx, [rdi]
mov rdx, [rdi+8]
cmp rcx, rdx
jz short loc_1570
movsd xmm0, cs:qword_20E0
mov rax, rcx
nop dword ptr [rax+rax+00h]
loc_1520:
pxor xmm1, xmm1
add rax, 4
cvtsi2sd xmm1, dword ptr [rax-4]
mulsd xmm0, xmm1
cmp rdx, rax
jnz short... | double func0(long long *a1)
{
long long v1; // rdx
double v2; // xmm0_8
long long v3; // rax
long long v4; // rdx
v1 = a1[1];
if ( *a1 == v1 )
{
v2 = 1.0;
}
else
{
v2 = 1.0;
v3 = *a1;
do
{
v3 += 4LL;
v2 = v2 * (double)*(int *)(v3 - 4);
}
while ( v1 != v3 );
... | func0:
ENDBR64
MOV RCX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RCX,RDX
JZ 0x00101570
MOVSD XMM0,qword ptr [0x001020e0]
MOV RAX,RCX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101520:
PXOR XMM1,XMM1
ADD RAX,0x4
CVTSI2SD XMM1,dword ptr [RAX + -0x4]
MULSD XMM0,XMM1
CMP RDX,RAX
JNZ 0x00101520
LAB_00101536:
SUB RDX,RCX
SA... | /* func0(std::vector<int, std::allocator<int> > const&) */
double func0(vector *param_1)
{
int *piVar1;
ulong uVar2;
double dVar3;
dVar3 = DAT_001020e0;
for (piVar1 = *(int **)param_1; piVar1 != *(int **)(param_1 + 8); piVar1 = piVar1 + 1) {
dVar3 = dVar3 * (double)*piVar1;
}
uVar2 = (long)*(int ... |
392 | func0 |
#include <iostream>
#include <bitset>
#include <assert.h>
| std::string func0(int n) {
return std::bitset<32>(n).to_string().substr(std::bitset<32>(n).to_string().find("1"));
}
| int main() {
assert(func0(8) == "1000");
assert(func0(18) == "10010");
assert(func0(7) == "111");
return 0;
}
| O0 | cpp | func0[abi:cxx11](int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x7c(%rbp),%eax
movslq %eax,%rdx
lea -0x70(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 15ea <_ZNSt6bi... | _Z5func0B5cxx11i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_7C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_7C]
movsxd rdx, eax
lea rax, [rbp+var_70]
mov rsi, rdx
mov rdi, rax
call _ZNSt6bits... | long long func0[abi:cxx11](long long a1, int a2)
{
long long v2; // rax
_BYTE v4[8]; // [rsp+10h] [rbp-70h] BYREF
_BYTE v5[8]; // [rsp+18h] [rbp-68h] BYREF
_BYTE v6[32]; // [rsp+20h] [rbp-60h] BYREF
_BYTE v7[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+68h] [rbp-18h]
v8 = __readfsqwo... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV dword ptr [RBP + -0x7c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x7c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x70]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101834
LEA RA... | /* func0[abi:cxx11](int) */
ulong func0_abi_cxx11_(int param_1)
{
int in_ESI;
int4 in_register_0000003c;
long in_FS_OFFSET;
bitset<32ul> local_78 [8];
bitset<32ul> local_70 [8];
string local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::bitset<32u... |
393 | func0 |
#include <iostream>
#include <bitset>
#include <assert.h>
| std::string func0(int n) {
return std::bitset<32>(n).to_string().substr(std::bitset<32>(n).to_string().find("1"));
}
| int main() {
assert(func0(8) == "1000");
assert(func0(18) == "10010");
assert(func0(7) == "111");
return 0;
}
| O1 | cpp | func0[abi:cxx11](int):
endbr64
push %r12
push %rbp
push %rbx
sub $0x70,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %esi,%ebp
mov %rbp,0x8(%rsp)
lea 0x20(%rsp),%rsi
lea 0x30(%rsp),%rax
mov %rax,0x20(%rsp)
movq $0x0,0x28(%rsp)
movb $0x0,0x30(%rsp)
lea... | _Z5func0B5cxx11i:
endbr64
push r12
push rbp
push rbx
sub rsp, 70h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+88h+var_20], rax
xor eax, eax
mov ebp, esi
mov [rsp+88h+var_80], rbp
lea rsi, [rsp+88h+var_68]
lea rax, [rsp+88h+var_58]
mov [rsp+88h+var_68], rax
mov [rsp+88h+var... | _QWORD * func0[abi:cxx11](_QWORD *a1, unsigned int a2)
{
unsigned long long v3; // rax
size_t v4; // rbp
void *v5; // rdi
_BYTE *v6; // r12
size_t v7; // rbp
size_t v8; // rax
long long v10; // [rsp+8h] [rbp-80h] BYREF
long long v11; // [rsp+10h] [rbp-78h] BYREF
size_t v12; // [rsp+18h] [rbp-70h] BYRE... | func0[abi:cxx11]:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV EBP,ESI
MOV qword ptr [RSP + 0x8],RBP
LEA RSI,[RSP + 0x20]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],0x0
MOV byte ptr [RSP + 0x30]... | /* func0[abi:cxx11](int) */
ulong * func0_abi_cxx11_(int param_1)
{
ulong uVar1;
int8 uVar2;
ulong *__dest;
ulong in_RSI;
int4 in_register_0000003c;
ulong *puVar3;
int *__src;
long in_FS_OFFSET;
ulong local_80;
ulong local_78;
ulong local_70;
int *local_68;
ulong local_60;
int local_58;
... |
394 | func0 |
#include <iostream>
#include <bitset>
#include <assert.h>
| std::string func0(int n) {
return std::bitset<32>(n).to_string().substr(std::bitset<32>(n).to_string().find("1"));
}
| int main() {
assert(func0(8) == "1000");
assert(func0(18) == "10010");
assert(func0(7) == "111");
return 0;
}
| O2 | cpp | func0[abi:cxx11](int):
endbr64
push %r14
mov $0x30,%r8d
mov $0x20,%ecx
xor %edx,%edx
push %r13
mov %esi,%r13d
xor %esi,%esi
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x60,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rbx
lea 0x10(%rsp),%rdi... | _Z5func0B5cxx11i:
endbr64
push r15
mov r8d, 30h ; '0'
mov ecx, 20h ; ' '
xor edx, edx
push r14
push r13
push r12
mov r12, rdi
push rbp
mov ebp, esi
xor esi, esi
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rax, [rsp+0A8h+... | long long * func0[abi:cxx11](long long *a1, unsigned int a2)
{
unsigned long long v5; // rcx
unsigned long long v6; // rax
unsigned long long v7; // rcx
unsigned long long v11; // rax
char *v12; // rbp
void *v13; // rdi
size_t v14; // rbx
char *v15; // rbp
long long v18; // rax
size_t v19; // [rsp+1... | func0[abi:cxx11]:
ENDBR64
PUSH R15
MOV R8D,0x30
MOV ECX,0x20
XOR EDX,EDX
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOV EBP,ESI
XOR ESI,ESI
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x20]
LEA R14,[RSP + 0x30]
MOV qword ptr [RSP + 0x28],0x0
MOV RDI,R... | /* func0[abi:cxx11](int) */
ulong * func0_abi_cxx11_(int param_1,int param_2,int param_3,int param_4,
int param_5,int param_6,int param_7,int param_8,
int8 param_9,int8 param_10,int8 param_11,
int8 param_12,int8 param_13,int8 param_14,
... |
395 | func0 |
#include <iostream>
#include <bitset>
#include <assert.h>
| std::string func0(int n) {
return std::bitset<32>(n).to_string().substr(std::bitset<32>(n).to_string().find("1"));
}
| int main() {
assert(func0(8) == "1000");
assert(func0(18) == "10010");
assert(func0(7) == "111");
return 0;
}
| O3 | cpp | func0[abi:cxx11](int):
endbr64
push %r14
mov $0x30,%r8d
mov $0x20,%ecx
xor %edx,%edx
push %r13
mov %esi,%r13d
xor %esi,%esi
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x60,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rbx
lea 0x10(%rsp),%rdi... | _Z5func0B5cxx11i:
endbr64
push r15
mov r8d, 30h ; '0'
mov ecx, 20h ; ' '
xor edx, edx
push r14
push r13
push r12
mov r12, rdi
push rbp
mov ebp, esi
xor esi, esi
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rax, [rsp+0A8h+... | long long * func0[abi:cxx11](long long *a1, unsigned int a2)
{
unsigned long long v5; // rcx
unsigned long long v6; // rax
unsigned long long v7; // rcx
unsigned long long v11; // rax
char *v12; // rbp
void *v13; // rdi
size_t v14; // rbx
char *v15; // rbp
long long v18; // rax
size_t v19; // [rsp+1... | func0[abi:cxx11]:
ENDBR64
PUSH R15
MOV R8D,0x30
MOV ECX,0x20
XOR EDX,EDX
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
MOV EBP,ESI
XOR ESI,ESI
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x20]
LEA R14,[RSP + 0x30]
MOV qword ptr [RSP + 0x28],0x0
MOV RDI,R... | /* func0[abi:cxx11](int) */
ulong * func0_abi_cxx11_(int param_1,int param_2,int param_3,int param_4,
int param_5,int param_6,int param_7,int param_8,
int8 param_9,int8 param_10,int8 param_11,
int8 param_12,int8 param_13,int8 param_14,
... |
396 | func0 |
#include <cassert>
#include <string>
#include <algorithm>
| int func0(int num) {
for (int i = num + 1; ; ++i) {
std::string numstr = std::to_string(i);
std::string revnumstr = numstr;
std::reverse(revnumstr.begin(), revnumstr.end());
if (numstr == revnumstr) {
return i;
}
}
}
| int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x70,%rsp
mov %edi,-0x74(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x74(%rbp),%eax
add $0x1,%eax
mov %eax,-0x64(%rbp)
lea -0x60(%rbp),%rax
mov -0x64(%rbp),%edx
mov %edx,%esi
mov %rax,%... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 70h
mov [rbp+var_74], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_74]
add eax, 1
mov [rbp+var_64], eax
loc_1313:
lea rax, [rbp+var_60]
mov edx, [rbp+var_64]
mov esi, ... | long long func0(int a1)
{
unsigned int v1; // r12d
long long v2; // rbx
long long v3; // rax
int v4; // ebx
int i; // [rsp+1Ch] [rbp-64h]
_BYTE v7[32]; // [rsp+20h] [rbp-60h] BYREF
_BYTE v8[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v9; // [rsp+68h] [rbp-18h]
v9 = __readfsqword(0x28u);
f... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x70
MOV dword ptr [RBP + -0x74],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOV dword ptr [RBP + -0x64],EAX
LAB_00101313:
LEA RAX,[RBP + -0x60]
MOV EDX,dword ptr [RBP + -0x64]
MOV E... | /* func0(int) */
int func0(int param_1)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int unaff_R12D;
long in_FS_OFFSET;
int local_6c;
string local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_6c = param_1 + 1;
while( true ... |
397 | func0 |
#include <cassert>
#include <string>
#include <algorithm>
| int func0(int num) {
for (int i = num + 1; ; ++i) {
std::string numstr = std::to_string(i);
std::string revnumstr = numstr;
std::reverse(revnumstr.begin(), revnumstr.end());
if (numstr == revnumstr) {
return i;
}
}
}
| int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x1(%rdi),%ebx
mov %rsp,%rbp
jmp 12b4 <_Z5func0i+0x8b>
mov 0x20(%rsp),%rdx
mov %rdx,%rax
add 0x28(%rsp),%rax
cmp %rax,%rdx
je 127e <_Z5func0i+0x55>
sub $0x1,%rax
cmp... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 138h
mov rax, fs:28h
mov [rsp+168h+var_40], rax
xor eax, eax
lea r15d, [rdi+1]
mov r12, 3330323031303030h
mov r13, 3730363035303430h
jmp loc_1552
loc_128E:
mov ebx, 1
loc_1293:
lea ... | long long func0(int a1)
{
int i; // r15d
unsigned int v2; // ebx
char *v3; // r14
int v4; // ebp
char v5; // bp
void *v6; // rbp
size_t v7; // rbx
char *v8; // rdx
char *v9; // rax
char v10; // cl
unsigned int v11; // r14d
unsigned int v12; // ebp
unsigned int v13; // eax
unsigned int v14; ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x138
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
LEA R15D,[RDI + 0x1]
MOV R12,0x3330323031303030
MOV R13,0x3730363035303430
JMP 0x00101552
LAB_0010128e:
MOV EBX,0x1
LAB_00101293:
LEA RDI,[RSP + 0x10]
LEA RAX,[RSP +... | /* func0(int) */
uint func0(int param_1)
{
int uVar1;
byte bVar2;
long *__src;
ulong *puVar3;
uint uVar4;
int iVar5;
ulong *puVar6;
uint uVar7;
uint uVar8;
ulong *puVar9;
ulong uVar10;
uint uVar11;
char cVar12;
ulong uVar13;
byte bVar14;
char *pcVar15;
uint uVar16;
long in_FS_OFFSE... |
398 | func0 |
#include <cassert>
#include <string>
#include <algorithm>
| int func0(int num) {
for (int i = num + 1; ; ++i) {
std::string numstr = std::to_string(i);
std::string revnumstr = numstr;
std::reverse(revnumstr.begin(), revnumstr.end());
if (numstr == revnumstr) {
return i;
}
}
}
| int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O2 | cpp | func0(int):
endbr64
push %r15
push %r14
push %r13
push %r12
lea 0x1(%rdi),%r12d
push %rbp
lea 0xd2a(%rip),%rbp
push %rbx
sub $0x78,%rsp
mov 0x2cc4(%rip),%r14
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%rax
lea 0x20(%rsp),%r15
mov %rax,0x8(%rsp)
lea 0x... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
lea ebx, [rdi+1]
sub rsp, 158h
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
lea rax, [rsp+188h+s1]
lea r13, [rsp+188h+var_148]
mov [rsp+188h+var_178], rax
lea rax, [rsp+188h+s2]
lea ... | long long func0(int a1)
{
int v1; // ebx
unsigned int v2; // ebp
unsigned int v3; // r14d
int v4; // esi
unsigned int v5; // r15d
long long v6; // rsi
long long v7; // rax
__int8 *v8; // rbp
unsigned long long v9; // rdx
unsigned int v10; // eax
unsigned int v11; // esi
long long v12; // rax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA EBX,[RDI + 0x1]
SUB RSP,0x158
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x30]
LEA R13,[RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
LEA RAX,[RSP + 0x50]
LEA R12,[RSP + 0x60]
MOV qword ptr [RSP + 0x18],RAX... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
uint func0(int param_1)
{
uint uVar1;
int uVar2;
size_t *psVar3;
uint uVar4;
int iVar5;
size_t *psVar6;
size_t *psVar7;
uint uVar8;
size_t *psVar9;
size_t *psVar10;
size_t __n;
uint uVar11;
... |
399 | func0 |
#include <cassert>
#include <string>
#include <algorithm>
| int func0(int num) {
for (int i = num + 1; ; ++i) {
std::string numstr = std::to_string(i);
std::string revnumstr = numstr;
std::reverse(revnumstr.begin(), revnumstr.end());
if (numstr == revnumstr) {
return i;
}
}
}
| int main() {
assert(func0(99) == 101);
assert(func0(1221) == 1331);
assert(func0(120) == 121);
return 0;
}
| O3 | cpp | func0(int):
endbr64
push %r15
push %r14
push %r13
lea 0x1(%rdi),%r13d
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov 0x2aeb(%rip),%r14
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%rax
lea 0x20(%rsp),%r15
mov %rax,(%rsp)
lea 0x18(%rsp),%rax
lea 0x50(%... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
lea ebx, [rdi+1]
sub rsp, 158h
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
lea rax, [rsp+188h+s1]
lea r13, [rsp+188h+var_148]
mov [rsp+188h+var_178], rax
lea rax, [rsp+188h+s2]
lea ... | long long func0(int a1)
{
int v1; // ebx
unsigned int v2; // ebp
unsigned int v3; // r14d
int v4; // esi
unsigned int v5; // r15d
long long v6; // rsi
long long v7; // rax
__int8 *v8; // rbp
unsigned long long v9; // rdx
unsigned int v10; // eax
unsigned int v11; // esi
long long v12; // rax
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
LEA EBX,[RDI + 0x1]
SUB RSP,0x158
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x30]
LEA R13,[RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
LEA RAX,[RSP + 0x50]
LEA R12,[RSP + 0x60]
MOV qword ptr [RSP + 0x18],RAX... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
uint func0(int param_1)
{
uint uVar1;
int uVar2;
size_t *psVar3;
uint uVar4;
int iVar5;
size_t *psVar6;
size_t *psVar7;
uint uVar8;
size_t *psVar9;
size_t *psVar10;
size_t __n;
uint uVar11;
... |
400 | func0 | #include <cassert>
#include <vector>
using namespace std;
| int func0(std::vector<int> arr, int n, int k) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// The original Python code uses '==' instead of '=',
// so no swap is performed.
}
}
}
... | int main() {
assert(func0({12, 3, 5, 7, 19}, 5, 2) == 3);
assert(func0({17, 24, 8, 23}, 4, 3) == 8);
assert(func0({16, 21, 25, 36, 4}, 5, 4) == 36);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
movl $0x0,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jge 12a3 <_Z5func0St6vectorIiSaIiEEii+0x7a>
movl ... | _Z5func0St6vectorIiSaIiEEii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov [rbp+var_18], 0
jmp short loc_12BB
loc_1269:
mov [rbp+var_14], 0
jmp short loc_12A9
loc_1272:
mov eax, [rbp+var_14]
movsxd ... | long long func0(long long a1, int a2, int a3)
{
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < a2 - i - 1; ++j )
{
std::vector<int>::operator[](a1, j);
std::vector<int>::operator[](a1, j + 1);
}
}
return *(unsigned int *)st... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001012bb
LAB_00101269:
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001012a9
LAB_00101272:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,E... | /* func0(std::vector<int, std::allocator<int> >, int, int) */
int4 func0(vector param_1,int param_2,int param_3)
{
int4 *puVar1;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int4 local_20;
int4 local_1c;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_... |
401 | func0 | #include <cassert>
#include <vector>
using namespace std;
| int func0(std::vector<int> arr, int n, int k) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// The original Python code uses '==' instead of '=',
// so no swap is performed.
}
}
}
... | int main() {
assert(func0({12, 3, 5, 7, 19}, 5, 2) == 3);
assert(func0({17, 24, 8, 23}, 4, 3) == 8);
assert(func0({16, 21, 25, 36, 4}, 5, 4) == 36);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int, int):
endbr64
test %esi,%esi
jle 1233 <_Z5func0St6vectorIiSaIiEEii+0x2a>
sub $0x1,%esi
mov %esi,%ecx
test %esi,%esi
jle 122b <_Z5func0St6vectorIiSaIiEEii+0x22>
mov $0x0,%eax
add $0x1,%eax
cmp %ecx,%eax
jne 121f <_Z5func0St6vectorIiSaIiEEii+0... | _Z5func0St6vectorIiSaIiEEii:
endbr64
test esi, esi
jle short loc_1235
lea ecx, [rsi-1]
loc_1214:
lea esi, [rcx+1]
mov eax, 0
cmp esi, 1
jle short loc_122D
loc_1221:
add eax, 1
cmp eax, ecx
jnz short loc_1221
sub ecx, 1
jmp short loc_1214
loc_122D:
sub ecx, 1
cmp ec... | long long func0(_QWORD *a1, int a2, int a3)
{
int v3; // ecx
int v4; // eax
if ( a2 > 0 )
{
v3 = a2 - 1;
do
{
while ( 1 )
{
v4 = 0;
if ( v3 + 1 <= 1 )
break;
do
++v4;
while ( v4 != v3 );
--v3;
}
--v3;
}
whi... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101235
LEA ECX,[RSI + -0x1]
LAB_00101214:
LEA ESI,[RCX + 0x1]
MOV EAX,0x0
CMP ESI,0x1
JLE 0x0010122d
LAB_00101221:
ADD EAX,0x1
CMP EAX,ECX
JNZ 0x00101221
SUB ECX,0x1
JMP 0x00101214
LAB_0010122d:
SUB ECX,0x1
CMP ECX,-0x1
JNZ 0x00101214
LAB_00101235:
LEA EAX,[RDX + -0x1]
CDQE
MOV RDX,q... | /* func0(std::vector<int, std::allocator<int> >, int, int) */
int4 func0(vector param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int4 in_register_0000003c;
if (0 < param_2) {
iVar2 = param_2 + -1;
do {
for (; iVar1 = 0, 1 < iVar2 + 1; iVar2 = iVar2 + -1) {
do {
iVar1... |
402 | func0 | #include <cassert>
#include <vector>
using namespace std;
| int func0(std::vector<int> arr, int n, int k) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// The original Python code uses '==' instead of '=',
// so no swap is performed.
}
}
}
... | int main() {
assert(func0({12, 3, 5, 7, 19}, 5, 2) == 3);
assert(func0({17, 24, 8, 23}, 4, 3) == 8);
assert(func0({16, 21, 25, 36, 4}, 5, 4) == 36);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int, int):
endbr64
mov (%rdi),%rax
sub $0x1,%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0St6vectorIiSaIiEEii:
endbr64
mov rax, [rdi]
sub edx, 1
movsxd rdx, edx
mov eax, [rax+rdx*4]
retn | long long func0(_QWORD *a1, long long a2, int a3)
{
return *(unsigned int *)(*a1 + 4LL * (a3 - 1));
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
SUB EDX,0x1
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
RET | /* func0(std::vector<int, std::allocator<int> >, int, int) */
int4 func0(vector param_1,int param_2,int param_3)
{
int4 in_register_0000003c;
return *(int4 *)(*(long *)CONCAT44(in_register_0000003c,param_1) + (long)(param_3 + -1) * 4)
;
} |
403 | func0 | #include <cassert>
#include <vector>
using namespace std;
| int func0(std::vector<int> arr, int n, int k) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// The original Python code uses '==' instead of '=',
// so no swap is performed.
}
}
}
... | int main() {
assert(func0({12, 3, 5, 7, 19}, 5, 2) == 3);
assert(func0({17, 24, 8, 23}, 4, 3) == 8);
assert(func0({16, 21, 25, 36, 4}, 5, 4) == 36);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int, int):
endbr64
mov (%rdi),%rax
sub $0x1,%edx
movslq %edx,%rdx
mov (%rax,%rdx,4),%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0St6vectorIiSaIiEEii:
endbr64
mov rax, [rdi]
sub edx, 1
movsxd rdx, edx
mov eax, [rax+rdx*4]
retn | long long func0(_QWORD *a1, long long a2, int a3)
{
return *(unsigned int *)(*a1 + 4LL * (a3 - 1));
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
SUB EDX,0x1
MOVSXD RDX,EDX
MOV EAX,dword ptr [RAX + RDX*0x4]
RET | /* func0(std::vector<int, std::allocator<int> >, int, int) */
int4 func0(vector param_1,int param_2,int param_3)
{
int4 in_register_0000003c;
return *(int4 *)(*(long *)CONCAT44(in_register_0000003c,param_1) + (long)(param_3 + -1) * 4)
;
} |
404 | func0 |
#include <iostream>
#include <string>
#include <cctype>
#include <vector>
#include <sstream>
#include <assert.h>
| std::string func0(const std::string& word) {
std::istringstream ss(word);
std::string token;
std::string result;
while (std::getline(ss, token, '_')) {
if (!token.empty()) {
token[0] = std::toupper(token[0]);
result += token;
}
}
return result;
... | int main() {
assert(func0("python_program") == "PythonProgram");
assert(func0("python_language") == "PythonLanguage");
assert(func0("programming_language") == "ProgrammingLanguage");
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x1c8,%rsp
mov %rdi,-0x1c8(%rbp)
mov %rsi,-0x1d0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x1d0(%rbp),%rcx
lea -0x1a0(%rbp),... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 1C8h
mov [rbp+var_1C8], rdi
mov [rbp+var_1D0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rcx, [rbp+var_1D0]
lea rax, [rbp+var_1A0]
mov edx, 8
mov... | long long func0(long long a1, long long a2)
{
char *v2; // rax
char v3; // bl
_QWORD *v4; // rax
_BYTE v6[32]; // [rsp+10h] [rbp-1C0h] BYREF
_BYTE v7[392]; // [rsp+30h] [rbp-1A0h] BYREF
unsigned long long v8; // [rsp+1B8h] [rbp-18h]
v8 = __readfsqword(0x28u);
std::istringstream::basic_istringstream(v7... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x1c8
MOV qword ptr [RBP + -0x1c8],RDI
MOV qword ptr [RBP + -0x1d0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RCX,qword ptr [RBP + -0x1d0]
LEA RAX,[RBP + -0x1a0]
MOV EDX,0x8
MOV RSI,RCX
MOV RDI,RAX
LAB_001024cf:
CALL 0x00102330
L... | /* func0(std::string const&) */
string * func0(string *param_1)
{
char cVar1;
bool bVar2;
int iVar3;
char *pcVar4;
int *puVar5;
istream *piVar6;
string *in_RSI;
long in_FS_OFFSET;
string local_1c8 [32];
istringstream local_1a8 [392];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);... |
405 | func0 |
#include <iostream>
#include <string>
#include <cctype>
#include <vector>
#include <sstream>
#include <assert.h>
| std::string func0(const std::string& word) {
std::istringstream ss(word);
std::string token;
std::string result;
while (std::getline(ss, token, '_')) {
if (!token.empty()) {
token[0] = std::toupper(token[0]);
result += token;
}
}
return result;
... | int main() {
assert(func0("python_program") == "PythonProgram");
assert(func0("python_language") == "PythonLanguage");
assert(func0("programming_language") == "ProgrammingLanguage");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1b8,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov %fs:0x28,%rax
mov %rax,0x1a8(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r14
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1B0h
mov rbp, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+1D8h+var_30], rax
xor eax, eax
lea r14, [rsp+1D8h+var_1B8]
lea rdi, [rsp+1D8h+var_140]; thi... | long long func0(long long a1, long long *a2)
{
long long v2; // rdx
long long v3; // rsi
_BYTE *v4; // r14
_QWORD *v5; // rax
void *v7; // [rsp+0h] [rbp-1D8h] BYREF
unsigned long long v8; // [rsp+8h] [rbp-1D0h]
_QWORD v9[2]; // [rsp+10h] [rbp-1C8h] BYREF
int *v10; // [rsp+20h] [rbp-1B8h] BYREF
long l... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1b0
MOV RBP,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1a8],RAX
XOR EAX,EAX
LEA R14,[RSP + 0x20]
LEA RDI,[RSP + 0x98]
CALL 0x00102190
LEA RAX,[0x104b88]
MOV qword ptr [RSP + 0x98],RAX
MOV qword ptr [RSP + 0x170],0x0
MOV byte p... | /* func0(std::string const&) */
string * func0(string *param_1)
{
char *pcVar1;
int8 uVar2;
int iVar3;
int8 uVar4;
int8 uVar5;
istream *piVar6;
int8 *in_RSI;
long in_FS_OFFSET;
char *local_1d8;
ulong local_1d0;
char local_1c8;
int7 uStack_1c7;
long local_1b8 [2];
char local_1a8 [56];
loc... |
406 | func0 |
#include <iostream>
#include <string>
#include <cctype>
#include <vector>
#include <sstream>
#include <assert.h>
| std::string func0(const std::string& word) {
std::istringstream ss(word);
std::string token;
std::string result;
while (std::getline(ss, token, '_')) {
if (!token.empty()) {
token[0] = std::toupper(token[0]);
result += token;
}
}
return result;
... | int main() {
assert(func0("python_program") == "PythonProgram");
assert(func0("python_language") == "PythonLanguage");
assert(func0("programming_language") == "ProgrammingLanguage");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x1d8,%rsp
mov %fs:0x28,%rax
mov %rax,0x1c8(%rsp)
xor %eax,%eax
lea 0xb8(%rsp),%r14
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
mov r14, rsi
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 1D8h
mov rax, fs:28h
mov [rsp+208h+var_40], rax
xor eax, eax
lea rax, [rsp+208h+var_150]
lea rbx, [rsp+208h+v... | long long func0(long long a1, long long a2)
{
_BYTE *v3; // r15
char *v4; // rbp
_QWORD *v5; // rax
_QWORD *v6; // rax
_QWORD *v8; // rdi
char *v9; // [rsp+18h] [rbp-1F0h] BYREF
void *v10; // [rsp+20h] [rbp-1E8h] BYREF
unsigned long long v11; // [rsp+28h] [rbp-1E0h]
_QWORD v12[2]; // [rsp+30h] [rbp-1... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x1d8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1c8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0xb8]
LEA RBX,[RSP + 0x40]
MOV RDI,RAX
MOV qword ptr [RSP],RAX
CALL 0x00102190
MOV R13,qword ptr [0x00104c70]
XOR EDX,EDX
XOR ... | /* func0(std::string const&) */
string * func0(string *param_1)
{
int *__src;
ulong __n;
int8 uVar1;
int iVar2;
istream *piVar3;
int8 uVar4;
int8 *in_RSI;
long in_FS_OFFSET;
ulong local_1f0;
char *local_1e8;
ulong local_1e0;
char local_1d8;
int7 uStack_1d7;
int8 local_1c8 [2];
char local... |
407 | func0 |
#include <iostream>
#include <string>
#include <cctype>
#include <vector>
#include <sstream>
#include <assert.h>
| std::string func0(const std::string& word) {
std::istringstream ss(word);
std::string token;
std::string result;
while (std::getline(ss, token, '_')) {
if (!token.empty()) {
token[0] = std::toupper(token[0]);
result += token;
}
}
return result;
... | int main() {
assert(func0("python_program") == "PythonProgram");
assert(func0("python_language") == "PythonLanguage");
assert(func0("programming_language") == "ProgrammingLanguage");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x1e8,%rsp
mov %fs:0x28,%rax
mov %rax,0x1d8(%rsp)
xor %eax,%eax
lea 0xc8(%rsp),%r15
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
mov r14, rsi
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 1D8h
mov rax, fs:28h
mov [rsp+208h+var_40], rax
xor eax, eax
lea rax, [rsp+208h+var_150]
lea rbx, [rsp+208h+v... | long long func0(long long a1, long long a2)
{
_BYTE *v3; // r15
char *v4; // rbp
_QWORD *v5; // rax
_QWORD *v6; // rax
_QWORD *v8; // rdi
char *v9; // [rsp+18h] [rbp-1F0h] BYREF
void *v10; // [rsp+20h] [rbp-1E8h] BYREF
unsigned long long v11; // [rsp+28h] [rbp-1E0h]
_QWORD v12[2]; // [rsp+30h] [rbp-1... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x1d8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1c8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0xb8]
LEA RBX,[RSP + 0x40]
MOV RDI,RAX
MOV qword ptr [RSP],RAX
CALL 0x00102190
MOV R13,qword ptr [0x00104c70]
XOR EDX,EDX
XOR ... | /* func0(std::string const&) */
string * func0(string *param_1)
{
int *__src;
ulong __n;
int8 uVar1;
int iVar2;
istream *piVar3;
int8 uVar4;
int8 *in_RSI;
long in_FS_OFFSET;
ulong local_1f0;
char *local_1e8;
ulong local_1e0;
char local_1d8;
int7 uStack_1d7;
int8 local_1c8 [2];
char local... |
408 | func0 |
#include <iostream>
#include <cassert>
| int func0(int n, int m) {
if (m >= n || n == 0)
return 0;
if (m == 0)
return 1;
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x10,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x14(%rbp),%eax
jge 11ac <_Z5func0ii+0x23>
cmpl $0x0,-0x14(%rbp)
jne 11b3 <_Z5func0ii+0x2a>
mov $0x0,%eax
jmp 11ff <_Z5func0ii+0x7... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 10h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jge short loc_116C
cmp [rbp+var_14], 0
jnz short loc_1173
loc_116C:
mov eax, 0
jmp short loc_11BF
loc_1173... | long long func0(int a1, int a2)
{
int v3; // ebx
if ( a2 >= a1 || !a1 )
return 0LL;
if ( !a2 )
return 1LL;
v3 = func0(a1 - 1, a2 - 1) * (a1 - a2);
return v3 + (a2 + 1) * (unsigned int)func0(a1 - 1, a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x0010116c
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00101173
LAB_0010116c:
MOV EAX,0x0
JMP 0x001011bf
LAB_00101173:
CMP dwor... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if ((param_2 < param_1) && (param_1 != 0)) {
if (param_2 == 0) {
iVar1 = 1;
}
else {
iVar1 = func0(param_1 + -1,param_2 + -1);
iVar2 = func0(param_1 + -1,param_2);
iVar1 = iVar2 * (param_2 + 1... |
409 | func0 |
#include <iostream>
#include <cassert>
| int func0(int n, int m) {
if (m >= n || n == 0)
return 0;
if (m == 0)
return 1;
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
cmp %edi,%esi
jge 11dd <_Z5func0ii+0x54>
push %r12
push %rbp
push %rbx
mov %esi,%ebx
test %edi,%edi
je 11d6 <_Z5func0ii+0x4d>
mov $0x1,%eax
test %esi,%esi
jne 11a9 <_Z5func0ii+0x20>
pop %rbx
pop %rbp
pop %r12
retq
mov %edi,%r12d
sub %esi,%r12d
lea ... | _Z5func0ii:
endbr64
cmp esi, edi
jge short loc_119C
push r12
push rbp
push rbx
mov ebx, esi
test edi, edi
jz short loc_1195
mov eax, 1
test esi, esi
jnz short loc_1169
loc_1164:
pop rbx
pop rbp
pop r12
retn
loc_1169:
mov r12d, edi
sub r12d, esi
lea ebp, [r... | long long func0(int a1, int a2)
{
long long result; // rax
int v3; // r12d
if ( a2 >= a1 )
return 0LL;
if ( !a1 )
return 0LL;
result = 1LL;
if ( a2 )
{
v3 = func0(a1 - 1, a2 - 1) * (a1 - a2);
return (unsigned int)func0(a1 - 1, a2) * (a2 + 1) + v3;
}
return result;
} | func0:
ENDBR64
CMP ESI,EDI
JGE 0x0010119c
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
TEST EDI,EDI
JZ 0x00101195
MOV EAX,0x1
TEST ESI,ESI
JNZ 0x00101169
LAB_00101164:
POP RBX
POP RBP
POP R12
RET
LAB_00101169:
MOV R12D,EDI
SUB R12D,ESI
LEA EBP,[RDI + -0x1]
LEA ESI,[RSI + -0x1]
MOV EDI,EBP
CALL 0x00101149
IMUL R12D,EAX
MOV ES... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
if (param_2 < param_1) {
if (param_1 == 0) {
iVar1 = 0;
}
else {
iVar1 = 1;
if (param_2 != 0) {
iVar1 = func0(param_1 + -1,param_2 + -1);
iVar2 = func0(param_1 + -1,param_2);
... |
410 | func0 |
#include <iostream>
#include <cassert>
| int func0(int n, int m) {
if (m >= n || n == 0)
return 0;
if (m == 0)
return 1;
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %edi,%edi
je 1300 <_Z5func0ii+0x80>
mov %edi,%ebx
mov %esi,%r13d
cmp %edi,%esi
jge 1300 <_Z5func0ii+0x80>
test %esi,%esi
je 1308 <_Z5func0ii+0x88>
lea 0x1(%rsi),%eax
lea ... | _Z5func0ii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
cmp edi, esi
jle short loc_1280
mov ebx, edi
test edi, edi
jz short loc_1280
mov r14d, esi
test esi, esi
jz short loc_1288
lea eax, [rsi-1]
lea r12d, [rsi+1]
mov r15d,... | long long func0(int a1, int a2)
{
int v2; // ebx
int v3; // r15d
unsigned int v4; // r13d
int v5; // ebp
int v6; // ebp
if ( a1 > a2 && (v2 = a1) != 0 )
{
if ( a2 )
{
v3 = 1;
v4 = 0;
do
{
v5 = v2--;
v6 = v3 * func0(v2, a2 - 1) * (v5 - a2);
v3 *= a2... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
CMP EDI,ESI
JLE 0x00101280
MOV EBX,EDI
TEST EDI,EDI
JZ 0x00101280
MOV R14D,ESI
TEST ESI,ESI
JZ 0x00101288
LEA EAX,[RSI + -0x1]
LEA R12D,[RSI + 0x1]
MOV R15D,0x1
XOR R13D,R13D
MOV dword ptr [RSP + 0xc],EAX
NOP word ptr [RAX + RAX*0x1]
LAB_... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if ((param_2 < param_1) && (param_1 != 0)) {
if (param_2 == 0) {
iVar3 = 1;
}
else {
iVar4 = 1;
iVar3 = 0;
do {
iVar2 = param_1 + -1;
iVar1 = func0(iV... |
411 | func0 |
#include <iostream>
#include <cassert>
| int func0(int n, int m) {
if (m >= n || n == 0)
return 0;
if (m == 0)
return 1;
return ((n - m) * func0(n - 1, m - 1) + (m + 1) * func0(n - 1, m));
}
| int main() {
assert(func0(3, 1) == 4);
assert(func0(4, 1) == 11);
assert(func0(5, 3) == 26);
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
test %edi,%edi
je 1300 <_Z5func0ii+0x80>
mov %edi,%ebx
mov %esi,%r13d
cmp %edi,%esi
jge 1300 <_Z5func0ii+0x80>
test %esi,%esi
je 1308 <_Z5func0ii+0x88>
lea 0x1(%rsi),%eax
lea ... | _Z5func0ii_constprop_1:
xor edx, edx
cmp edi, 1
jle short loc_1221
mov eax, 1
nop dword ptr [rax+00h]
loc_1210:
sub edi, 1
mov ecx, edi
imul ecx, eax
add eax, eax
add edx, ecx
cmp edi, 1
jnz short loc_1210
loc_1221:
mov eax, edx
retn | long long func0(int a1)
{
unsigned int v1; // edx
int v2; // eax
int v3; // ecx
v1 = 0;
if ( a1 > 1 )
{
v2 = 1;
do
{
--a1;
v3 = v2 * a1;
v2 *= 2;
v1 += v3;
}
while ( a1 != 1 );
}
return v1;
} | func0:
XOR EDX,EDX
CMP EDI,0x1
JLE 0x00101221
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101210:
SUB EDI,0x1
MOV ECX,EDI
IMUL ECX,EAX
ADD EAX,EAX
ADD EDX,ECX
CMP EDI,0x1
JNZ 0x00101210
LAB_00101221:
MOV EAX,EDX
RET | /* func0(int, int) [clone .constprop.1] */
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 0;
if (1 < param_1) {
iVar1 = 1;
do {
param_1 = param_1 + -1;
iVar2 = param_1 * iVar1;
iVar1 = iVar1 * 2;
iVar3 = iVar3 + iVar2;
} while (param_1 !=... |
412 | func0 | #include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::vector<std::string>> func0(std::vector<std::vector<std::string>> input_list) {
for (auto &sublist : input_list) {
std::sort(sublist.begin(), sublist.end());
}
return input_list;
}
| int main() {
assert((func0({{"green", "orange"}, {"black", "white"}, {"white", "black", "orange"}}) == std::vector<std::vector<std::string>>{{"green", "orange"}, {"black", "white"}, {"black", "orange", "white"}}));
assert((func0({{" red ", "green"}, {"blue ", " black"}, {" orange", "brown"}}) == std::vector<s... | O0 | cpp | func0(std::vector<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::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, s... | _Z5func0St6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_50]
mov [rbp+var_28], ... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
long long v5; // [rsp+18h] [rbp-38h] BYREF
_QWORD v6[2]; // [rsp+20h] [rbp-30h] BYREF
long long v7; // [rsp+30h] [rbp-20h]
unsigned long long v8; // [rsp+38h] [rbp-18h]
v8 = __readfsqword(0x28u);
v6[1] = a2;
v5 =... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001038a6
MO... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > >) */
vector<std::vector<std::string,std::allocator<std::string>>,std::allocator<std::vector<std::string,std::allocator<std::string>>>>
* func0(vector param_1)
{
... |
413 | func0 | #include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::vector<std::string>> func0(std::vector<std::vector<std::string>> input_list) {
for (auto &sublist : input_list) {
std::sort(sublist.begin(), sublist.end());
}
return input_list;
}
| int main() {
assert((func0({{"green", "orange"}, {"black", "white"}, {"white", "black", "orange"}}) == std::vector<std::vector<std::string>>{{"green", "orange"}, {"black", "white"}, {"black", "orange", "white"}}));
assert((func0({{" red ", "green"}, {"blue ", " black"}, {" orange", "brown"}}) == std::vector<s... | O1 | cpp | func0(std::vector<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::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, s... | _Z5func0St6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdi
mov r14, rsi
mov r12, [rsi]
mov r15, [rsi+8]
cmp r15, r12
jnz short loc_13C7
loc_1... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
_QWORD *v2; // r12
_QWORD *v3; // r15
long long v5; // rbp
long long v6; // r13
int v7; // eax
unsigned long long v8; // rax
long long v9; // rbx
v2 = (_QWORD *)*a2;
v3 = (_QWORD *)a2[1];
if ( v3 != (_QWORD *)*a2 )
{
do
{
v5 = v2[1];
v6... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV R14,RSI
MOV R12,qword ptr [RSI]
MOV R15,qword ptr [RSI + 0x8]
CMP R15,R12
JNZ 0x001013c7
LAB_0010136f:
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RCX],RAX
MOV RAX,qword ptr [R14 ... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > >) */
int8 * func0(vector param_1)
{
long *plVar1;
long lVar2;
uint uVar3;
int8 in_RCX;
_Iter_less_iter extraout_EDX;
ulong uVar4;
long lVar5;
int8 ... |
414 | func0 | #include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::vector<std::string>> func0(std::vector<std::vector<std::string>> input_list) {
for (auto &sublist : input_list) {
std::sort(sublist.begin(), sublist.end());
}
return input_list;
}
| int main() {
assert((func0({{"green", "orange"}, {"black", "white"}, {"white", "black", "orange"}}) == std::vector<std::vector<std::string>>{{"green", "orange"}, {"black", "white"}, {"black", "orange", "white"}}));
assert((func0({{" red ", "green"}, {"blue ", " black"}, {" orange", "brown"}}) == std::vector<s... | O2 | cpp | func0(std::vector<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::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, s... | _Z5func0St6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EE:
endbr64
push r15
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
sub rsp, 18h
movdqu xmm0, xmmword ptr [rsi]
mov [rsp+48h+var_40], rdi
movhlps xmm1, xmm0
movq r12, xmm0
movq r13, xmm... | __m128 * func0(__m128 *a1, const __m128i *a2, double a3, __m128 a4)
{
__m128 v4; // xmm0
unsigned long long v5; // xmm1_8
_QWORD *v6; // r12
long long v7; // rbp
long long v8; // r15
long long v9; // rdx
unsigned long long v10; // rax
long long v11; // rbx
long long v12; // rdi
long long v13; // rax... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOVDQU XMM0,xmmword ptr [RSI]
MOV qword ptr [RSP + 0x8],RDI
MOVHLPS XMM1,XMM0
MOVQ R12,XMM0
MOVQ R13,XMM1
CMP R13,R12
JZ 0x0010395f
LAB_001038e0:
MOV RBP,qword ptr [R12 + 0x8]
MOV R15,qword ptr [R12]
CMP R15,RBP
JZ 0x00103951
... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > >) */
int8 *
func0(int8 *param_1,int (*param_2) [16],int8 param_3,int8 param_4)
{
long lVar1;
int8 uVar2;
ulong uVar3;
_Iter_less_iter extraout_EDX;
long ... |
415 | func0 | #include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
| std::vector<std::vector<std::string>> func0(std::vector<std::vector<std::string>> input_list) {
for (auto &sublist : input_list) {
std::sort(sublist.begin(), sublist.end());
}
return input_list;
}
| int main() {
assert((func0({{"green", "orange"}, {"black", "white"}, {"white", "black", "orange"}}) == std::vector<std::vector<std::string>>{{"green", "orange"}, {"black", "white"}, {"black", "orange", "white"}}));
assert((func0({{" red ", "green"}, {"blue ", " black"}, {" orange", "brown"}}) == std::vector<s... | O3 | cpp | func0(std::vector<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::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, s... | _Z5func0St6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EE:
endbr64
push r15
push r14
mov r14, rsi
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 78h
movdqu xmm0, xmmword ptr [rsi]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, ea... | __m128 * func0(__m128 *a1, const __m128i *a2, double a3, __m128 a4)
{
const __m128i *v4; // r14
__m128 *v5; // r13
__m128 v6; // xmm0
unsigned long long v7; // xmm1_8
_QWORD *v8; // r13
_QWORD *v9; // r14
long long v10; // rax
long long v11; // rbp
long long v12; // rcx
long long v13; // rbx
unsig... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOVDQU XMM0,xmmword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOVHLPS XMM1,XMM0
MOVQ R12,XMM0
MOVQ RBX,XMM1
CMP RBX,R12
JZ 0x00103d47
MOV qword ptr [RSP + 0x30],RDI
MOV R13,R1... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > >) */
int8 * func0(int8 *param_1,int (*param_2) [16])
{
long **pplVar1;
long *plVar2;
int8 uVar3;
long *plVar4;
uint uVar5;
ulong uVar6;
long lVar7;
... |
416 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<bool>& lst) {
return std::accumulate(lst.begin(), lst.end(), 0);
}
| int main() {
assert(func0({true, false, true}) == 2);
assert(func0({false, false}) == 0);
assert(func0({true, true, true}) == 3);
return 0;
}
| O0 | cpp | func0(std::vector<bool, std::allocator<bool> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 19ba <_ZNKSt6vectorIbSaIbEE3endEv>
mov %rax,-0x20(%rbp)
mov %rdx,-0x18(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1952 <... | _Z5func0RKSt6vectorIbSaIbEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNKSt6vectorIbSaIbEE3endEv; std::vector<bool>::end(void)
mov [rbp+var_20], rax
mov [rbp+var_18], rdx
mov rax, [rbp+var_28]
mov rdi, rax
call ... | long long func0(long long a1)
{
long long v1; // rdx
long long v2; // rax
long long v3; // rdx
long long v5; // [rsp+10h] [rbp-20h]
long long v6; // [rsp+18h] [rbp-18h]
v5 = std::vector<bool>::end(a1);
v6 = v1;
v2 = std::vector<bool>::begin(a1);
return std::accumulate<std::_Bit_const_iterator,int>(v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101acc
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101a64
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0... | /* func0(std::vector<bool, std::allocator<bool> > const&) */
void func0(vector *param_1)
{
int auVar1 [16];
int auVar2 [16];
auVar1 = std::vector<bool,std::allocator<bool>>::end((vector<bool,std::allocator<bool>> *)param_1)
;
auVar2 = std::vector<bool,std::allocator<bool>>::begin
((v... |
417 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<bool>& lst) {
return std::accumulate(lst.begin(), lst.end(), 0);
}
| int main() {
assert(func0({true, false, true}) == 2);
assert(func0({false, false}) == 0);
assert(func0({true, true, true}) == 3);
return 0;
}
| O1 | cpp | func0(std::vector<bool, std::allocator<bool> > const&):
endbr64
mov 0x18(%rdi),%r8d
mov 0x10(%rdi),%r9
mov (%rdi),%rax
test %r8d,%r8d
jne 11e2 <_Z5func0RKSt6vectorIbSaIbEE+0x19>
cmp %r9,%rax
je 11f3 <_Z5func0RKSt6vectorIbSaIbEE+0x2a>
mov (%rax),%edx
and $0x1,%edx
mov $0x1,%ecx
mov $0x1,... | _Z5func0RKSt6vectorIbSaIbEE:
endbr64
mov r9d, [rdi+18h]
mov r8, [rdi+10h]
mov rdx, [rdi]
mov ecx, 0
mov esi, 0
mov edi, 1
jmp short loc_1201
loc_11E9:
mov rax, rdi
shl rax, cl
and rax, [rdx]
cmp rax, 1
sbb esi, 0FFFFFFFFh
cmp ecx, 3Fh ; '?'
jz short loc_120E
add ... | long long func0(long long a1)
{
_QWORD *v1; // rdx
int v2; // ecx
unsigned int v3; // esi
v1 = *(_QWORD **)a1;
v2 = 0;
v3 = 0;
while ( *(_QWORD **)(a1 + 16) != v1 || *(_DWORD *)(a1 + 24) != v2 )
{
v3 -= ((*v1 & (1LL << v2)) == 0) - 1;
if ( v2 == 63 )
{
++v1;
v2 = 0;
}
e... | func0:
ENDBR64
MOV R9D,dword ptr [RDI + 0x18]
MOV R8,qword ptr [RDI + 0x10]
MOV RDX,qword ptr [RDI]
MOV ECX,0x0
MOV ESI,0x0
MOV EDI,0x1
JMP 0x00101201
LAB_001011e9:
MOV RAX,RDI
SHL RAX,CL
AND RAX,qword ptr [RDX]
CMP RAX,0x1
SBB ESI,-0x1
CMP ECX,0x3f
JZ 0x0010120e
ADD ECX,0x1
LAB_00101201:
CMP R8,RDX
JNZ 0x001011e9
CMP ... | /* func0(std::vector<bool, std::allocator<bool> > const&) */
int func0(vector *param_1)
{
int iVar1;
ulong *puVar2;
int iVar3;
puVar2 = *(ulong **)param_1;
iVar1 = 0;
iVar3 = 0;
while ((*(ulong **)(param_1 + 0x10) != puVar2 || (*(int *)(param_1 + 0x18) != iVar1))) {
iVar3 = (iVar3 + 1) - (uint)((... |
418 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<bool>& lst) {
return std::accumulate(lst.begin(), lst.end(), 0);
}
| int main() {
assert(func0({true, false, true}) == 2);
assert(func0({false, false}) == 0);
assert(func0({true, true, true}) == 3);
return 0;
}
| O2 | cpp | func0(std::vector<bool, std::allocator<bool> > const&):
endbr64
mov 0x10(%rdi),%r9
mov (%rdi),%rax
mov 0x18(%rdi),%esi
cmp %r9,%rax
jne 1467 <_Z5func0RKSt6vectorIbSaIbEE+0x17>
test %esi,%esi
je 14c0 <_Z5func0RKSt6vectorIbSaIbEE+0x70>
mov (%rax),%r8d
mov $0x1,%ecx
mov $0x1,%edi
and $0x1,... | _Z5func0RKSt6vectorIbSaIbEE:
endbr64
mov r9d, [rdi+18h]
mov r8, [rdi+10h]
mov rdx, [rdi]
test r9d, r9d
setz r10b
cmp rdx, r8
jnz short loc_1340
test r10b, r10b
jnz short loc_1390
loc_1340:
xor ecx, ecx
xor esi, esi
mov edi, 1
nop dword ptr [rax+00000000h]
loc_1350:
mov ... | long long func0(long long a1)
{
int v1; // r9d
_QWORD *v2; // r8
_QWORD *v3; // rdx
int v4; // ecx
unsigned int v5; // esi
bool v6; // al
v1 = *(_DWORD *)(a1 + 24);
v2 = *(_QWORD **)(a1 + 16);
v3 = *(_QWORD **)a1;
if ( *(_QWORD **)a1 == v2 && !v1 )
return 0LL;
v4 = 0;
v5 = 0;
do
{
... | func0:
ENDBR64
MOV R9D,dword ptr [RDI + 0x18]
MOV R8,qword ptr [RDI + 0x10]
MOV RDX,qword ptr [RDI]
TEST R9D,R9D
SETZ R10B
CMP RDX,R8
JNZ 0x00101340
TEST R10B,R10B
JNZ 0x00101390
LAB_00101340:
XOR ECX,ECX
XOR ESI,ESI
MOV EDI,0x1
NOP dword ptr [RAX]
LAB_00101350:
MOV RAX,RDI
SHL RAX,CL
AND RAX,qword ptr [RDX]
CMP RAX,0x... | /* func0(std::vector<bool, std::allocator<bool> > const&) */
int func0(vector *param_1)
{
int iVar1;
bool bVar2;
int iVar3;
ulong *puVar4;
int iVar5;
iVar1 = *(int *)(param_1 + 0x18);
puVar4 = *(ulong **)param_1;
if ((puVar4 == *(ulong **)(param_1 + 0x10)) && (iVar1 == 0)) {
return 0;
}
iVa... |
419 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<bool>& lst) {
return std::accumulate(lst.begin(), lst.end(), 0);
}
| int main() {
assert(func0({true, false, true}) == 2);
assert(func0({false, false}) == 0);
assert(func0({true, true, true}) == 3);
return 0;
}
| O3 | cpp | func0(std::vector<bool, std::allocator<bool> > const&):
endbr64
mov 0x18(%rdi),%r9d
mov 0x10(%rdi),%r10
mov (%rdi),%rax
test %r9d,%r9d
sete %dil
cmp %r10,%rax
sete %dl
jne 14e3 <_Z5func0RKSt6vectorIbSaIbEE+0x23>
test %dil,%dil
jne 1548 <_Z5func0RKSt6vectorIbSaIbEE+0x88>
mov (%rax),%r8d
and ... | _Z5func0RKSt6vectorIbSaIbEE:
endbr64
mov r9d, [rdi+18h]
mov r8, [rdi+10h]
mov rdx, [rdi]
test r9d, r9d
setz r10b
xor esi, esi
cmp rdx, r8
jnz short loc_1472
test r10b, r10b
jnz short loc_14BE
loc_1472:
xor ecx, ecx
mov edi, 1
nop dword ptr [rax+00000000h]
loc_1480:
mov ... | long long func0(long long a1)
{
int v1; // r9d
_QWORD *v2; // r8
_QWORD *v3; // rdx
unsigned int v4; // esi
int i; // ecx
long long v6; // rax
v1 = *(_DWORD *)(a1 + 24);
v2 = *(_QWORD **)(a1 + 16);
v3 = *(_QWORD **)a1;
v4 = 0;
if ( *(_QWORD **)a1 != v2 || v1 )
{
for ( i = 0; v1 != i || v3 ... | func0:
ENDBR64
MOV R9D,dword ptr [RDI + 0x18]
MOV R8,qword ptr [RDI + 0x10]
MOV RDX,qword ptr [RDI]
TEST R9D,R9D
SETZ R10B
XOR ESI,ESI
CMP RDX,R8
JNZ 0x00101472
TEST R10B,R10B
JNZ 0x001014be
LAB_00101472:
XOR ECX,ECX
MOV EDI,0x1
NOP dword ptr [RAX]
LAB_00101480:
MOV RAX,RDI
SHL RAX,CL
AND RAX,qword ptr [RDX]
CMP RAX,0x... | /* func0(std::vector<bool, std::allocator<bool> > const&) */
int func0(vector *param_1)
{
int iVar1;
ulong *puVar2;
int iVar3;
ulong *puVar4;
ulong *puVar5;
int iVar6;
iVar1 = *(int *)(param_1 + 0x18);
puVar2 = *(ulong **)(param_1 + 0x10);
iVar6 = 0;
if ((*(ulong **)param_1 != puVar2) || (iVar1... |
420 | func0 |
#include <vector>
#include <tuple>
#include <cassert>
| std::tuple<int, int, int, int, int> func0(std::vector<int> test_list, std::tuple<int, int> test_tup) {
std::tuple<int, int, int, int, int> res(std::get<0>(test_tup), std::get<1>(test_tup), test_list[0], test_list[1], test_list[2]);
return res;
}
| int main() {
assert(func0({5, 6, 7}, {9, 10}) == std::make_tuple(9, 10, 5, 6, 7));
assert(func0({6, 7, 8}, {10, 11}) == std::make_tuple(10, 11, 6, 7, 8));
assert(func0({7, 8, 9}, {11, 12}) == std::make_tuple(11, 12, 7, 8, 9));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, std::tuple<int, int>):
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
sub $0x30,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov -0x40(%... | _Z5func0St6vectorIiSaIiEESt5tupleIJiiEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r13
push r12
push rbx
sub rsp, 20h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov rax, [rbp+var_30]
mov esi, 2
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::ve... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // r14
long long v4; // r13
long long v5; // r12
long long v6; // rbx
long long v7; // rax
v3 = std::vector<int>::operator[](a2, 2LL);
v4 = std::vector<int>::operator[](a2, 1LL);
v5 = std::vector<int>::operator[](a2, 0LL);
v6 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV RAX,qword ptr [RBP + -0x30]
MOV ESI,0x2
MOV RDI,RAX
CALL 0x001018c6
MOV R14,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV ESI,0x1
MOV RDI,RAX... | /* func0(std::vector<int, std::allocator<int> >, std::tuple<int, int>) */
tuple<int,int,int,int,int> * func0(vector param_1,tuple param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
type *ptVar4;
type *ptVar5;
tuple *in_RDX;
int4 in_register_00000034;
vector<int,std::allocator<int>> *this;
int4 in_reg... |
421 | func0 |
#include <vector>
#include <tuple>
#include <cassert>
| std::tuple<int, int, int, int, int> func0(std::vector<int> test_list, std::tuple<int, int> test_tup) {
std::tuple<int, int, int, int, int> res(std::get<0>(test_tup), std::get<1>(test_tup), test_list[0], test_list[1], test_list[2]);
return res;
}
| int main() {
assert(func0({5, 6, 7}, {9, 10}) == std::make_tuple(9, 10, 5, 6, 7));
assert(func0({6, 7, 8}, {10, 11}) == std::make_tuple(10, 11, 6, 7, 8));
assert(func0({7, 8, 9}, {11, 12}) == std::make_tuple(11, 12, 7, 8, 9));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, std::tuple<int, int>):
endbr64
mov %rdi,%rax
mov (%rsi),%rcx
mov 0x8(%rcx),%esi
mov %esi,(%rdi)
mov 0x4(%rcx),%esi
mov %esi,0x4(%rdi)
mov (%rcx),%ecx
mov %ecx,0x8(%rdi)
mov (%rdx),%ecx
mov %ecx,0xc(%rdi)
mov 0x4(%rdx),%edx
mov %edx,0x10(%... | _Z5func0St6vectorIiSaIiEESt5tupleIJiiEE:
endbr64
mov rax, rdi
mov rcx, [rsi]
mov esi, [rcx+8]
mov [rdi], esi
mov esi, [rcx+4]
mov [rdi+4], esi
mov ecx, [rcx]
mov [rdi+8], ecx
mov ecx, [rdx]
mov [rdi+0Ch], ecx
mov edx, [rdx+4]
mov [rdi+10h], edx
retn | _DWORD * func0(_DWORD *a1, long long a2, _DWORD *a3)
{
_DWORD *result; // rax
_DWORD *v4; // rcx
result = a1;
v4 = *(_DWORD **)a2;
*a1 = *(_DWORD *)(*(_QWORD *)a2 + 8LL);
a1[1] = v4[1];
a1[2] = *v4;
a1[3] = *a3;
a1[4] = a3[1];
return result;
} | func0:
ENDBR64
MOV RAX,RDI
MOV RCX,qword ptr [RSI]
MOV ESI,dword ptr [RCX + 0x8]
MOV dword ptr [RDI],ESI
MOV ESI,dword ptr [RCX + 0x4]
MOV dword ptr [RDI + 0x4],ESI
MOV ECX,dword ptr [RCX]
MOV dword ptr [RDI + 0x8],ECX
MOV ECX,dword ptr [RDX]
MOV dword ptr [RDI + 0xc],ECX
MOV EDX,dword ptr [RDX + 0x4]
MOV dword ptr [RD... | /* func0(std::vector<int, std::allocator<int> >, std::tuple<int, int>) */
int8 func0(vector param_1,tuple param_2)
{
int4 *puVar1;
int4 *in_RDX;
int4 in_register_00000034;
int4 in_register_0000003c;
puVar1 = *(int4 **)CONCAT44(in_register_00000034,param_2);
*(int4 *)CONCAT44(in_register_0000003c,param_... |
422 | func0 |
#include <vector>
#include <tuple>
#include <cassert>
| std::tuple<int, int, int, int, int> func0(std::vector<int> test_list, std::tuple<int, int> test_tup) {
std::tuple<int, int, int, int, int> res(std::get<0>(test_tup), std::get<1>(test_tup), test_list[0], test_list[1], test_list[2]);
return res;
}
| int main() {
assert(func0({5, 6, 7}, {9, 10}) == std::make_tuple(9, 10, 5, 6, 7));
assert(func0({6, 7, 8}, {10, 11}) == std::make_tuple(10, 11, 6, 7, 8));
assert(func0({7, 8, 9}, {11, 12}) == std::make_tuple(11, 12, 7, 8, 9));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, std::tuple<int, int>):
endbr64
mov (%rsi),%rcx
mov %rdi,%rax
mov 0x8(%rcx),%esi
mov %esi,(%rdi)
mov 0x4(%rcx),%esi
mov %esi,0x4(%rdi)
mov (%rcx),%ecx
mov %ecx,0x8(%rdi)
mov (%rdx),%ecx
mov %ecx,0xc(%rdi)
mov 0x4(%rdx),%edx
mov %edx,0x10(%... | _Z5func0St6vectorIiSaIiEESt5tupleIJiiEE:
endbr64
mov rcx, [rsi]
mov rax, rdi
mov esi, [rcx+8]
mov [rdi], esi
mov esi, [rcx+4]
mov [rdi+4], esi
mov ecx, [rcx]
mov [rdi+8], ecx
mov ecx, [rdx]
mov [rdi+0Ch], ecx
mov edx, [rdx+4]
mov [rdi+10h], edx
retn | _DWORD * func0(_DWORD *a1, long long a2, _DWORD *a3)
{
_DWORD *v3; // rcx
_DWORD *result; // rax
v3 = *(_DWORD **)a2;
result = a1;
*a1 = *(_DWORD *)(*(_QWORD *)a2 + 8LL);
a1[1] = v3[1];
a1[2] = *v3;
a1[3] = *a3;
a1[4] = a3[1];
return result;
} | func0:
ENDBR64
MOV RCX,qword ptr [RSI]
MOV RAX,RDI
MOV ESI,dword ptr [RCX + 0x8]
MOV dword ptr [RDI],ESI
MOV ESI,dword ptr [RCX + 0x4]
MOV dword ptr [RDI + 0x4],ESI
MOV ECX,dword ptr [RCX]
MOV dword ptr [RDI + 0x8],ECX
MOV ECX,dword ptr [RDX]
MOV dword ptr [RDI + 0xc],ECX
MOV EDX,dword ptr [RDX + 0x4]
MOV dword ptr [RD... | /* func0(std::vector<int, std::allocator<int> >, std::tuple<int, int>) */
int8 func0(vector param_1,tuple param_2)
{
int4 *puVar1;
int4 *in_RDX;
int4 in_register_00000034;
int4 in_register_0000003c;
puVar1 = *(int4 **)CONCAT44(in_register_00000034,param_2);
*(int4 *)CONCAT44(in_register_0000003c,param_... |
423 | func0 |
#include <vector>
#include <tuple>
#include <cassert>
| std::tuple<int, int, int, int, int> func0(std::vector<int> test_list, std::tuple<int, int> test_tup) {
std::tuple<int, int, int, int, int> res(std::get<0>(test_tup), std::get<1>(test_tup), test_list[0], test_list[1], test_list[2]);
return res;
}
| int main() {
assert(func0({5, 6, 7}, {9, 10}) == std::make_tuple(9, 10, 5, 6, 7));
assert(func0({6, 7, 8}, {10, 11}) == std::make_tuple(10, 11, 6, 7, 8));
assert(func0({7, 8, 9}, {11, 12}) == std::make_tuple(11, 12, 7, 8, 9));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, std::tuple<int, int>):
endbr64
mov (%rsi),%rcx
mov %rdi,%rax
mov 0x8(%rcx),%esi
mov %esi,(%rdi)
mov 0x4(%rcx),%esi
mov %esi,0x4(%rdi)
mov (%rcx),%ecx
mov %ecx,0x8(%rdi)
mov (%rdx),%ecx
mov %ecx,0xc(%rdi)
mov 0x4(%rdx),%edx
mov %edx,0x10(%... | _Z5func0St6vectorIiSaIiEESt5tupleIJiiEE:
endbr64
mov rcx, [rsi]
mov rax, rdi
mov esi, [rcx+8]
mov [rdi], esi
mov esi, [rcx+4]
mov [rdi+4], esi
mov ecx, [rcx]
mov [rdi+8], ecx
mov ecx, [rdx]
mov [rdi+0Ch], ecx
mov edx, [rdx+4]
mov [rdi+10h], edx
retn | _DWORD * func0(_DWORD *a1, long long a2, _DWORD *a3)
{
_DWORD *v3; // rcx
_DWORD *result; // rax
v3 = *(_DWORD **)a2;
result = a1;
*a1 = *(_DWORD *)(*(_QWORD *)a2 + 8LL);
a1[1] = v3[1];
a1[2] = *v3;
a1[3] = *a3;
a1[4] = a3[1];
return result;
} | func0:
ENDBR64
MOV RCX,qword ptr [RSI]
MOV RAX,RDI
MOV ESI,dword ptr [RCX + 0x8]
MOV dword ptr [RDI],ESI
MOV ESI,dword ptr [RCX + 0x4]
MOV dword ptr [RDI + 0x4],ESI
MOV ECX,dword ptr [RCX]
MOV dword ptr [RDI + 0x8],ECX
MOV ECX,dword ptr [RDX]
MOV dword ptr [RDI + 0xc],ECX
MOV EDX,dword ptr [RDX + 0x4]
MOV dword ptr [RD... | /* func0(std::vector<int, std::allocator<int> >, std::tuple<int, int>) */
int8 func0(vector param_1,tuple param_2)
{
int4 *puVar1;
int4 *in_RDX;
int4 in_register_00000034;
int4 in_register_0000003c;
puVar1 = *(int4 **)CONCAT44(in_register_00000034,param_2);
*(int4 *)CONCAT44(in_register_0000003c,param_... |
424 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count += 1;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count += 1;
... | int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x18(%rbp),%eax
jg 1200 <_Z5func0ii+0x77>
cmpl $0x9,-0x8(%rbp)
jle 11be <_Z5func0ii+0x35>
cmpl $0xf,-0x8(%... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_C], 0
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
jmp short loc_11BE
loc_1166:
cmp [rbp+var_8], 9
jle short loc_1178
cmp [rbp+var_8], 0Fh
jg short loc_1178
add [rbp+var_C... | long long func0(int a1, int a2)
{
unsigned int v3; // [rsp+Ch] [rbp-Ch]
int i; // [rsp+14h] [rbp-4h]
v3 = 0;
while ( a1 <= a2 )
{
if ( a1 <= 9 || a1 > 15 )
{
if ( a1 > 15 )
{
for ( i = a1; i; i /= 16 )
{
if ( i % 16 > 9 )
++v3;
}
}
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011be
LAB_00101166:
CMP dword ptr [RBP + -0x8],0x9
JLE 0x00101178
CMP dword ptr [RBP + -0x8],0xf
JG 0x00101178
ADD dw... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = param_1; local_10 <= param_2; local_10 = local_10 + 1) {
if ((local_10 < 10) || (0xf < local_10)) {
if (0xf < local_10) {
for (local_c = local_10; local_c... |
425 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count += 1;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count += 1;
... | int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
cmp %esi,%edi
jg 11e4 <_Z5func0ii+0x5b>
lea 0x1(%rsi),%r8d
mov $0x0,%esi
jmp 11a9 <_Z5func0ii+0x20>
cmp $0xf,%edi
jg 11b6 <_Z5func0ii+0x2d>
add $0x1,%edi
cmp %r8d,%edi
je 11e9 <_Z5func0ii+0x60>
lea -0xa(%rdi),%eax
cmp $0x5,%eax
ja 119c <_Z5func0ii+0x13... | _Z5func0ii:
endbr64
cmp edi, esi
jg short loc_11A5
add esi, 1
mov r8d, 0
jmp short loc_1168
loc_115C:
cmp edi, 0Fh
jg short loc_1176
loc_1161:
add edi, 1
cmp edi, esi
jz short loc_11AB
loc_1168:
lea eax, [rdi-0Ah]
cmp eax, 5
ja short loc_115C
add r8d, 1
jmp ... | long long func0(int a1, int a2)
{
int v2; // eax
int v3; // esi
unsigned int v4; // r8d
int v5; // edx
if ( a1 > a2 )
{
return 0;
}
else
{
v3 = a2 + 1;
v4 = 0;
do
{
if ( (unsigned int)(a1 - 10) > 5 )
{
if ( a1 > 15 )
{
v5 = a1;
do
... | func0:
ENDBR64
CMP EDI,ESI
JG 0x001011a5
ADD ESI,0x1
MOV R8D,0x0
JMP 0x00101168
LAB_0010115c:
CMP EDI,0xf
JG 0x00101176
LAB_00101161:
ADD EDI,0x1
CMP EDI,ESI
JZ 0x001011ab
LAB_00101168:
LEA EAX,[RDI + -0xa]
CMP EAX,0x5
JA 0x0010115c
ADD R8D,0x1
JMP 0x00101161
LAB_00101176:
MOV EDX,EDI
LAB_00101178:
MOV ECX,EDX
SAR ECX,... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
if (param_2 < param_1) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
if (param_1 - 10U < 6) {
iVar3 = iVar3 + 1;
}
else {
iVar1 = param_1;
if (0xf < param_1) {
... |
426 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count += 1;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count += 1;
... | int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
cmp %esi,%edi
jg 1218 <_Z5func0ii+0x58>
add $0x1,%esi
xor %r8d,%r8d
jmp 11db <_Z5func0ii+0x1b>
add $0x1,%r8d
add $0x1,%edi
cmp %edi,%esi
je 120d <_Z5func0ii+0x4d>
lea -0xa(%rdi),%eax
cmp $0x5,%eax
jbe 11d0 <_Z5func0ii+0x10>
cmp $0xf,%edi
jle 11d4 <_Z5... | _Z5func0ii:
endbr64
cmp edi, esi
jg short loc_1268
add esi, 1
xor r8d, r8d
jmp short loc_121B
loc_1210:
add r8d, 1
loc_1214:
add edi, 1
cmp edi, esi
jz short loc_1260
loc_121B:
lea eax, [rdi-0Ah]
cmp eax, 5
jbe short loc_1210
cmp edi, 0Fh
jle short loc_1214
mov ... | long long func0(int a1, int a2)
{
int v2; // esi
unsigned int v3; // r8d
int v4; // eax
if ( a1 <= a2 )
{
v2 = a2 + 1;
v3 = 0;
while ( 1 )
{
while ( (unsigned int)(a1 - 10) <= 5 )
{
++v3;
LABEL_4:
if ( ++a1 == v2 )
return v3;
}
if ( a1 <= 15 ... | func0:
ENDBR64
CMP EDI,ESI
JG 0x00101268
ADD ESI,0x1
XOR R8D,R8D
JMP 0x0010121b
LAB_00101210:
ADD R8D,0x1
LAB_00101214:
ADD EDI,0x1
CMP EDI,ESI
JZ 0x00101260
LAB_0010121b:
LEA EAX,[RDI + -0xa]
CMP EAX,0x5
JBE 0x00101210
CMP EDI,0xf
JLE 0x00101214
MOV EAX,EDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101230:
MOV ECX,EAX
SAR EC... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
if (param_1 <= param_2) {
iVar3 = 0;
do {
if (param_1 - 10U < 6) {
iVar3 = iVar3 + 1;
}
else {
iVar1 = param_1;
if (0xf < param_1) {
do {
iVar3... |
427 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int L, int R) {
int count = 0;
for (int i = L; i <= R; i++) {
if (i >= 10 && i <= 15) {
count += 1;
} else if (i > 15) {
int k = i;
while (k != 0) {
if (k % 16 >= 10) {
count += 1;
... | int main() {
assert(func0(10, 15) == 6);
assert(func0(2, 4) == 0);
assert(func0(15, 16) == 1);
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
cmp %esi,%edi
jg 1388 <_Z5func0ii+0x1c8>
cmp $0xf,%edi
jg 1380 <_Z5func0ii+0x1c0>
cmp $0xf,%esi
mov $0xf,%edx
mov $0x1,%eax
cmovle %esi,%edx
lea 0x1(%rdx),%ecx
sub %edi,%ecx
cmp %edx,%edi
cmovg %eax,%ecx
mov %edx,%eax
sub %edi,%eax
cmp $0x5,%eax
jbe ... | _Z5func0ii:
endbr64
mov ecx, edi
mov r8d, esi
xor edi, edi
cmp ecx, esi
jg short loc_11A0
cmp ecx, 0Fh
jg short loc_116B
jmp short loc_11A8
loc_1160:
add edi, 1
loc_1163:
add ecx, 1
loc_1166:
cmp r8d, ecx
jl short loc_11A0
loc_116B:
lea eax, [rcx-0Ah]
cmp eax, ... | long long func0(signed int a1, int a2)
{
unsigned int v3; // edi
signed int v4; // eax
int v6; // edx
unsigned int v7; // r9d
__m128i v8; // xmm2
int v9; // eax
__m128i si128; // xmm7
__m128i v11; // xmm1
__m128i v12; // xmm6
__m128i v13; // xmm5
__m128i v14; // xmm8
__m128i v15; // xmm3
__m1... | func0:
ENDBR64
MOV ECX,EDI
MOV R8D,ESI
XOR EDI,EDI
CMP ECX,ESI
JG 0x001011a0
CMP ECX,0xf
JG 0x0010116b
JMP 0x001011a8
LAB_00101160:
ADD EDI,0x1
LAB_00101163:
ADD ECX,0x1
LAB_00101166:
CMP R8D,ECX
JL 0x001011a0
LAB_0010116b:
LEA EAX,[RCX + -0xa]
CMP EAX,0x5
JBE 0x00101160
MOV EAX,ECX
LAB_00101175:
MOV ESI,EAX
SAR ESI,0x... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int) */
int func0(int param_1,int param_2)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
iVar5 = ... |
428 | func0 | #include <cassert>
#include <vector>
#include <algorithm>
using namespace std;
| vector<int> func0(vector<int> num1, vector<int> num2, vector<int> num3) {
// Sort each input vector
sort(num1.begin(), num1.end());
sort(num2.begin(), num2.end());
sort(num3.begin(), num3.end());
// Merge num1 and num2 into a temporary vector
vector<int> temp;
temp.resize(num1.s... | int main() {
{
vector<int> res = func0(
{25, 24, 15, 4, 5, 29, 110},
{19, 20, 11, 56, 25, 233, 154},
{24, 26, 54, 48}
);
vector<int> expected = {4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233};
assert(res == expecte... | O0 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r14
push %r13
push %r12
push %rbx
sub $0x40,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %rdx,-0x58(%rbp)
mov %rcx,-0x60(... | _Z5func0St6vectorIiSaIiEES1_S1_:
endbr64
push rbp
mov rbp, rsp
push r14
push r13
push r12
push rbx
sub rsp, 40h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov [rbp+var_58], rdx
mov [rbp+var_60], rcx
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov rax, [rbp+... | long long func0(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rbx
long long v5; // rax
long long v6; // rbx
long long v7; // rax
long long v8; // rbx
long long v9; // rax
long long v10; // rbx
long long v11; // rax
long long v12; // r14
long long v13; // r13
long long... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV qword ptr [RBP + -0x58],RDX
MOV qword ptr [RBP + -0x60],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >,
std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1,vector param_2,vector param_3)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
__normal_iterator _Var3;
__normal_ite... |
429 | func0 | #include <cassert>
#include <vector>
#include <algorithm>
using namespace std;
| vector<int> func0(vector<int> num1, vector<int> num2, vector<int> num3) {
// Sort each input vector
sort(num1.begin(), num1.end());
sort(num2.begin(), num2.end());
sort(num3.begin(), num3.end());
// Merge num1 and num2 into a temporary vector
vector<int> temp;
temp.resize(num1.s... | int main() {
{
vector<int> res = func0(
{25, 24, 15, 4, 5, 29, 110},
{19, 20, 11, 56, 25, 233, 154},
{24, 26, 54, 48}
);
vector<int> expected = {4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233};
assert(res == expecte... | O1 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r13
mov %rsi,%rbp
mov %rdx,%r12
mov %rcx,%rbx
mov %fs:0x28,%rax
mov ... | _Z5func0St6vectorIiSaIiEES1_S1_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r13, rdi
mov rbp, rsi
mov r12, rdx
mov rbx, rcx
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov r15, [rsi+8]
mov r14, [rsi]
cmp r14, r1... | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3, _QWORD *a4)
{
long long v6; // r15
long long v7; // r14
int v8; // ecx
unsigned long long v9; // rcx
long long v10; // r15
long long v11; // r14
int v12; // ecx
unsigned long long v13; // rcx
long long v14; // r15
long long v15; // r14
int v16; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R13,RDI
MOV RBP,RSI
MOV R12,RDX
MOV RBX,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV R15,qword ptr [RSI + 0x8]
MOV R14,qword ptr [RSI]
CMP R14,R15
JZ 0x001012be
MOV RAX,R15
SUB RAX,R14
SAR RAX,0x2
MOV... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >,
std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> *
func0(vector param_1,vector param_2,vector param_3,int param_4,int param_5,
int param_6,int8 param_7,int8 param_8,int8 param_9)
{
long lVar1;
... |
430 | func0 | #include <cassert>
#include <vector>
#include <algorithm>
using namespace std;
| vector<int> func0(vector<int> num1, vector<int> num2, vector<int> num3) {
// Sort each input vector
sort(num1.begin(), num1.end());
sort(num2.begin(), num2.end());
sort(num3.begin(), num3.end());
// Merge num1 and num2 into a temporary vector
vector<int> temp;
temp.resize(num1.s... | int main() {
{
vector<int> res = func0(
{25, 24, 15, 4, 5, 29, 110},
{19, 20, 11, 56, 25, 233, 154},
{24, 26, 54, 48}
);
vector<int> expected = {4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233};
assert(res == expecte... | O2 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
mov %rdx,%rbp
push %rbx
mov %rcx,%rbx
sub $0x28,%rsp
mov 0x8(%rsi),%r15
mov ... | _Z5func0St6vectorIiSaIiEES1_S1_:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
mov r12, rsi
push rbp
mov rbp, rdx
push rbx
mov rbx, rcx
sub rsp, 38h
mov r15, [rsi+8]
mov r14, [rsi]
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
cmp r14, r1... | long long * func0(long long *a1, long long *a2, _QWORD *a3, _QWORD *a4)
{
long long v8; // r15
long long v9; // r14
long long v10; // rdx
unsigned long long v11; // rax
long long v12; // r15
long long v13; // r14
long long v14; // rdx
unsigned long long v15; // rax
long long v16; // r15
long long v1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RCX
SUB RSP,0x38
MOV R15,qword ptr [RSI + 0x8]
MOV R14,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CMP R14,R15
JZ 0x00101e9d
MOV RAX,R15
MOV RDX,-0x2
SUB RAX,R14
SA... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >,
std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> *
func0(vector param_1,vector param_2,vector param_3,int param_4,int param_5,
int param_6,int8 param_7,int1 param_8 [16],int8 param_9,
int8 pa... |
431 | func0 | #include <cassert>
#include <vector>
#include <algorithm>
using namespace std;
| vector<int> func0(vector<int> num1, vector<int> num2, vector<int> num3) {
// Sort each input vector
sort(num1.begin(), num1.end());
sort(num2.begin(), num2.end());
sort(num3.begin(), num3.end());
// Merge num1 and num2 into a temporary vector
vector<int> temp;
temp.resize(num1.s... | int main() {
{
vector<int> res = func0(
{25, 24, 15, 4, 5, 29, 110},
{19, 20, 11, 56, 25, 233, 154},
{24, 26, 54, 48}
);
vector<int> expected = {4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233};
assert(res == expecte... | O3 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
mov %rcx,%rbp
push %rbx
sub $0x48,%rsp
mov 0x8(%rsi),%r15
mov ... | _Z5func0St6vectorIiSaIiEES1_S1_:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdx
push rbx
mov rbx, rcx
sub rsp, 48h
mov r15, [rsi+8]
mov r14, [rsi]
mov [rsp+78h+var_70], rdi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
cm... | long long * func0(long long *a1, char **a2, char **a3, char **a4)
{
char *v7; // r15
char *v8; // r14
unsigned long long v9; // rdx
char *v10; // rcx
char *v11; // r13
char *v12; // r9
int v13; // r10d
char *v14; // rsi
int v15; // edx
char *j; // rax
int v17; // esi
int v18; // edx
char *v19;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RCX
SUB RSP,0x48
MOV R15,qword ptr [RSI + 0x8]
MOV R14,qword ptr [RSI]
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
CMP R14,R15
JZ 0x00101e7c
MOV R13,R15
LEA RCX,[... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >,
std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> *
func0(vector param_1,vector param_2,vector param_3,int param_4,int param_5,
int param_6,int8 param_7,int8 param_8,int param_9,int param_10,
... |
432 | func0 |
#include <assert.h>
#include <string>
| int func0(const std::string& s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count++;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jge 141d <_Z5func0RKN... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_1375
loc_134C:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
mo... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_BYTE *)std::string::operator[](a1, i) == 49 )
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101375
LAB_0010134c:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001011d... | /* func0(std::string const&, int) */
int func0(string *param_1,int param_2)
{
char *pcVar1;
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
pcVar1 = (char *)std::string::operator[]((ulong)param_1);
if (*pcVar1 == '1') {
local_10 = loc... |
433 | func0 |
#include <assert.h>
#include <string>
| int func0(const std::string& s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count++;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, int):
endbr64
test %esi,%esi
jle 1218 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x2f>
mov (%rdi),%rax
lea -0x1(%rsi),%edx
lea 0x1(%rax,%rdx,1),%rsi
mov $0x0,%edx
cmpb $0x31,(%rax)
sete... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
test esi, esi
jle short loc_1236
mov rax, [rdi]
movsxd rsi, esi
add rsi, rax
mov edx, 0
loc_121F:
cmp byte ptr [rax], 31h ; '1'
setz cl
movzx ecx, cl
add edx, ecx
add rax, 1
cmp rax, rsi
jnz short loc_1... | long long func0(_QWORD *a1, int a2)
{
_BYTE *v2; // rax
_BYTE *v3; // rsi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = (_BYTE *)*a1;
v3 = (_BYTE *)(*a1 + a2);
v4 = 0;
do
v4 += *v2++ == 49;
while ( v2 != v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101236
MOV RAX,qword ptr [RDI]
MOVSXD RSI,ESI
ADD RSI,RAX
MOV EDX,0x0
LAB_0010121f:
CMP byte ptr [RAX],0x31
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x0010121f
LAB_00101233:
MOV EAX,EDX
RET
LAB_00101236:
MOV EDX,0x0
JMP 0x00101233 | /* func0(std::string const&, int) */
int func0(string *param_1,int param_2)
{
char *pcVar1;
int iVar2;
char *pcVar3;
if (param_2 < 1) {
iVar2 = 0;
}
else {
pcVar1 = *(char **)param_1;
pcVar3 = pcVar1 + param_2;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(*pcVar1 == '1');
pcVa... |
434 | func0 |
#include <assert.h>
#include <string>
| int func0(const std::string& s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count++;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, int):
endbr64
test %esi,%esi
jle 13e0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x40>
mov (%rdi),%rdx
lea -0x1(%rsi),%ecx
xor %r8d,%r8d
lea 0x1(%rdx),%rax
add %rax,%rcx
jmp 13c4 <_... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
test esi, esi
jle short loc_13C0
mov rax, [rdi]
movsxd rsi, esi
xor edx, edx
add rsi, rax
nop dword ptr [rax+rax+00h]
loc_13A8:
xor ecx, ecx
cmp byte ptr [rax], 31h ; '1'
setz cl
add rax, 1
add edx, ecx
c... | long long func0(_QWORD *a1, int a2)
{
_BYTE *v2; // rax
unsigned int v3; // edx
_BYTE *v4; // rsi
int v5; // ecx
if ( a2 <= 0 )
return 0LL;
v2 = (_BYTE *)*a1;
v3 = 0;
v4 = (_BYTE *)(*a1 + a2);
do
{
v5 = *v2++ == 49;
v3 += v5;
}
while ( v2 != v4 );
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013c0
MOV RAX,qword ptr [RDI]
MOVSXD RSI,ESI
XOR EDX,EDX
ADD RSI,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013a8:
XOR ECX,ECX
CMP byte ptr [RAX],0x31
SETZ CL
ADD RAX,0x1
ADD EDX,ECX
CMP RAX,RSI
JNZ 0x001013a8
MOV EAX,EDX
RET
LAB_001013c0:
XOR EDX,EDX
MOV EAX,EDX
RET | /* func0(std::string const&, int) */
int func0(string *param_1,int param_2)
{
char cVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
if (0 < param_2) {
pcVar2 = *(char **)param_1;
iVar3 = 0;
pcVar4 = pcVar2 + param_2;
do {
cVar1 = *pcVar2;
pcVar2 = pcVar2 + 1;
iVar3 = iVar3 ... |
435 | func0 |
#include <assert.h>
#include <string>
| int func0(const std::string& s, int n) {
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count++;
}
}
return count;
}
| int main() {
assert(func0("011001", 6) == 3);
assert(func0("11011", 5) == 4);
assert(func0("1010", 4) == 2);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, int):
endbr64
test %esi,%esi
jle 1658 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x268>
lea -0x1(%rsi),%eax
mov (%rdi),%rcx
cmp $0xe,%eax
jbe 165b <_Z5func0RKNSt7__cxx1112basic_stringIcSt... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
mov edx, esi
test esi, esi
jle loc_15D0
lea eax, [rsi-1]
mov rcx, [rdi]
cmp eax, 0Eh
jbe loc_15D3
shr esi, 4
pxor xmm1, xmm1
pxor xmm5, xmm5
mov rax, rcx
shl rsi, 4
movdqa xmm6, cs:xmmword_20D0
pxor ... | long long func0(const __m128i **a1, int a2)
{
const __m128i *v3; // rcx
__m128i v4; // xmm1
const __m128i *v5; // rax
__m128i si128; // xmm6
const __m128i *v7; // rsi
__m128i v8; // xmm0
__m128i v9; // xmm0
__m128i v10; // xmm3
__m128i v11; // xmm2
__m128i v12; // xmm0
__m128i v13; // xmm3
__m1... | func0:
ENDBR64
MOV EDX,ESI
TEST ESI,ESI
JLE 0x001015d0
LEA EAX,[RSI + -0x1]
MOV RCX,qword ptr [RDI]
CMP EAX,0xe
JBE 0x001015d3
SHR ESI,0x4
PXOR XMM1,XMM1
PXOR XMM5,XMM5
MOV RAX,RCX
SHL RSI,0x4
MOVDQA XMM6,xmmword ptr [0x001020d0]
PXOR XMM4,XMM4
ADD RSI,RCX
NOP
LAB_001013f0:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM3,XMM... | /* func0(std::string const&, int) */
int func0(string *param_1,int param_2)
{
char *pcVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
char *pcVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pc... |
436 | func0 | #include <cassert>
#include <vector>
#include <utility>
using namespace std;
| vector<pair<int,int>> func0(const vector<pair<int,int>> &test_list, int strt_val, int stop_val) {
vector<pair<int,int>> res;
for (const auto &sub : test_list) {
if (sub.first > strt_val) {
res.push_back({strt_val, sub.first});
strt_val = sub.second;
}
if (s... | int main() {
vector<pair<int,int>> result1 = func0({{6, 9}, {15, 34}, {48, 70}}, 2, 100);
vector<pair<int,int>> expected1 = {{2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100}};
assert(result1 == expected1);
vector<pair<int,int>> result2 = func0({{7, 2}, {15, 19}, {38, 50}}, 5, 60);
ve... | O0 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %edx,-0x54(%rbp)
mov %ecx,-0x58(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%ea... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EEii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov [rbp+var_54], edx
mov [rbp+var_58], ecx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
c... | long long func0(long long a1, long long a2, int a3, int a4)
{
int v5; // [rsp+8h] [rbp-58h] BYREF
int v6; // [rsp+Ch] [rbp-54h] BYREF
long long v7; // [rsp+10h] [rbp-50h]
long long v8; // [rsp+18h] [rbp-48h]
long long v9; // [rsp+20h] [rbp-40h] BYREF
_QWORD v10[2]; // [rsp+28h] [rbp-38h] BYREF
_DWORD *v1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV dword ptr [RBP + -0x54],EDX
MOV dword ptr [RBP + -0x58],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00101b96
MO... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, int, int)
*/
vector * func0(vector *param_1,int param_2,int param_3)
{
bool bVar1;
int in_ECX;
int4 in_register_00000034;
long in_FS_OFFSET;
int local_60;
int local_5c;
vector<std::pair<int,int>,std::allocator<s... |
437 | func0 | #include <cassert>
#include <vector>
#include <utility>
using namespace std;
| vector<pair<int,int>> func0(const vector<pair<int,int>> &test_list, int strt_val, int stop_val) {
vector<pair<int,int>> res;
for (const auto &sub : test_list) {
if (sub.first > strt_val) {
res.push_back({strt_val, sub.first});
strt_val = sub.second;
}
if (s... | int main() {
vector<pair<int,int>> result1 = func0({{6, 9}, {15, 34}, {48, 70}}, 2, 100);
vector<pair<int,int>> expected1 = {{2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100}};
assert(result1 == expected1);
vector<pair<int,int>> result2 = func0({{7, 2}, {15, 19}, {38, 50}}, 5, 60);
ve... | O1 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r13
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq ... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EEii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov r13, rdi
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov r... | _QWORD * func0(_QWORD *a1, int **a2, int a3, int a4)
{
int *v4; // rbx
int *v5; // r15
int v8; // eax
int v10; // [rsp+10h] [rbp-48h] BYREF
int v11; // [rsp+14h] [rbp-44h]
unsigned long long v12; // [rsp+18h] [rbp-40h]
v12 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v4 = *a2;
v... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV R13,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBX,qword ptr [RSI]
MOV R15,qword ptr [RSI + 0x8]
CMP R15,RBX
JZ 0... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, int, int)
*/
vector * func0(vector *param_1,int param_2,int param_3)
{
int *piVar1;
int in_ECX;
int *piVar2;
int4 in_register_00000034;
long in_FS_OFFSET;
int local_48;
int local_44;
long local_40;
local_... |
438 | func0 | #include <cassert>
#include <vector>
#include <utility>
using namespace std;
| vector<pair<int,int>> func0(const vector<pair<int,int>> &test_list, int strt_val, int stop_val) {
vector<pair<int,int>> res;
for (const auto &sub : test_list) {
if (sub.first > strt_val) {
res.push_back({strt_val, sub.first});
strt_val = sub.second;
}
if (s... | int main() {
vector<pair<int,int>> result1 = func0({{6, 9}, {15, 34}, {48, 70}}, 2, 100);
vector<pair<int,int>> expected1 = {{2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100}};
assert(result1 == expected1);
vector<pair<int,int>> result2 = func0({{7, 2}, {15, 19}, {38, 50}}, 5, 60);
ve... | O2 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, int, int):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %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 ... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EEii:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov ... | long long func0(long long a1, unsigned int **a2, signed int a3, signed int a4)
{
unsigned int *v4; // rbx
unsigned int *v5; // r14
long long v8; // rsi
long long v9; // rsi
long long v10; // rsi
long long v11; // rsi
_QWORD v13[7]; // [rsp+0h] [rbp-38h] BYREF
v13[1] = __readfsqword(0x28u);
*(_QWORD ... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x10
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
MOV RBX,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
CMP R14,RBX
JZ 0x00101778
MOV EBP,E... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, int, int)
*/
vector * func0(vector *param_1,int param_2,int param_3)
{
int *piVar1;
int8 *puVar2;
int in_ECX;
int *piVar3;
int4 in_register_00000034;
long in_FS_OFFSET;
int8 local_38;
long local_30;
local... |
439 | func0 | #include <cassert>
#include <vector>
#include <utility>
using namespace std;
| vector<pair<int,int>> func0(const vector<pair<int,int>> &test_list, int strt_val, int stop_val) {
vector<pair<int,int>> res;
for (const auto &sub : test_list) {
if (sub.first > strt_val) {
res.push_back({strt_val, sub.first});
strt_val = sub.second;
}
if (s... | int main() {
vector<pair<int,int>> result1 = func0({{6, 9}, {15, 34}, {48, 70}}, 2, 100);
vector<pair<int,int>> expected1 = {{2, 6}, {9, 100}, {9, 15}, {34, 100}, {34, 48}, {70, 100}};
assert(result1 == expected1);
vector<pair<int,int>> result2 = func0({{7, 2}, {15, 19}, {38, 50}}, 5, 60);
ve... | O3 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, int, int):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EEii:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov ... | long long func0(long long a1, unsigned int **a2, signed int a3, signed int a4)
{
unsigned int *v4; // rbx
unsigned int *v5; // r14
long long v8; // rsi
long long v9; // rsi
long long v10; // rsi
long long v11; // rsi
_QWORD v13[7]; // [rsp+0h] [rbp-38h] BYREF
v13[1] = __readfsqword(0x28u);
*(_QWORD ... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x10
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
MOV RBX,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
CMP R14,RBX
JZ 0x00101788
MOV EBP,E... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, int, int)
*/
vector * func0(vector *param_1,int param_2,int param_3)
{
int *piVar1;
int8 *puVar2;
int in_ECX;
int *piVar3;
int4 in_register_00000034;
long in_FS_OFFSET;
int8 local_38;
long local_30;
local... |
440 | func0 |
#include <vector>
#include <set>
#include <iostream>
#include <assert.h>
#include <algorithm>
| std::vector<int> func0(std::vector<std::vector<int>> nestedlist) {
std::set<int> intersection;
for (int i = 0; i < nestedlist.size(); i++) {
std::set<int> tempSet(nestedlist[i].begin(), nestedlist[i].end());
if (i == 0) {
intersection = tempSet;
} else {
... | int main() {
assert((func0({{12, 18, 23, 25, 45}, {7, 12, 18, 24, 28}, {1, 5, 8, 12, 15, 16, 18}}) == std::vector<int>{12, 18}));
assert((func0({{12, 5, 23, 25, 45}, {7, 11, 5, 23, 28}, {1, 5, 8, 18, 23, 16}}) == std::vector<int>{5, 23}));
assert((func0({{2, 3, 4, 1}, {4, 5}, {6, 4, 8}, {4, 5}, {6, 8, 4}... | O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0xc8,%rsp
mov %rdi,-0xe8(%rbp)
mov %rsi,-0xf0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov [rbp+var_E8], rdi
mov [rbp+var_F0], rsi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea rax, [rbp+var_D0]
mov rdi, rax
call _... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rbx
long long v4; // rax
long long v5; // rax
long long v6; // rax
long long v7; // r12
long long v8; // rdx
long long v9; // r13
long long v10; // r15
long long v11; // r14
long long v12; // rbx
long long v13; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RBP + -0xe8],RDI
MOV qword ptr [RBP + -0xf0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xd0]
MOV RDI,RAX
CALL 0x001025e8
MOV dword ptr [RBP + -0xdc],0x0
JMP 0x00... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
iterator iVar3;
insert_iterator iVar4;
_Rb_tree_const_iterator _Var5;
_R... |
441 | func0 |
#include <vector>
#include <set>
#include <iostream>
#include <assert.h>
#include <algorithm>
| std::vector<int> func0(std::vector<std::vector<int>> nestedlist) {
std::set<int> intersection;
for (int i = 0; i < nestedlist.size(); i++) {
std::set<int> tempSet(nestedlist[i].begin(), nestedlist[i].end());
if (i == 0) {
intersection = tempSet;
} else {
... | int main() {
assert((func0({{12, 18, 23, 25, 45}, {7, 12, 18, 24, 28}, {1, 5, 8, 12, 15, 16, 18}}) == std::vector<int>{12, 18}));
assert((func0({{12, 5, 23, 25, 45}, {7, 11, 5, 23, 28}, {1, 5, 8, 18, 23, 16}}) == std::vector<int>{5, 23}));
assert((func0({{2, 3, 4, 1}, {4, 5}, {6, 4, 8}, {4, 5}, {6, 8, 4}... | O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xc8,%rsp
mov %rdi,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0xb8(%rsp)
xor %eax,%eax
movl $0x0,0x28(%rs... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0C8h
mov [rsp+0F8h+var_E0], rdi
mov [rsp+0F8h+var_E8], rsi
mov rax, fs:28h
mov [rsp+0F8h+var_40], rax
xor eax, eax
mov [rsp+0F8h+var_D0], 0
mov [rsp+0F8h+var_C8]... | _QWORD * func0(_QWORD *a1, int **a2, long long a3, int a4, int a5, int a6)
{
int *v6; // rdx
_DWORD *v7; // rbx
long long insert_hint_unique_pos; // rax
int *v9; // rbp
bool v10; // r12
long long v11; // rax
int *v12; // rbp
int *v13; // rbx
int *v14; // r13
int v15; // r12d
int v16; // eax
long... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x0
LEA RAX,[RSP + 0x28]
MOV qword ptr [RSP + 0... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
_Vector_base<int,std::allocator<int>> * func0(vector param_1)
{
long *plVar1;
int iVar2;
int *piVar3;
_Rb_tree_node_base *p_Var4;
_Rb_tree_node_base *p_Var5;
int4 *puVar6;
int8 u... |
442 | func0 |
#include <vector>
#include <set>
#include <iostream>
#include <assert.h>
#include <algorithm>
| std::vector<int> func0(std::vector<std::vector<int>> nestedlist) {
std::set<int> intersection;
for (int i = 0; i < nestedlist.size(); i++) {
std::set<int> tempSet(nestedlist[i].begin(), nestedlist[i].end());
if (i == 0) {
intersection = tempSet;
} else {
... | int main() {
assert((func0({{12, 18, 23, 25, 45}, {7, 12, 18, 24, 28}, {1, 5, 8, 12, 15, 16, 18}}) == std::vector<int>{12, 18}));
assert((func0({{12, 5, 23, 25, 45}, {7, 11, 5, 23, 28}, {1, 5, 8, 18, 23, 16}}) == std::vector<int>{5, 23}));
assert((func0({{2, 3, 4, 1}, {4, 5}, {6, 4, 8}, {4, 5}, {6, 8, 4}... | O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xd8,%rsp
mov (%rsi),%rdx
mov %rdi,0x28(%rsp)
mov %rsi,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0xc8(%... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0D8h
mov rdx, [rsi]
mov [rsp+108h+var_E8], rdi
mov [rsp+108h+var_F0], rsi
mov rax, fs:28h
mov [rsp+108h+var_40], rax
xor eax, eax
lea rax, [rsp+108h+var_D0]
mov ... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v2; // rdx
unsigned int **v3; // rax
unsigned int *v4; // r15
unsigned int *v5; // rbp
long long v6; // rax
signed int v7; // r13d
long long insert_hint_unique_pos; // rax
int *v9; // rdx
int *v10; // rbx
_QWORD *v11; // rbx
void *v12; // rdi
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xd8
MOV RDX,qword ptr [RSI]
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x38]
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x... | /* WARNING: Removing unreachable block (ram,0x001026f2) */
/* WARNING: Removing unreachable block (ram,0x001026d8) */
/* WARNING: Removing unreachable block (ram,0x001026fc) */
/* WARNING: Removing unreachable block (ram,0x00102760) */
/* WARNING: Removing unreachable block (ram,0x0010277a) */
/* WARNING: Removing unre... |
443 | func0 |
#include <vector>
#include <set>
#include <iostream>
#include <assert.h>
#include <algorithm>
| std::vector<int> func0(std::vector<std::vector<int>> nestedlist) {
std::set<int> intersection;
for (int i = 0; i < nestedlist.size(); i++) {
std::set<int> tempSet(nestedlist[i].begin(), nestedlist[i].end());
if (i == 0) {
intersection = tempSet;
} else {
... | int main() {
assert((func0({{12, 18, 23, 25, 45}, {7, 12, 18, 24, 28}, {1, 5, 8, 12, 15, 16, 18}}) == std::vector<int>{12, 18}));
assert((func0({{12, 5, 23, 25, 45}, {7, 11, 5, 23, 28}, {1, 5, 8, 18, 23, 16}}) == std::vector<int>{5, 23}));
assert((func0({{2, 3, 4, 1}, {4, 5}, {6, 4, 8}, {4, 5}, {6, 8, 4}... | O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xd8,%rsp
mov (%rsi),%rdx
mov %rdi,0x28(%rsp)
mov %rsi,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0xc8(%... | _Z5func0St6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0D8h
mov rdx, [rsi]
mov [rsp+108h+var_F0], rdi
lea r14, [rsp+108h+var_D0]
mov [rsp+108h+var_F8], rsi
mov rax, fs:28h
mov [rsp+108h+var_40], rax
xor eax, eax
mov ... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v2; // rdx
long long v3; // r12
int **v4; // rax
int *v5; // r15
int *v6; // rbp
int v7; // ecx
int *v8; // rbx
int v9; // edx
int *v10; // rax
bool v11; // r12
long long v12; // rax
_QWORD *v13; // rbx
void *v14; // rdi
_QWORD *v15; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xd8
MOV RDX,qword ptr [RSI]
MOV qword ptr [RSP + 0x18],RDI
LEA R14,[RSP + 0x38]
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc8],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >) */
int (*) [16] func0(vector param_1)
{
int8 *puVar1;
int iVar2;
int *piVar3;
bool bVar4;
_Rb_tree_node_base *p_Var5;
_Rb_tree_node_base *p_Var6;
int4 *puVar7;
_Rb_tree_node_base ... |
444 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%edx
mov -0x8(%rbp),%eax
add %edx,%eax
add %eax,%eax
pop %rbp
retq
| _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov edx, [rbp+var_4]
mov eax, [rbp+var_8]
add eax, edx
add eax, eax
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a1 + a2));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
ADD EAX,EAX
POP RBP
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return (param_2 + param_1) * 2;
} |
445 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
add %esi,%edi
lea (%rdi,%rdi,1),%eax
retq
| _Z5func0ii:
endbr64
add edi, esi
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDI*0x1]
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return (param_1 + param_2) * 2;
} |
446 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
add %esi,%edi
lea (%rdi,%rdi,1),%eax
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
add edi, esi
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDI*0x1]
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return (param_1 + param_2) * 2;
} |
447 | func0 |
#include <assert.h>
| int func0(int diameter, int height) {
return 2 * (diameter + height);
}
| int main() {
assert(func0(2, 4) == 12);
assert(func0(1, 2) == 6);
assert(func0(3, 1) == 8);
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
add %esi,%edi
lea (%rdi,%rdi,1),%eax
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
add edi, esi
lea eax, [rdi+rdi]
retn | long long func0(int a1, int a2)
{
return (unsigned int)(2 * (a2 + a1));
} | func0:
ENDBR64
ADD EDI,ESI
LEA EAX,[RDI + RDI*0x1]
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return (param_1 + param_2) * 2;
} |
448 | func0 |
#include <iostream>
#include <string>
#include <cctype>
#include <assert.h>
| bool func0(const std::string& text) {
std::string t = text;
t.erase(0, t.find_first_not_of(' ')); // Strip leading spaces
t.erase(t.find_last_not_of(' ') + 1); // Strip trailing spaces
if (t.empty()) {
return false;
}
if (t[0] == '+' || t[0] == '-') {
t = t.substr(1... | int main() {
assert(func0("python") == false);
assert(func0("1") == true);
assert(func0("12345") == true);
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x88,%rsp
mov %rdi,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x88(%rbp),%rdx
lea -0x60(%rbp),%rax
mov %rdx,%rsi
mov ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_88], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rdx, [rbp+var_88]
lea rax, [rbp+var_60]
mov rsi, rdx
mov rdi, rax
call __ZNSt7... | long long func0(long long a1)
{
long long first_not_of; // rax
long long last_not_of; // rax
unsigned int v3; // ebx
long long v6; // [rsp+18h] [rbp-78h] BYREF
_QWORD v7[2]; // [rsp+20h] [rbp-70h] BYREF
_BYTE v8[32]; // [rsp+30h] [rbp-60h] BYREF
_BYTE v9[40]; // [rsp+50h] [rbp-40h] BYREF
unsigned long ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RBP + -0x88]
LEA RAX,[RBP + -0x60]
MOV RSI,RDX
MOV RDI,RAX
LAB_00102480:
CALL 0x001021e0
LEA RAX,[RBP + -0x60]
MOV EDX,0x0
MOV ESI,0x20
MOV... | /* func0(std::string const&) */
int8 func0(string *param_1)
{
char cVar1;
bool bVar2;
long lVar3;
char *pcVar4;
int8 uVar5;
long in_FS_OFFSET;
int8 local_80;
int8 local_78;
string *local_70;
string local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x2... |
449 | func0 |
#include <iostream>
#include <string>
#include <cctype>
#include <assert.h>
| bool func0(const std::string& text) {
std::string t = text;
t.erase(0, t.find_first_not_of(' ')); // Strip leading spaces
t.erase(t.find_last_not_of(' ') + 1); // Strip trailing spaces
if (t.empty()) {
return false;
}
if (t[0] == '+' || t[0] == '-') {
t = t.substr(1... | int main() {
assert(func0("python") == false);
assert(func0("1") == true);
assert(func0("12345") == true);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r12
push %rbp
push %rbx
sub $0x60,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rax
mov %rax,0x10(%rsp)
mov (%rdi),%r12
mov 0x8(%rdi),%rbp
test %r12,%r1... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+78h+var_20], rax
xor eax, eax
lea rax, [rsp+78h+var_58]
mov [rsp+78h+var_68], rax
mov rbp, [rdi]
mov rbx, [rdi+8]
mov [rsp+78h+var_70], rbx
cmp rb... | long long func0(long long a1)
{
_BYTE *v1; // rbp
size_t v2; // rbx
unsigned long long first_not_of; // rax
long long last_not_of; // rax
void *v5; // rdi
char *v6; // rdx
unsigned int v7; // ebx
_QWORD *v8; // rdi
size_t v9; // rdx
char *v10; // rax
long long v11; // rcx
size_t v12; // rdx
u... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV RBP,qword ptr [RDI]
MOV RBX,qword ptr [RDI + 0x8]
MOV qword ptr [RSP + 0x8],RBX
CMP RBX,0xf
JA 0x001013e2
CMP RBX,0x1
JNZ 0x00101418
MOVZX EAX,byte... | /* func0(std::string const&) */
int8 func0(string *param_1)
{
int *__src;
uint uVar1;
long lVar2;
uint uVar3;
ulong uVar4;
ulong uVar5;
ulong *puVar6;
int8 uVar7;
long in_FS_OFFSET;
ulong local_70;
ulong *local_68;
ulong local_60;
ulong local_58 [2];
ulong *local_48;
int8 local_40;
ulo... |
450 | func0 |
#include <iostream>
#include <string>
#include <cctype>
#include <assert.h>
| bool func0(const std::string& text) {
std::string t = text;
t.erase(0, t.find_first_not_of(' ')); // Strip leading spaces
t.erase(t.find_last_not_of(' ') + 1); // Strip trailing spaces
if (t.empty()) {
return false;
}
if (t[0] == '+' || t[0] == '-') {
t = t.substr(1... | int main() {
assert(func0("python") == false);
assert(func0("1") == true);
assert(func0("12345") == true);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x60,%rsp
mov (%rdi),%r14
mov 0x8(%rdi),%r13
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rbx
mov %r14,%r... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 60h
mov rbx, [rdi+8]
mov r12, [rdi]
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
lea rbp, [rsp+88h+var_70+8]
lea r13, [rsp+88h+var_78]
mo... | long long func0(long long a1)
{
size_t v1; // rbx
__int8 *v2; // r12
__int8 *v3; // rax
unsigned long long first_not_of; // rax
long long last_not_of; // rax
long long v6; // rcx
char *v7; // rbx
char *v8; // rcx
char *v9; // rdx
unsigned int v10; // r12d
__int8 *v12; // rdi
size_t v13; // r12
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x60
MOV RBX,qword ptr [RDI + 0x8]
MOV R12,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x20]
LEA R13,[RSP + 0x10]
MOV qword ptr [RSP + 0x10],RBP
MOV qword ptr [RSP + 0x8],RBX
CMP RBX,0xf
JA 0x00... | /* func0(std::string const&) */
int8 func0(string *param_1)
{
int *__src;
uint uVar1;
long lVar2;
ulong __n;
ulong uVar3;
uint uVar4;
ulong *puVar5;
char cVar6;
int8 uVar7;
long in_FS_OFFSET;
ulong local_80;
ulong *local_78;
ulong local_70;
ulong auStack_68 [2];
ulong *local_58;
int8 l... |
451 | func0 |
#include <iostream>
#include <string>
#include <cctype>
#include <assert.h>
| bool func0(const std::string& text) {
std::string t = text;
t.erase(0, t.find_first_not_of(' ')); // Strip leading spaces
t.erase(t.find_last_not_of(' ') + 1); // Strip trailing spaces
if (t.empty()) {
return false;
}
if (t[0] == '+' || t[0] == '-') {
t = t.substr(1... | int main() {
assert(func0("python") == false);
assert(func0("1") == true);
assert(func0("12345") == true);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x60,%rsp
mov (%rdi),%r14
mov 0x8(%rdi),%r13
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rbx
mov %r14,%r... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 60h
mov rbx, [rdi+8]
mov r12, [rdi]
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
lea rbp, [rsp+88h+var_70+8]
lea r13, [rsp+88h+var_78]
mo... | long long func0(long long a1)
{
size_t v1; // rbx
__int8 *v2; // r12
__int8 *v3; // rax
unsigned long long first_not_of; // rax
unsigned long long v5; // rdx
long long last_not_of; // rax
long long v7; // rcx
char *v8; // rbx
char *v9; // rcx
char *v10; // rdx
unsigned int v11; // r12d
__int8 *... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x60
MOV RBX,qword ptr [RDI + 0x8]
MOV R12,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RBP,[RSP + 0x20]
LEA R13,[RSP + 0x10]
MOV qword ptr [RSP + 0x10],RBP
MOV qword ptr [RSP + 0x8],RBX
CMP RBX,0xf
JA 0x00... | /* func0(std::string const&) */
int8 func0(string *param_1)
{
int *__src;
uint uVar1;
long lVar2;
ulong __n;
ulong uVar3;
uint uVar4;
ulong *puVar5;
char cVar6;
int8 uVar7;
long in_FS_OFFSET;
ulong local_80;
ulong *local_78;
ulong local_70;
ulong auStack_68 [2];
ulong *local_58;
int8 l... |
452 | func0 |
#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <cassert>
#include <sstream>
| std::string func0(const std::vector<std::vector<int>>& test_list) {
std::map<std::string, int> freq_map;
std::vector<std::string> unique_keys;
for(const auto& vec : test_list){
std::ostringstream oss;
oss << "(";
for(size_t i = 0; i < vec.size(); ++i){
oss << vec... | int main(){
std::vector<std::vector<int>> test1 = { {6, 5, 8}, {2, 7}, {6, 5, 8}, {6, 5, 8}, {9}, {2, 7} };
assert(func0(test1) == "[(6, 5, 8, 3), (2, 7, 2), (9, 1)]");
std::vector<std::vector<int>> test2 = { {4, 2, 4}, {7, 1}, {4, 8}, {4, 2, 4}, {9, 2}, {7, 1} };
assert(func0(test2) == "[(4, 2, 4... | O0 | cpp | func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x248,%rsp
mov %rdi,-0x248(%rbp)
mov %rsi,-0x250(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea ... | _Z5func0B5cxx11RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 248h
mov [rbp+var_248], rdi
mov [rbp+var_250], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_1E0]
mov rdi, rax
call _ZNSt3mapINSt7__cxx1112basic_stringIc... | long long func0[abi:cxx11](long long a1, long long a2)
{
unsigned int *v2; // rax
long long v3; // rax
unsigned long long v4; // rax
_DWORD *v5; // rax
long long v6; // rax
long long v7; // rax
long long v8; // rbx
long long v9; // rax
unsigned int *v10; // rax
long long v11; // rax
long long v12... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x248
MOV qword ptr [RBP + -0x248],RDI
MOV qword ptr [RBP + -0x250],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x1e0]
MOV RDI,RAX
CALL 0x001039e4
LEA RAX,[RBP + -0x200]
MOV RDI,RAX
CALL 0x00103a6c
MOV RAX,qw... | /* func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
char cVar1;
bool bVar2;
string *psVar3;
ostream *poVar4;
int *piVar5;
long lVar6;
ulong uVar7;
vector<std::vector... |
453 | func0 |
#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <cassert>
#include <sstream>
| std::string func0(const std::vector<std::vector<int>>& test_list) {
std::map<std::string, int> freq_map;
std::vector<std::string> unique_keys;
for(const auto& vec : test_list){
std::ostringstream oss;
oss << "(";
for(size_t i = 0; i < vec.size(); ++i){
oss << vec... | int main(){
std::vector<std::vector<int>> test1 = { {6, 5, 8}, {2, 7}, {6, 5, 8}, {6, 5, 8}, {9}, {2, 7} };
assert(func0(test1) == "[(6, 5, 8, 3), (2, 7, 2), (9, 1)]");
std::vector<std::vector<int>> test2 = { {4, 2, 4}, {7, 1}, {4, 8}, {4, 2, 4}, {9, 2}, {7, 1} };
assert(func0(test2) == "[(4, 2, 4... | O1 | cpp | func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x228,%rsp
mov %rdi,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x218(%rsp)
xor %eax,%eax
... | _Z5func0B5cxx11RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 248h
mov [rsp+278h+var_260], rdi
mov rax, fs:28h
mov [rsp+278h+var_40], rax
xor eax, eax
mov [rsp+278h+var_200], 0
mov [rsp+278h+var_1F8], 0
lea rax, [r... | long long func0[abi:cxx11](long long a1, long long **a2)
{
long long *v2; // rbp
long long v3; // rdx
unsigned long long v4; // rbx
unsigned long long v5; // r8
long long v6; // rax
long long v7; // rbx
size_t v8; // r13
size_t v9; // r15
size_t v10; // rdx
int v11; // edx
long long v12; // r13
... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x248
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x238],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x0
LEA RAX,[RSP + 0x78]
MOV qword ptr [RSP + 0x88],RAX
MOV qword... | /* func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
long *plVar1;
ulong uVar2;
int8 uVar3;
string *psVar4;
int iVar5;
_Rb_tree_iterator _Var6;
int4 *puVar7;
piecewis... |
454 | func0 |
#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <cassert>
#include <sstream>
| std::string func0(const std::vector<std::vector<int>>& test_list) {
std::map<std::string, int> freq_map;
std::vector<std::string> unique_keys;
for(const auto& vec : test_list){
std::ostringstream oss;
oss << "(";
for(size_t i = 0; i < vec.size(); ++i){
oss << vec... | int main(){
std::vector<std::vector<int>> test1 = { {6, 5, 8}, {2, 7}, {6, 5, 8}, {6, 5, 8}, {9}, {2, 7} };
assert(func0(test1) == "[(6, 5, 8, 3), (2, 7, 2), (9, 1)]");
std::vector<std::vector<int>> test2 = { {4, 2, 4}, {7, 1}, {4, 8}, {4, 2, 4}, {9, 2}, {7, 1} };
assert(func0(test2) == "[(4, 2, 4... | O2 | cpp | func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x288,%rsp
mov (%rsi),%rbx
mov %rdi,0x78(%rsp)
lea 0x100(%rsp),%rbp
mov %fs:0x28,%ra... | _Z5func0B5cxx11RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 298h
mov rbx, [rsi]
movq xmm2, cs:off_6CA0
mov [rsp+2C8h+var_240], rdi
movhps xmm2, cs:off_6CA8
mov rax, fs:28h
mov [rsp+2C8h+var_40], rax
xo... | long long func0[abi:cxx11](long long a1, long long **a2)
{
long long *v2; // rbx
long long *v3; // rax
std::ios_base *v4; // r15
_QWORD *v5; // rdi
__m128i si128; // xmm1
long long v7; // rdx
unsigned long long v8; // rbp
__m128i *v9; // r15
unsigned long long v10; // rax
long long v11; // r8
voi... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x298
MOV RBX,qword ptr [RSI]
MOVQ XMM2,qword ptr [0x00106ca0]
MOV qword ptr [RSP + 0x88],RDI
MOVHPS XMM2,qword ptr [0x00106ca8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x288],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0... | /* func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
long *plVar1;
void *__s2;
tuple *ptVar2;
pointer_____offset_0x18___ puVar3;
pointer_____offset_0x18___ puVar4;
pointe... |
455 | func0 |
#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <cassert>
#include <sstream>
| std::string func0(const std::vector<std::vector<int>>& test_list) {
std::map<std::string, int> freq_map;
std::vector<std::string> unique_keys;
for(const auto& vec : test_list){
std::ostringstream oss;
oss << "(";
for(size_t i = 0; i < vec.size(); ++i){
oss << vec... | int main(){
std::vector<std::vector<int>> test1 = { {6, 5, 8}, {2, 7}, {6, 5, 8}, {6, 5, 8}, {9}, {2, 7} };
assert(func0(test1) == "[(6, 5, 8, 3), (2, 7, 2), (9, 1)]");
std::vector<std::vector<int>> test2 = { {4, 2, 4}, {7, 1}, {4, 8}, {4, 2, 4}, {9, 2}, {7, 1} };
assert(func0(test2) == "[(4, 2, 4... | O3 | cpp | func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x278,%rsp
mov (%rsi),%rbx
mov %rdi,0x68(%rsp)
lea 0xf0(%rsp),%rbp
m... | _Z5func0B5cxx11RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 298h
mov r12, [rsi]
movq xmm2, cs:off_6CA0
mov [rsp+2C8h+var_240], rdi
movhps xmm2, cs:off_6CA8
mov rax, fs:28h
mov [rsp+2C8h+var_40], rax
xo... | long long func0[abi:cxx11](long long a1, char **a2)
{
char *v2; // r12
char *v3; // rax
char *v4; // rbx
std::ios_base *v5; // r15
char *v6; // rdi
__m128i si128; // xmm1
long long v8; // rdx
unsigned long long v9; // rbp
unsigned long long v10; // rax
long long v11; // r8
void *v12; // r13
siz... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x298
MOV R12,qword ptr [RSI]
MOVQ XMM2,qword ptr [0x00106ca0]
MOV qword ptr [RSP + 0x88],RDI
MOVHPS XMM2,qword ptr [0x00106ca8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x288],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0... | /* func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
long *plVar1;
tuple *ptVar2;
int *__src;
void *__s2;
pointer_____offset_0x18___ puVar3;
pointer_____offset_0x18___ pu... |
456 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| bool func0(const std::vector<std::vector<int>>& list1) {
for (const auto& d : list1) {
if (!d.empty()) {
return false;
}
}
return true;
}
| int main() {
assert(func0({{}, {}, {}}) == true);
assert(func0({{1, 2}, {}, {}}) == false);
assert(func0({}) == true);
return 0;
}
| O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,-0x18(%rbp)
mov ... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_38]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EE5be... | long long func0(long long a1)
{
long long v2; // [rsp+18h] [rbp-28h] BYREF
_QWORD v3[2]; // [rsp+20h] [rbp-20h] BYREF
long long v4; // [rsp+30h] [rbp-10h]
unsigned long long v5; // [rsp+38h] [rbp-8h]
v5 = __readfsqword(0x28u);
v3[1] = a1;
v2 = std::vector<std::vector<int>>::begin(a1);
v3[0] = std::vec... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x001018fc
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qwor... | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int8 func0(vector *param_1)
{
char cVar1;
bool bVar2;
int8 uVar3;
long in_FS_OFFSET;
int8 local_30;
int8 local_28;
vector<std::vector<int,std::allocator<int>>,std::allocat... |
457 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| bool func0(const std::vector<std::vector<int>>& list1) {
for (const auto& d : list1) {
if (!d.empty()) {
return false;
}
}
return true;
}
| int main() {
assert(func0({{}, {}, {}}) == true);
assert(func0({{1, 2}, {}, {}}) == false);
assert(func0({}) == true);
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
cmp %rdx,%rax
je 12f1 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x28>
mov (%rax),%rcx
cmp %rcx,0x8(%rax)
jne 12f7 <_Z5func0RKSt6vect... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rax, [rdi]
mov rdx, [rdi+8]
cmp rdx, rax
jz short loc_12B1
loc_1299:
mov rcx, [rax]
cmp [rax+8], rcx
jnz short loc_12B7
add rax, 18h
cmp rdx, rax
jnz short loc_1299
mov eax, 1
retn
loc_12B1:
mov eax, 1
retn
loc_12B7:
mo... | long long func0(long long a1)
{
_QWORD *v1; // rax
_QWORD *v2; // rdx
v1 = *(_QWORD **)a1;
v2 = *(_QWORD **)(a1 + 8);
if ( v2 == *(_QWORD **)a1 )
return 1LL;
while ( v1[1] == *v1 )
{
v1 += 3;
if ( v2 == v1 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RDX,RAX
JZ 0x001012b1
LAB_00101299:
MOV RCX,qword ptr [RAX]
CMP qword ptr [RAX + 0x8],RCX
JNZ 0x001012b7
ADD RAX,0x18
CMP RDX,RAX
JNZ 0x00101299
MOV EAX,0x1
RET
LAB_001012b1:
MOV EAX,0x1
RET
LAB_001012b7:
MOV EAX,0x0
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int8 func0(vector *param_1)
{
long *plVar1;
plVar1 = *(long **)param_1;
if (*(long **)(param_1 + 8) == plVar1) {
return 1;
}
do {
if (plVar1[1] != *plVar1) {
... |
458 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| bool func0(const std::vector<std::vector<int>>& list1) {
for (const auto& d : list1) {
if (!d.empty()) {
return false;
}
}
return true;
}
| int main() {
assert(func0({{}, {}, {}}) == true);
assert(func0({{1, 2}, {}, {}}) == false);
assert(func0({}) == true);
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
cmp %rdx,%rax
jne 1601 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x21>
jmp 1610 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x30>
nopw 0x0(%r... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rax, [rdi]
mov rdx, [rdi+8]
cmp rdx, rax
jnz short loc_15A1
jmp short loc_15B0
loc_1598:
add rax, 18h
cmp rdx, rax
jz short loc_15B0
loc_15A1:
mov rcx, [rax]
cmp [rax+8], rcx
jz short loc_1598
xor eax, eax
retn
loc_15B... | long long func0(long long a1)
{
_QWORD *v1; // rax
_QWORD *v2; // rdx
v1 = *(_QWORD **)a1;
v2 = *(_QWORD **)(a1 + 8);
if ( v2 == *(_QWORD **)a1 )
return 1LL;
while ( v1[1] == *v1 )
{
v1 += 3;
if ( v2 == v1 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RDX,RAX
JNZ 0x001015a1
JMP 0x001015b0
LAB_00101598:
ADD RAX,0x18
CMP RDX,RAX
JZ 0x001015b0
LAB_001015a1:
MOV RCX,qword ptr [RAX]
CMP qword ptr [RAX + 0x8],RCX
JZ 0x00101598
XOR EAX,EAX
RET
LAB_001015b0:
MOV EAX,0x1
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int8 func0(vector *param_1)
{
long *plVar1;
plVar1 = *(long **)param_1;
while( true ) {
if (*(long **)(param_1 + 8) == plVar1) {
return 1;
}
if (plVar1[1] != ... |
459 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| bool func0(const std::vector<std::vector<int>>& list1) {
for (const auto& d : list1) {
if (!d.empty()) {
return false;
}
}
return true;
}
| int main() {
assert(func0({{}, {}, {}}) == true);
assert(func0({{1, 2}, {}, {}}) == false);
assert(func0({}) == true);
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
cmp %rdx,%rax
jne 15c1 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x21>
jmp 15d0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x30>
nopw 0x0(%r... | _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rax, [rdi]
mov rdx, [rdi+8]
cmp rdx, rax
jnz short loc_15C1
jmp short loc_15D0
loc_15B8:
add rax, 18h
cmp rdx, rax
jz short loc_15D0
loc_15C1:
mov rcx, [rax]
cmp [rax+8], rcx
jz short loc_15B8
xor eax, eax
retn
loc_15D... | long long func0(long long a1)
{
_QWORD *v1; // rax
_QWORD *v2; // rdx
v1 = *(_QWORD **)a1;
v2 = *(_QWORD **)(a1 + 8);
if ( v2 == *(_QWORD **)a1 )
return 1LL;
while ( v1[1] == *v1 )
{
v1 += 3;
if ( v2 == v1 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RDX,RAX
JNZ 0x001015c1
JMP 0x001015d0
LAB_001015b8:
ADD RAX,0x18
CMP RDX,RAX
JZ 0x001015d0
LAB_001015c1:
MOV RCX,qword ptr [RAX]
CMP qword ptr [RAX + 0x8],RCX
JZ 0x001015b8
XOR EAX,EAX
RET
LAB_001015d0:
MOV EAX,0x1
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int8 func0(vector *param_1)
{
long *plVar1;
plVar1 = *(long **)param_1;
while( true ) {
if (*(long **)(param_1 + 8) == plVar1) {
return 1;
}
if (plVar1[1] != ... |
460 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <cassert>
| int func0(const std::vector<int>& nums) {
std::string num_str;
for (int num : nums) {
num_str += std::to_string(num);
}
return std::stoi(num_str);
}
| int main() {
assert(func0({1, 2, 3}) == 123);
assert(func0({4, 5, 6}) == 456);
assert(func0({5, 6, 7}) == 567);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x88,%rsp
mov %rdi,-0x88(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 23c0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev@p... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_88], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_60]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string... | long long func0(long long a1)
{
unsigned int v1; // ebx
int v3; // [rsp+14h] [rbp-7Ch]
long long v4; // [rsp+18h] [rbp-78h] BYREF
_QWORD v5[2]; // [rsp+20h] [rbp-70h] BYREF
_BYTE v6[32]; // [rsp+30h] [rbp-60h] BYREF
_BYTE v7[40]; // [rsp+50h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+78h] [rbp-18h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x00101270
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RDI,RAX
... | /* func0(std::vector<int, std::allocator<int> > const&) */
int4 func0(vector *param_1)
{
bool bVar1;
int4 uVar2;
long in_FS_OFFSET;
int8 local_80;
int8 local_78;
vector<int,std::allocator<int>> *local_70;
string local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFS... |
461 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <cassert>
| int func0(const std::vector<int>& nums) {
std::string num_str;
for (int num : nums) {
num_str += std::to_string(num);
}
return std::stoi(num_str);
}
| int main() {
assert(func0({1, 2, 3}) == 123);
assert(func0({4, 5, 6}) == 456);
assert(func0({5, 6, 7}) == 567);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rax
mov %rax,0x10(%rsp)
movq $0x0,0x18(%rsp)
movb $0x0,0x20(%rsp)
mov (%rdi),%rbx
mov 0x8(%rdi),%rb... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 130h
mov rax, fs:28h
mov [rsp+158h+var_30], rax
xor eax, eax
lea rax, [rsp+158h+var_138]
mov [rsp+158h+var_148], rax
mov [rsp+158h+var_140], 0
mov byte ptr [rsp+158h+var_138], 0
mov ... | long long func0(unsigned int **a1)
{
unsigned int *v1; // r13
unsigned int *v2; // r14
void *v3; // rbx
int *v4; // rbp
int v5; // r12d
long long v6; // rax
unsigned int v7; // ebx
unsigned int v9; // ebx
char *v10; // r12
int v11; // ebp
char v12; // bp
unsigned int v13; // eax
unsigned int ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x130
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],0x0
MOV byte ptr [RSP + 0x20],0x0
MOV R13,qword ptr [RDI]
MOV R14,qword ptr [RDI + 0x8]
CMP R14... | /* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
int iVar1;
uint *puVar2;
int *puVar3;
uint uVar4;
int *piVar5;
ulong uVar6;
int8 uVar7;
uint uVar8;
ulong uVar9;
uint uVar10;
char cVar11;
uint uVar12;
char *pcVar13;
uint *puVar14;
long in_FS_OFFSE... |
462 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <cassert>
| int func0(const std::vector<int>& nums) {
std::string num_str;
for (int num : nums) {
num_str += std::to_string(num);
}
return std::stoi(num_str);
}
| int main() {
assert(func0({1, 2, 3}) == 123);
assert(func0({4, 5, 6}) == 456);
assert(func0({5, 6, 7}) == 567);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r15
movb $0x0,0x20(%rsp)
mov %r15,0x10(%rs... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 158h
mov rbx, [rdi]
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
lea rax, [rsp+188h+var_148]
mov byte ptr [rsp+188h+var_148], 0
mov [rsp+188h+var_170], rax
mov... | long long func0(unsigned int **a1)
{
unsigned int *v1; // rbx
unsigned int *v2; // rax
unsigned int v3; // r15d
unsigned int v4; // ecx
unsigned int v5; // r13d
unsigned int v6; // r12d
int v7; // esi
unsigned int v8; // r14d
__int8 *v9; // r15
unsigned int v10; // eax
unsigned int v11; // esi
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x158
MOV RBX,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RDI + 0x8... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
uint uVar1;
uint *puVar2;
int *puVar3;
uint uVar4;
int *piVar5;
ulong uVar6;
char cVar7;
uint uVar8;
uint *puVar9;
int iVar... |
463 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <cassert>
| int func0(const std::vector<int>& nums) {
std::string num_str;
for (int num : nums) {
num_str += std::to_string(num);
}
return std::stoi(num_str);
}
| int main() {
assert(func0({1, 2, 3}) == 123);
assert(func0({4, 5, 6}) == 456);
assert(func0({5, 6, 7}) == 567);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%rax
movb $0x0,0x30(%rsp)
mov %rax,0x8(%rsp... | _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 158h
mov rbx, [rdi]
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
lea rax, [rsp+188h+var_148]
mov byte ptr [rsp+188h+var_148], 0
mov [rsp+188h+var_170], rax
mov... | long long func0(unsigned int **a1)
{
unsigned int *v1; // rbx
unsigned int *v2; // rax
unsigned int v3; // r15d
unsigned int v4; // ecx
unsigned int v5; // r14d
unsigned int v6; // r12d
int v7; // esi
unsigned int v8; // r13d
__int8 *v9; // r15
unsigned int v10; // eax
unsigned int v11; // esi
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x158
MOV RBX,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RDI + 0x8... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&) */
ulong func0(vector *param_1)
{
uint uVar1;
uint *puVar2;
int *puVar3;
uint uVar4;
int *piVar5;
ulong uVar6;
char cVar7;
uint uVar8;
uint *puVar9;
int iVar... |
464 | func0 | #include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <cassert>
#include <cctype>
using namespace std;
| string func0(const vector<pair<string, string>>& test_list) {
// Helper lambda: check if a string is all alphabetic.
auto isAlpha = [](const string &s) -> bool {
for (char c : s) {
if (!isalpha(c)) return false;
}
return true;
};
// Helper lambda: conver... | int main(){
assert(func0({{"3", "4"}, {"1", "26.45"}, {"7.32", "8"}, {"4", "8"}}) == "[(3.0, 4.0), (1.0, 26.45), (7.32, 8.0), (4.0, 8.0)]");
assert(func0({{"4", "4"}, {"2", "27"}, {"4.12", "9"}, {"7", "11"}}) == "[(4.0, 4.0), (2.0, 27.0), (4.12, 9.0), (7.0, 11.0)]");
assert(func0({{"6", "78"}, {"5", "26.... | O0 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_st... | _ZZ5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EEENKUlRKS6_E_clESD_:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_40]
mov [rbp+var_10],... | long long func0(std::vector<std::pair<std::string,std::string>> const&)::{lambda(std::string const&)#1}::operator()(
long long a1,
long long a2)
{
char v3; // [rsp+1Fh] [rbp-21h]
long long v4; // [rsp+20h] [rbp-20h] BYREF
_QWORD v5[3]; // [rsp+28h] [rbp-18h] BYREF
v5[2] = __readfsqword(0x28u);... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x208
MOV qword ptr [RBP + -0x208],RDI
MOV qword ptr [RBP + -0x210],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x1fa]
MOV qword ptr [RBP + -0x1f8],RAX
LEA RAX,[RBP + -0x190]
MOV RDI,RAX
LAB_00102a4f:
CALL 0x00102540
LE... | /* func0(std::vector<std::pair<std::string, std::string >, std::allocator<std::pair<std::string,
std::string > > > const&) */
vector * func0(vector *param_1)
{
bool bVar1;
ostream *poVar2;
vector<std::pair<std::string,std::string>,std::allocator<std::pair<std::string,std::string>>>
*in_RSI;
long in_FS_OF... |
465 | func0 | #include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <cassert>
#include <cctype>
using namespace std;
| string func0(const vector<pair<string, string>>& test_list) {
// Helper lambda: check if a string is all alphabetic.
auto isAlpha = [](const string &s) -> bool {
for (char c : s) {
if (!isalpha(c)) return false;
}
return true;
};
// Helper lambda: conver... | int main(){
assert(func0({{"3", "4"}, {"1", "26.45"}, {"7.32", "8"}, {"4", "8"}}) == "[(3.0, 4.0), (1.0, 26.45), (7.32, 8.0), (4.0, 8.0)]");
assert(func0({{"4", "4"}, {"2", "27"}, {"4.12", "9"}, {"7", "11"}}) == "[(4.0, 4.0), (2.0, 27.0), (4.12, 9.0), (7.0, 11.0)]");
assert(func0({{"6", "78"}, {"5", "26.... | O1 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_st... | _ZZ5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EEENKUlRKS6_E0_clESD_:
push r13
push r12
push rbp
push rbx
sub rsp, 1A8h
mov r12, rdi
mov r13, rdx
mov rax, fs:28h
mov [rsp+1C8h+var_30], rax
xor eax, eax
mov rbx, [rdx]
mov rbp, rbx
ad... | long long func0(std::vector<std::pair<std::string,std::string>> const&)::{lambda(std::string const&)#2}::operator()(
long long a1,
long long a2,
const char **a3)
{
const char *v4; // rbx
char *v5; // rbp
unsigned long long v7; // rbx
const char *v8; // rbp
struct _Unwind_Exception *v9... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1e8
MOV qword ptr [RSP + 0x8],RDI
MOV RBP,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1d8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x17]
MOV qword ptr [RSP + 0x18],RAX
LEA RBX,[RSP + 0x60]
LEA RDI,[RSP + 0xd0]
CALL 0x00102260
LEA RAX,[0x10... | /* func0(std::vector<std::pair<std::string, std::string >, std::allocator<std::pair<std::string,
std::string > > > const&) */
vector * func0(vector *param_1)
{
long lVar1;
ostream *poVar2;
long lVar3;
long *in_RSI;
long in_FS_OFFSET;
int local_201;
int *local_200;
long *local_1f8;
long local_1f0;... |
466 | func0 | #include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <cassert>
#include <cctype>
using namespace std;
| string func0(const vector<pair<string, string>>& test_list) {
// Helper lambda: check if a string is all alphabetic.
auto isAlpha = [](const string &s) -> bool {
for (char c : s) {
if (!isalpha(c)) return false;
}
return true;
};
// Helper lambda: conver... | int main(){
assert(func0({{"3", "4"}, {"1", "26.45"}, {"7.32", "8"}, {"4", "8"}}) == "[(3.0, 4.0), (1.0, 26.45), (7.32, 8.0), (4.0, 8.0)]");
assert(func0({{"4", "4"}, {"2", "27"}, {"4.12", "9"}, {"7", "11"}}) == "[(4.0, 4.0), (2.0, 27.0), (4.12, 9.0), (7.0, 11.0)]");
assert(func0({{"6", "78"}, {"5", "26.... | O2 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_st... | _ZZ5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EEENKUlRKS6_E0_clESD__isra_0:
push r15
push r14
push r13
mov r13, rsi
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 1D8h
mov rbp, [rsi]
mov r14, [rsi+8]
mov rax, fs:28h
mov [rsp+20... | long long func0(std::vector<std::pair<std::string,std::string>> const&)::{lambda(std::string const&)#2}::operator()(
long long a1,
const char **a2)
{
char *v3; // rbp
const char *v4; // r14
char *v5; // r12
int *v6; // rax
const char *v7; // r12
int v8; // r13d
int *v9; // rbp
_QWORD *v... | func0:
ENDBR64
PUSH R15
MOV R15,RDI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
SUB RSP,0x1f8
MOVQ XMM1,qword ptr [0x00105ca8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1e8],RAX
XOR EAX,EAX
LEA R14,[RSP + 0xe0]
LEA R12,[RSP + 0x70]
MOVHPS XMM1,qword ptr [0x00105ca0]
MOV RDI,R14
MOV qword ptr [RSP ... | /* func0(std::vector<std::pair<std::string, std::string >, std::allocator<std::pair<std::string,
std::string > > > const&) */
vector * func0(vector *param_1)
{
string *psVar1;
pointer_____offset_0x10___ puVar2;
pointer_____offset_0x18___ puVar3;
ostream *poVar4;
string *psVar5;
long *in_RSI;
streambu... |
467 | func0 | #include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <cassert>
#include <cctype>
using namespace std;
| string func0(const vector<pair<string, string>>& test_list) {
// Helper lambda: check if a string is all alphabetic.
auto isAlpha = [](const string &s) -> bool {
for (char c : s) {
if (!isalpha(c)) return false;
}
return true;
};
// Helper lambda: conver... | int main(){
assert(func0({{"3", "4"}, {"1", "26.45"}, {"7.32", "8"}, {"4", "8"}}) == "[(3.0, 4.0), (1.0, 26.45), (7.32, 8.0), (4.0, 8.0)]");
assert(func0({{"4", "4"}, {"2", "27"}, {"4.12", "9"}, {"7", "11"}}) == "[(4.0, 4.0), (2.0, 27.0), (4.12, 9.0), (7.0, 11.0)]");
assert(func0({{"6", "78"}, {"5", "26.... | O3 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_st... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rsi
sub rsp, 3C8h
mov [rsp+3F8h+var_3A8], rdi
lea r14, [rsp+3F8h+var_2C8]
lea r15, [rsp+3F8h+var_338]
mov rdi, r1... | long long func0(long long a1, char ***a2)
{
_QWORD *v2; // rdi
__m128i si128; // xmm3
char **v4; // rbx
char *v5; // r13
char *v6; // r12
char *v7; // r14
int *v8; // rax
const char *v9; // r13
int v10; // r14d
int *v11; // r12
_QWORD *v12; // rdi
__m128i v13; // xmm5
long long v14; // r8
_... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x3c8
MOV qword ptr [RSP + 0x50],RDI
LEA R14,[RSP + 0x130]
LEA R15,[RSP + 0xc0]
MOV RDI,R14
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x3b8],RAX
LEA RAX,[0x106bc8]
MOV qword ptr [RSP + 0x8],R15
MOV qword ptr [RSP + 0x58],R14... | /* func0(std::vector<std::pair<std::string, std::string >, std::allocator<std::pair<std::string,
std::string > > > const&) */
vector * func0(vector *param_1)
{
char *pcVar1;
ulong *puVar2;
int *__src;
ulong uVar3;
ulong uVar4;
int8 uVar5;
pointer_____offset_0x10___ puVar6;
pointer_____offset_0x10__... |
468 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
| std::vector<std::string> func0(std::string string) {
std::vector<std::string> lst;
size_t pos = 0;
std::string token;
std::string delimiter = " ";
while ((pos = string.find(delimiter)) != std::string::npos) {
token = string.substr(0, pos);
lst.push_back(token);
... | int main() {
std::vector<std::string> result;
result = func0("python programming");
assert((result.size() == 2) && (result[0] == "python") && (result[1] == "programming"));
result = func0("lists tuples strings");
assert((result.size() == 3) && (result[0] == "lists") && (result[1] ==... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x98,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x98(%rbp),%rax
mov %rax,%rdi
callq 2ccc <_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+var_A8], rdi
mov [rbp+var_B0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_A8]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx111... | long long func0(long long a1, long long a2)
{
long long v2; // rax
char v4; // [rsp+1Fh] [rbp-91h] BYREF
long long v5; // [rsp+20h] [rbp-90h]
char *v6; // [rsp+28h] [rbp-88h]
_BYTE v7[32]; // [rsp+30h] [rbp-80h] BYREF
_BYTE v8[32]; // [rsp+50h] [rbp-60h] BYREF
_BYTE v9[40]; // [rsp+70h] [rbp-40h] BYREF
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0xa8],RDI
MOV qword ptr [RBP + -0xb0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
MOV RDI,RAX
CALL 0x00102d9e
MOV qword ptr [RBP + -0x90],0x0
LEA RAX,[RBP + -0x80]
MOV RDI,RAX
... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,string *param_2)
{
long in_FS_OFFSET;
allocator local_99;
long local_98;
allocator *local_90;
string local_88 [32];
string local_68 [32];
string local_48 [40];
long... |
469 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
| std::vector<std::string> func0(std::string string) {
std::vector<std::string> lst;
size_t pos = 0;
std::string token;
std::string delimiter = " ";
while ((pos = string.find(delimiter)) != std::string::npos) {
token = string.substr(0, pos);
lst.push_back(token);
... | int main() {
std::vector<std::string> result;
result = func0("python programming");
assert((result.size() == 2) && (result[0] == "python") && (result[1] == "programming"));
result = func0("lists tuples strings");
assert((result.size() == 3) && (result[0] == "lists") && (result[1] ==... | 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 $0x78,%rsp
mov %rdi,%r12
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov rbp, rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+98h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h],... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
char *v4; // rax
long long v5; // rcx
_QWORD *v6; // rdi
long long v7; // rdx
unsigned long long v8; // rdi
char *v9; // rax
char *v10; // rsi
unsigned int v11; // ecx
unsigned int v12; // eax
unsigned long long v13; // rbx
long long v14; // rbx
unsigned ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RBP,RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
M... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,string *param_2)
{
long *plVar1;
ulong *puVar2;
uint uVar3;
long lVar4;
ulong uVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
long in_FS_OFFSET;
ulong *local_98;
... |
470 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
| std::vector<std::string> func0(std::string string) {
std::vector<std::string> lst;
size_t pos = 0;
std::string token;
std::string delimiter = " ";
while ((pos = string.find(delimiter)) != std::string::npos) {
token = string.substr(0, pos);
lst.push_back(token);
... | int main() {
std::vector<std::string> result;
result = func0("python programming");
assert((result.size() == 2) && (result[0] == "python") && (result[1] == "programming"));
result = func0("lists tuples strings");
assert((result.size() == 3) && (result[0] == "lists") && (result[1] ==... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
lea 0x890(%rip),%rdx
push %r14
push %r13
mov %rdi,%r13
push %r12
mov %rsi,%r12
lea -0x1(%rdx),%rsi
push %rbp
push %rbx
sub $0x88,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %e... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
lea rdx, asc_3193+1; ""
push r14
push r13
push r12
mov r12, rsi
lea rsi, [rdx-1]
push rbp
mov rbp, rdi
push rbx
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor ... | long long func0(long long a1, _QWORD *a2)
{
long long v4; // rcx
long long v5; // rbx
_BYTE *v6; // rsi
double *v7; // rdi
size_t v8; // rdx
__m128 v9; // xmm0
double v10; // rdx
_QWORD *v11; // rdi
unsigned long long v12; // rdx
unsigned long long v13; // rbx
unsigned long long v14; // rax
_QW... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
LEA RDX,[0x103194]
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
LEA RSI,[RDX + -0x1]
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
LEA R15,[RSP + 0x30]
LEA RAX,[RSP + 0x50]
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [R... | /* func0(std::string) */
vector<std::string,std::allocator<std::string>> *
func0(vector<std::string,std::allocator<std::string>> *param_1,string *param_2)
{
long *plVar1;
int8 uVar2;
ulong *puVar3;
ulong uVar4;
ulong uVar5;
long in_FS_OFFSET;
ulong *local_a8;
size_t local_a0;
ulong auStack_98 [2];
... |
471 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
| std::vector<std::string> func0(std::string string) {
std::vector<std::string> lst;
size_t pos = 0;
std::string token;
std::string delimiter = " ";
while ((pos = string.find(delimiter)) != std::string::npos) {
token = string.substr(0, pos);
lst.push_back(token);
... | int main() {
std::vector<std::string> result;
result = func0("python programming");
assert((result.size() == 2) && (result[0] == "python") && (result[1] == "programming"));
result = func0("lists tuples strings");
assert((result.size() == 3) && (result[0] == "lists") && (result[1] ==... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
mov $0x1,%ecx
push %r14
mov %rdi,%r14
push %r13
mov %rsi,%r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
mov edx, 20h ; ' '
mov ecx, 1
push r14
mov r14, rdi
push r13
push r12
mov r12, rsi
push rbp
push rbx
sub rsp, 0A8h
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
xor eax, eax
l... | long long func0(long long a1, long long a2)
{
long long v2; // rcx
_QWORD *v5; // rsi
unsigned long long v6; // rax
unsigned long long v7; // rbx
size_t v8; // rbp
__int8 *v9; // r15
long long *v10; // rax
long long *v11; // rax
long long *v12; // rcx
__m128i v13; // xmm0
long long v14; // rcx
... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV EDX,0x20
MOV ECX,0x1
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RSP + 0x8],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,string *param_2)
{
int *puVar1;
ulong *puVar2;
uint uVar3;
ulong uVar4;
ulong *__dest;
ulong uVar5;
ulong *puVar6;
long lVar7;
uint uVar8;
long in_FS_OFFSET;
... |
472 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O0 | cpp | func0(int*, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jge 11ad <_Z5func0Pii+0x44>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax... | _Z5func0Pii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11A5
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
xor [rbp+var_8], e... | long long func0(int *a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
v3 ^= a1[i];
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011a5
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
XOR dwo... | /* func0(int*, int) */
uint func0(int *param_1,int param_2)
{
uint local_10;
int local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_10 = local_10 ^ param_1[local_c];
}
return local_10;
} |
473 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O1 | cpp | func0(int*, int):
endbr64
test %esi,%esi
jle 118f <_Z5func0Pii+0x26>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rcx
mov $0x0,%edx
xor (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 1181 <_Z5func0Pii+0x18>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 118c <_Z5func0Pii+0x23>
| _Z5func0Pii:
endbr64
test esi, esi
jle short loc_118E
mov rax, rdi
movsxd rsi, esi
lea rcx, [rdi+rsi*4]
mov edx, 0
loc_1180:
xor edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1180
loc_118B:
mov eax, edx
retn
loc_118E:
mov edx, 0
jmp short loc_118B | long long func0(int *a1, int a2)
{
int *v2; // rax
unsigned int v3; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = 0;
do
v3 ^= *v2++;
while ( v2 != &a1[a2] );
}
return v3;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010118e
MOV RAX,RDI
MOVSXD RSI,ESI
LEA RCX,[RDI + RSI*0x4]
MOV EDX,0x0
LAB_00101180:
XOR EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101180
LAB_0010118b:
MOV EAX,EDX
RET
LAB_0010118e:
MOV EDX,0x0
JMP 0x0010118b | /* func0(int*, int) */
uint func0(int *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
if (param_2 < 1) {
uVar2 = 0;
}
else {
puVar1 = (uint *)(param_1 + param_2);
uVar2 = 0;
do {
uVar2 = uVar2 ^ *param_1;
param_1 = (int *)((uint *)param_1 + 1);
} while ((uint *)param_1 !... |
474 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O2 | cpp | func0(int*, int):
endbr64
test %esi,%esi
jle 1268 <_Z5func0Pii+0x28>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdx
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
xor (%rdi),%eax
add $0x4,%rdi
cmp %rdx,%rdi
jne 1258 <_Z5func0Pii+0x18>
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0Pii:
endbr64
test esi, esi
jle short loc_1320
movsxd rsi, esi
xor eax, eax
lea rdx, [rdi+rsi*4]
and esi, 1
jz short loc_1308
mov eax, [rdi]
add rdi, 4
cmp rdi, rdx
jz short locret_1323
nop dword ptr [rax+00000000h]
loc_1308:
xor eax, [rdi]
add rdi, 8
xor ... | long long func0(unsigned int *a1, int a2)
{
long long result; // rax
int *v3; // rdx
int v4; // eax
if ( a2 <= 0 )
return 0LL;
LODWORD(result) = 0;
v3 = (int *)&a1[a2];
if ( (a2 & 1) == 0 || (result = *a1, ++a1, a1 != (unsigned int *)v3) )
{
do
{
v4 = *a1 ^ result;
a1 += 2;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101320
MOVSXD RSI,ESI
XOR EAX,EAX
LEA RDX,[RDI + RSI*0x4]
AND ESI,0x1
JZ 0x00101308
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JZ 0x00101323
NOP dword ptr [RAX]
LAB_00101308:
XOR EAX,dword ptr [RDI]
ADD RDI,0x8
XOR EAX,dword ptr [RDI + -0x4]
CMP RDI,RDX
JNZ 0x00101308
RET
LAB_00... | /* func0(int*, int) */
uint func0(int *param_1,int param_2)
{
uint uVar1;
uint *puVar2;
uint *puVar3;
if (param_2 < 1) {
return 0;
}
uVar1 = 0;
puVar2 = (uint *)param_1;
if ((param_2 & 1U) != 0) {
uVar1 = *param_1;
puVar2 = (uint *)(param_1 + 1);
if (param_1 + 1 == param_1 + param_2... |
475 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int XOR = 0;
for (int i = 0; i < n; i++) {
XOR = XOR ^ arr[i];
}
return XOR;
}
| int main() {
int arr1[] = {1, 1, 2, 2, 3};
assert(func0(arr1, 5) == 3);
int arr2[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8};
assert(func0(arr2, 11) == 8);
int arr3[] = {1, 2, 2, 3, 3, 4, 4};
assert(func0(arr3, 7) == 1);
return 0;
}
| O3 | cpp | func0(int*, int):
endbr64
test %esi,%esi
jle 11e0 <_Z5func0Pii+0xa0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 11e9 <_Z5func0Pii+0xa9>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm0,%xmm0
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
pxor %x... | _Z5func0Pii:
endbr64
mov rcx, rdi
test esi, esi
jle loc_11D8
lea eax, [rsi-1]
cmp eax, 2
jbe loc_11E1
mov edx, esi
mov rax, rdi
pxor xmm0, xmm0
shr edx, 2
shl rdx, 4
add rdx, rdi
xchg ax, ax
loc_1170:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
pxor xmm0, xmm2
cm... | long long func0(const __m128i *a1, int a2)
{
const __m128i *v2; // rax
__m128i v3; // xmm0
__m128i v4; // xmm2
int v5; // edx
__m128i v6; // xmm0
long long result; // rax
long long v8; // r8
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v5 = 0;
LODWORD(result) = 0;
... | func0:
ENDBR64
MOV RCX,RDI
TEST ESI,ESI
JLE 0x001011d8
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x001011e1
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP
LAB_00101170:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PXOR XMM0,XMM2
CMP RAX,RDX
JNZ 0x00101170
MOVDQA XMM1,XMM0
MOV EDX,ESI
PSRLDQ XMM... | /* func0(int*, int) */
uint func0(int *param_1,int param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
uint *puVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
if (param_2 < 1) {
uVar4 = 0;
}
else {
if (param_2 - 1U < 3) {
uVar6 = 0;
uVar4 = 0;
}
... |
476 | func0 |
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#include <cassert>
| int func0(const std::vector<std::pair<int, int>>& list1) {
int result_max = 0;
for (const auto& p : list1) {
int product = std::abs(p.first * p.second);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
assert(func0({{2, 7}, {2, 6}, {1, 8}, {4, 9}}) == 36);
assert(func0({{10, 20}, {15, 2}, {5, 10}}) == 200);
assert(func0({{11, 44}, {10, 15}, {20, 5}, {12, 9}}) == 484);
return 0;
}
| O0 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x30(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x18(%rbp)
mov -0x18(%rbp),%r... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_30], 0
mov rax, [rbp+var_38]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vec... | long long func0(long long a1)
{
int v1; // eax
int v3; // [rsp+10h] [rbp-30h]
long long v4; // [rsp+18h] [rbp-28h] BYREF
_QWORD v5[2]; // [rsp+20h] [rbp-20h] BYREF
_DWORD *v6; // [rsp+30h] [rbp-10h]
unsigned long long v7; // [rsp+38h] [rbp-8h]
v7 = __readfsqword(0x28u);
v3 = 0;
v5[1] = a1;
v4 = st... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x30],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x0010167c
MOV qword pt... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
int func0(vector *param_1)
{
bool bVar1;
int iVar2;
long in_FS_OFFSET;
int local_38;
int8 local_30;
int8 local_28;
vector<std::pair<int,int>,std::allocator<std::pair<int,int>>> *local_20;
int *local_18;
long ... |
477 | func0 |
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#include <cassert>
| int func0(const std::vector<std::pair<int, int>>& list1) {
int result_max = 0;
for (const auto& p : list1) {
int product = std::abs(p.first * p.second);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
assert(func0({{2, 7}, {2, 6}, {1, 8}, {4, 9}}) == 36);
assert(func0({{10, 20}, {15, 2}, {5, 10}}) == 200);
assert(func0({{11, 44}, {10, 15}, {20, 5}, {12, 9}}) == 484);
return 0;
}
| O1 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rdi
cmp %rdi,%rdx
je 121e <_Z5func0RKSt6vectorISt4pairIiiESaIS1_EE+0x35>
mov $0x0,%ecx
mov (%rdx),%eax
imul 0x4(%rdx),%eax
mov %eax,%esi
sar $0x1f,%esi
xor %esi,%ea... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
mov rdx, [rdi]
mov rdi, [rdi+8]
cmp rdi, rdx
jz short loc_121C
mov esi, 0
loc_11FE:
mov eax, [rdx]
imul eax, [rdx+4]
mov ecx, eax
neg ecx
cmovns eax, ecx
cmp esi, eax
cmovl esi, eax
add rdx, 8
cmp rdx, rdi
jnz short ... | long long func0(long long a1)
{
_DWORD *v1; // rdx
_DWORD *v2; // rdi
int v3; // esi
int v4; // eax
v1 = *(_DWORD **)a1;
v2 = *(_DWORD **)(a1 + 8);
if ( v2 == v1 )
{
return 0;
}
else
{
v3 = 0;
do
{
v4 = v1[1] * *v1;
if ( v4 <= 0 )
v4 = -(v1[1] * *v1);
if... | func0:
ENDBR64
MOV RDX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RDX
JZ 0x0010121c
MOV ESI,0x0
LAB_001011fe:
MOV EAX,dword ptr [RDX]
IMUL EAX,dword ptr [RDX + 0x4]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
CMP ESI,EAX
CMOVL ESI,EAX
ADD RDX,0x8
CMP RDX,RDI
JNZ 0x001011fe
LAB_00101219:
MOV EAX,ESI
RET
LAB_0010121c:
... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
int func0(vector *param_1)
{
int iVar1;
int *piVar2;
int iVar3;
piVar2 = *(int **)param_1;
if (*(int **)(param_1 + 8) == piVar2) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
iVar1 = *piVar2 * piVar2... |
478 | func0 |
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#include <cassert>
| int func0(const std::vector<std::pair<int, int>>& list1) {
int result_max = 0;
for (const auto& p : list1) {
int product = std::abs(p.first * p.second);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
assert(func0({{2, 7}, {2, 6}, {1, 8}, {4, 9}}) == 36);
assert(func0({{10, 20}, {15, 2}, {5, 10}}) == 200);
assert(func0({{11, 44}, {10, 15}, {20, 5}, {12, 9}}) == 484);
return 0;
}
| O2 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rsi
xor %r8d,%r8d
cmp %rsi,%rdx
je 14a7 <_Z5func0RKSt6vectorISt4pairIiiESaIS1_EE+0x37>
nopl 0x0(%rax,%rax,1)
mov (%rdx),%eax
imul 0x4(%rdx),%eax
mov %eax,%ecx
sar $0... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
mov rdx, [rdi]
mov rdi, [rdi+8]
xor esi, esi
cmp rdi, rdx
jz short loc_1443
nop word ptr [rax+rax+00h]
loc_1428:
mov eax, [rdx]
imul eax, [rdx+4]
mov ecx, eax
neg ecx
cmovns eax, ecx
cmp esi, eax
cmovl esi, eax
add rdx, ... | long long func0(long long a1)
{
_DWORD *v1; // rdx
_DWORD *v2; // rdi
int i; // esi
int v4; // eax
v1 = *(_DWORD **)a1;
v2 = *(_DWORD **)(a1 + 8);
for ( i = 0; v2 != v1; v1 += 2 )
{
v4 = v1[1] * *v1;
if ( v4 <= 0 )
v4 = -(v1[1] * *v1);
if ( i < v4 )
i = v4;
}
return (unsign... | func0:
ENDBR64
MOV RDX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
XOR ESI,ESI
CMP RDI,RDX
JZ 0x00101443
NOP word ptr [RAX + RAX*0x1]
LAB_00101428:
MOV EAX,dword ptr [RDX]
IMUL EAX,dword ptr [RDX + 0x4]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
CMP ESI,EAX
CMOVL ESI,EAX
ADD RDX,0x8
CMP RDI,RDX
JNZ 0x00101428
LAB_00101443:
M... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
int func0(vector *param_1)
{
int iVar1;
int *piVar2;
int iVar3;
iVar3 = 0;
for (piVar2 = *(int **)param_1; *(int **)(param_1 + 8) != piVar2; piVar2 = piVar2 + 2) {
iVar1 = *piVar2 * piVar2[1];
if (iVar1 < ... |
479 | func0 |
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#include <cassert>
| int func0(const std::vector<std::pair<int, int>>& list1) {
int result_max = 0;
for (const auto& p : list1) {
int product = std::abs(p.first * p.second);
if (product > result_max) {
result_max = product;
}
}
return result_max;
}
| int main() {
assert(func0({{2, 7}, {2, 6}, {1, 8}, {4, 9}}) == 36);
assert(func0({{10, 20}, {15, 2}, {5, 10}}) == 200);
assert(func0({{11, 44}, {10, 15}, {20, 5}, {12, 9}}) == 484);
return 0;
}
| O3 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rsi
cmp %rsi,%rcx
je 18e8 <_Z5func0RKSt6vectorISt4pairIiiESaIS1_EE+0x158>
lea -0x8(%rsi),%rdx
mov %rcx,%rax
sub %rcx,%rdx
mov %rdx,%rdi
shr $0x3,%rdi
add $0x1,%rdi... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
mov rsi, [rdi]
mov rdi, [rdi+8]
cmp rdi, rsi
jz loc_18C0
lea rdx, [rdi-8]
mov rax, rsi
sub rdx, rsi
mov rcx, rdx
shr rcx, 3
add rcx, 1
cmp rdx, 10h
jbe loc_18C3
mov rdx, rcx
pxor xmm3, xmm3
shr rdx, 2
shl rd... | long long func0(const __m128i **a1)
{
const __m128i *v1; // rsi
const __m128i *v2; // rdi
const __m128i *v3; // rax
unsigned long long v4; // rcx
__m128i v5; // xmm3
__m128 v6; // xmm2
__m128 v7; // xmm4
__m128 v8; // xmm1
__m128i v9; // xmm2
__m128i v10; // xmm0
__m128i v11; // xmm0
__m128i v1... | func0:
ENDBR64
MOV RSI,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RSI
JZ 0x001018c0
LEA RDX,[RDI + -0x8]
MOV RAX,RSI
SUB RDX,RSI
MOV RCX,RDX
SHR RCX,0x3
ADD RCX,0x1
CMP RDX,0x10
JBE 0x001018c3
MOV RDX,RCX
PXOR XMM3,XMM3
SHR RDX,0x2
SHL RDX,0x5
ADD RDX,RSI
NOP dword ptr [RAX]
LAB_001017b8:
MOVDQU XMM2,xmmword... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
uint func0(vector *param_1)
{
int *piVar1;
int *piVar2;
int iVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint *puVar7;
int *piVar8;
int *piVar9;
uint uVar10;
int *piVar11;
ulong uVar12;
uint uVar13;
... |
480 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int A[], int n, int sum, int count) {
if (count == 3 && sum == 0) {
return true;
}
if (count == 3 || n == 0 || sum < 0) {
return false;
}
return func0(A, n - 1, sum - A[n - 1], count + 1) || func0(A, n - 1, sum, count);
}
| int main() {
int arr1[] = {2, 7, 4, 0, 9, 5, 1, 3};
assert(func0(arr1, 8, 6, 0) == true);
int arr2[] = {1, 4, 5, 6, 7, 8, 5, 9};
assert(func0(arr2, 8, 6, 0) == false);
int arr3[] = {10, 4, 2, 3, 5};
assert(func0(arr3, 5, 15, 0) == true);
std::cout << "All tests passe... | O0 | cpp | func0(int*, int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov %edx,-0x10(%rbp)
mov %ecx,-0x14(%rbp)
cmpl $0x3,-0x14(%rbp)
jne 1215 <_Z5func0Piiii+0x2c>
cmpl $0x0,-0x10(%rbp)
jne 1215 <_Z5func0Piiii+0x2c>
mov $0x1,%eax
jmp 128e ... | _Z5func0Piiii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov [rbp+var_14], ecx
cmp [rbp+var_14], 3
jnz short loc_11D5
cmp [rbp+var_10], 0
jnz short loc_11D5
mov eax, 1
jmp short locret_124E
loc_11D5:
cmp ... | _BOOL8 func0(int *a1, int a2, int a3, int a4)
{
if ( a4 == 3 && !a3 )
return 1LL;
if ( a4 == 3 || !a2 || a3 < 0 )
return 0LL;
return (unsigned __int8)func0(a1, a2 - 1, a3 - a1[a2 - 1], a4 + 1) || (unsigned __int8)func0(a1, a2 - 1, a3, a4);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV dword ptr [RBP + -0x14],ECX
CMP dword ptr [RBP + -0x14],0x3
JNZ 0x001011d5
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x001011d5
MOV EAX,0x1
JMP 0x0010124e
LAB_001011d5:
CMP dword ... | /* func0(int*, int, int, int) */
int8 func0(int *param_1,int param_2,int param_3,int param_4)
{
char cVar1;
int8 uVar2;
if ((param_4 == 3) && (param_3 == 0)) {
uVar2 = 1;
}
else if ((param_4 == 3) || ((param_2 == 0 || (param_3 < 0)))) {
uVar2 = 0;
}
else {
cVar1 = func0(param_1,param_2 + ... |
481 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int A[], int n, int sum, int count) {
if (count == 3 && sum == 0) {
return true;
}
if (count == 3 || n == 0 || sum < 0) {
return false;
}
return func0(A, n - 1, sum - A[n - 1], count + 1) || func0(A, n - 1, sum, count);
}
| int main() {
int arr1[] = {2, 7, 4, 0, 9, 5, 1, 3};
assert(func0(arr1, 8, 6, 0) == true);
int arr2[] = {1, 4, 5, 6, 7, 8, 5, 9};
assert(func0(arr2, 8, 6, 0) == false);
int arr3[] = {10, 4, 2, 3, 5};
assert(func0(arr3, 5, 15, 0) == true);
std::cout << "All tests passe... | O1 | cpp | func0(int*, int, int, int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edx,%ebx
cmp $0x3,%ecx
sete %dl
test %ebx,%ebx
sete %al
and %dl,%al
jne 1241 <_Z5func0Piiii+0x58>
mov %rdi,%r12
mov %ecx,%ebp
test %esi,%esi
sete %dil
mov %ebx,%ecx
shr $0x1f,%ecx
... | _Z5func0Piiii:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebx, edx
cmp ecx, 3
setz dl
test ebx, ebx
setz al
and al, dl
jnz short loc_1200
mov r12, rdi
mov ebp, ecx
test esi, esi
setz cl
mov edi, ebx
shr edi, 1Fh
or cl, dil
jnz short... | char func0(int *a1, int a2, int a3, int a4)
{
char result; // al
result = a4 == 3 && a3 == 0;
if ( !result && a3 >= 0 && a2 != 0 && a4 != 3 )
{
result = func0(a1, a2 - 1, a3 - a1[a2 - 1], a4 + 1);
if ( !result )
return func0(a1, a2 - 1, a3, a4);
}
return result;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDX
CMP ECX,0x3
SETZ DL
TEST EBX,EBX
SETZ AL
AND AL,DL
JNZ 0x00101200
MOV R12,RDI
MOV EBP,ECX
TEST ESI,ESI
SETZ CL
MOV EDI,EBX
SHR EDI,0x1f
OR CL,DIL
JNZ 0x00101200
TEST DL,DL
JNZ 0x00101200
LEA R13D,[RSI + -0x1]
LEA ECX,[RBP + 0x1]
MOVSXD RSI,ESI
M... | /* func0(int*, int, int, int) */
void func0(int *param_1,int param_2,int param_3,int param_4)
{
char cVar1;
if (((param_3 != 0 || param_4 != 3) && (param_2 != 0 && -1 < param_3)) && (param_4 != 3)) {
cVar1 = func0(param_1,param_2 + -1,param_3 - param_1[(long)param_2 + -1],param_4 + 1);
if (cVar1 == '\0... |
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.