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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
2,382 | func0 |
#include <tuple>
#include <cassert>
template <typename T>
| size_t func0(const T& t) {
return sizeof(t);
}
| int main() {
assert(func0(std::make_tuple("A", 1, "B", 2, "C", 3)) == sizeof(std::make_tuple("A", 1, "B", 2, "C", 3)));
assert(func0(std::make_tuple(1, "Raju", 2, "Nikhil", 3, "Deepanshu")) == sizeof(std::make_tuple(1, "Raju", 2, "Nikhil", 3, "Deepanshu")));
assert(func0(std::make_tuple(std::make_tuple(1, "Lion"), std::make_tuple(2, "Tiger"), std::make_tuple(3, "Fox"), std::make_tuple(4, "Wolf"))) == sizeof(std::make_tuple(std::make_tuple(1, "Lion"), std::make_tuple(2, "Tiger"), std::make_tuple(3, "Fox"), std::make_tuple(4, "Wolf"))));
}
| O2 | cpp | |||||
2,383 | func0 |
#include <tuple>
#include <cassert>
template <typename T>
| size_t func0(const T& t) {
return sizeof(t);
}
| int main() {
assert(func0(std::make_tuple("A", 1, "B", 2, "C", 3)) == sizeof(std::make_tuple("A", 1, "B", 2, "C", 3)));
assert(func0(std::make_tuple(1, "Raju", 2, "Nikhil", 3, "Deepanshu")) == sizeof(std::make_tuple(1, "Raju", 2, "Nikhil", 3, "Deepanshu")));
assert(func0(std::make_tuple(std::make_tuple(1, "Lion"), std::make_tuple(2, "Tiger"), std::make_tuple(3, "Fox"), std::make_tuple(4, "Wolf"))) == sizeof(std::make_tuple(std::make_tuple(1, "Lion"), std::make_tuple(2, "Tiger"), std::make_tuple(3, "Fox"), std::make_tuple(4, "Wolf"))));
}
| O3 | cpp | |||||
2,384 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(std::vector<int>& arr1, std::vector<int>& arr2, int m, int n, int k) {
std::vector<int> sorted1(m + n);
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
j++;
}
d++;
}
while (i < m) {
sorted1[d] = arr1[i];
i++;
d++;
}
while (j < n) {
sorted1[d] = arr2[j];
j++;
d++;
}
return sorted1[k - 1];
}
| int main() {
std::vector<int> arr1 = {2, 3, 6, 7, 9};
std::vector<int> arr2 = {1, 4, 8, 10};
assert(func0(arr1, arr2, 5, 4, 5) == 6);
arr1 = {100, 112, 256, 349, 770};
arr2 = {72, 86, 113, 119, 265, 445, 892};
assert(func0(arr1, arr2, 5, 7, 7) == 256);
arr1 = {3, 4, 7, 8, 10};
arr2 = {2, 5, 9, 11};
assert(func0(arr1, arr2, 5, 4, 6) == 8);
std::cout << "All tests passed successfully.\n";
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, 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 %r8d,-0x5c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x3d(%rbp),%rax
mov %rax,%rdi
callq 1984 <_ZNSaIiEC1Ev>
mov -0x54(%rbp),%edx
mov -0x58(%rbp),%eax
add %edx,%eax
movslq %eax,%rcx
lea -0x3d(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 19c4 <_ZNSt6vectorIiSaIiEEC1EmRKS0_>
lea -0x3d(%rbp),%rax
mov %rax,%rdi
callq 19a4 <_ZNSaIiED1Ev>
movl $0x0,-0x3c(%rbp)
movl $0x0,-0x38(%rbp)
movl $0x0,-0x34(%rbp)
mov -0x3c(%rbp),%eax
cmp -0x54(%rbp),%eax
jge 1420 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x137>
mov -0x38(%rbp),%eax
cmp -0x58(%rbp),%eax
jge 1420 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x137>
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a8c <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x38(%rbp),%eax
movslq %eax,%rdx
mov -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a8c <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
cmp %eax,%ebx
setl %al
test %al,%al
je 13e5 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xfc>
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a8c <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x34(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a8c <_ZNSt6vectorIiSaIiEEixEm>
mov %ebx,(%rax)
addl $0x1,-0x3c(%rbp)
jmp 1417 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x12e>
mov -0x38(%rbp),%eax
movslq %eax,%rdx
mov -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a8c <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x34(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a8c <_ZNSt6vectorIiSaIiEEixEm>
mov %ebx,(%rax)
addl $0x1,-0x38(%rbp)
addl $0x1,-0x34(%rbp)
jmpq 1362 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x79>
mov -0x3c(%rbp),%eax
cmp -0x54(%rbp),%eax
jge 1460 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x177>
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a8c <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x34(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a8c <_ZNSt6vectorIiSaIiEEixEm>
mov %ebx,(%rax)
addl $0x1,-0x3c(%rbp)
addl $0x1,-0x34(%rbp)
jmp 1420 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x137>
mov -0x38(%rbp),%eax
cmp -0x58(%rbp),%eax
jge 14a0 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x1b7>
mov -0x38(%rbp),%eax
movslq %eax,%rdx
mov -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a8c <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x34(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a8c <_ZNSt6vectorIiSaIiEEixEm>
mov %ebx,(%rax)
addl $0x1,-0x38(%rbp)
addl $0x1,-0x34(%rbp)
jmp 1460 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x177>
mov -0x5c(%rbp),%eax
sub $0x1,%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a8c <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 1a44 <_ZNSt6vectorIiSaIiEED1Ev>
mov %ebx,%eax
mov -0x18(%rbp),%rcx
xor %fs:0x28,%rcx
je 14fc <_Z5func0RSt6vectorIiSaIiEES2_iii+0x213>
jmp 14f7 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x20e>
endbr64
mov %rax,%rbx
lea -0x3d(%rbp),%rax
mov %rax,%rdi
callq 19a4 <_ZNSaIiED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 11f0 <_Unwind_Resume@plt>
callq 11a0 <__stack_chk_fail@plt>
add $0x58,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RSt6vectorIiSaIiEES2_iii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_64], edx
mov [rbp+var_68], ecx
mov [rbp+var_6C], r8d
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_45]
mov [rbp+var_38], rax
nop
nop
mov edx, [rbp+var_64]
mov eax, [rbp+var_68]
add eax, edx
movsxd rcx, eax
lea rdx, [rbp+var_45]
lea rax, [rbp+var_30]
mov rsi, rcx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2EmRKS0_; std::vector<int>::vector(ulong,std::allocator<int> const&)
lea rax, [rbp+var_45]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
mov [rbp+var_44], 0
mov [rbp+var_40], 0
mov [rbp+var_3C], 0
jmp loc_13E7
loc_1346:
mov eax, [rbp+var_44]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_40]
movsxd rdx, eax
mov rax, [rbp+var_60]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
cmp ebx, eax
setl al
test al, al
jz short loc_13B1
mov eax, [rbp+var_44]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_3C]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rax], ebx
add [rbp+var_44], 1
jmp short loc_13E3
loc_13B1:
mov eax, [rbp+var_40]
movsxd rdx, eax
mov rax, [rbp+var_60]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_3C]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rax], ebx
add [rbp+var_40], 1
loc_13E3:
add [rbp+var_3C], 1
loc_13E7:
mov eax, [rbp+var_44]
cmp eax, [rbp+var_64]
jge short loc_1433
mov eax, [rbp+var_40]
cmp eax, [rbp+var_68]
jl loc_1346
jmp short loc_1433
loc_13FD:
mov eax, [rbp+var_44]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_3C]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rax], ebx
add [rbp+var_44], 1
add [rbp+var_3C], 1
loc_1433:
mov eax, [rbp+var_44]
cmp eax, [rbp+var_64]
jl short loc_13FD
jmp short loc_1473
loc_143D:
mov eax, [rbp+var_40]
movsxd rdx, eax
mov rax, [rbp+var_60]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_3C]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rax], ebx
add [rbp+var_40], 1
add [rbp+var_3C], 1
loc_1473:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_68]
jl short loc_143D
mov eax, [rbp+var_6C]
sub eax, 1
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov eax, ebx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_14EC
jmp short loc_14E7
endbr64
mov rbx, rax
lea rax, [rbp+var_45]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_14DF
call ___stack_chk_fail
loc_14DF:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_14E7:
call ___stack_chk_fail
loc_14EC:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, int a3, int a4, int a5)
{
int v5; // ebx
int v6; // ebx
int v7; // ebx
int v8; // ebx
int v9; // ebx
unsigned int v10; // ebx
char v15; // [rsp+2Bh] [rbp-45h] BYREF
int v16; // [rsp+2Ch] [rbp-44h]
int v17; // [rsp+30h] [rbp-40h]
int v18; // [rsp+34h] [rbp-3Ch]
char *v19; // [rsp+38h] [rbp-38h]
_BYTE v20[24]; // [rsp+40h] [rbp-30h] BYREF
unsigned long long v21; // [rsp+58h] [rbp-18h]
v21 = __readfsqword(0x28u);
v19 = &v15;
std::vector<int>::vector(v20, a3 + a4, &v15);
std::__new_allocator<int>::~__new_allocator(&v15);
v16 = 0;
v17 = 0;
v18 = 0;
while ( v16 < a3 && v17 < a4 )
{
v5 = *(_DWORD *)std::vector<int>::operator[](a1, v16);
if ( v5 >= *(_DWORD *)std::vector<int>::operator[](a2, v17) )
{
v7 = *(_DWORD *)std::vector<int>::operator[](a2, v17);
*(_DWORD *)std::vector<int>::operator[](v20, v18) = v7;
++v17;
}
else
{
v6 = *(_DWORD *)std::vector<int>::operator[](a1, v16);
*(_DWORD *)std::vector<int>::operator[](v20, v18) = v6;
++v16;
}
++v18;
}
while ( v16 < a3 )
{
v8 = *(_DWORD *)std::vector<int>::operator[](a1, v16);
*(_DWORD *)std::vector<int>::operator[](v20, v18) = v8;
++v16;
++v18;
}
while ( v17 < a4 )
{
v9 = *(_DWORD *)std::vector<int>::operator[](a2, v17);
*(_DWORD *)std::vector<int>::operator[](v20, v18) = v9;
++v17;
++v18;
}
v10 = *(_DWORD *)std::vector<int>::operator[](v20, a5 - 1);
std::vector<int>::~vector(v20);
return v10;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV dword ptr [RBP + -0x64],EDX
MOV dword ptr [RBP + -0x68],ECX
MOV dword ptr [RBP + -0x6c],R8D
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x45]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV EDX,dword ptr [RBP + -0x64]
MOV EAX,dword ptr [RBP + -0x68]
ADD EAX,EDX
MOVSXD RCX,EAX
LEA RDX,[RBP + -0x45]
LEA RAX,[RBP + -0x30]
MOV RSI,RCX
MOV RDI,RAX
LAB_0010131a:
CALL 0x0010196a
LEA RAX,[RBP + -0x45]
MOV RDI,RAX
CALL 0x00101bae
NOP
MOV dword ptr [RBP + -0x44],0x0
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x001013e7
LAB_00101346:
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a42
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x40]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a42
MOV EAX,dword ptr [RAX]
CMP EBX,EAX
SETL AL
TEST AL,AL
JZ 0x001013b1
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a42
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a42
MOV dword ptr [RAX],EBX
ADD dword ptr [RBP + -0x44],0x1
JMP 0x001013e3
LAB_001013b1:
MOV EAX,dword ptr [RBP + -0x40]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a42
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a42
MOV dword ptr [RAX],EBX
ADD dword ptr [RBP + -0x40],0x1
LAB_001013e3:
ADD dword ptr [RBP + -0x3c],0x1
LAB_001013e7:
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x64]
JGE 0x00101433
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x68]
JL 0x00101346
JMP 0x00101433
LAB_001013fd:
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a42
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a42
MOV dword ptr [RAX],EBX
ADD dword ptr [RBP + -0x44],0x1
ADD dword ptr [RBP + -0x3c],0x1
LAB_00101433:
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x64]
JL 0x001013fd
JMP 0x00101473
LAB_0010143d:
MOV EAX,dword ptr [RBP + -0x40]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a42
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a42
MOV dword ptr [RAX],EBX
ADD dword ptr [RBP + -0x40],0x1
ADD dword ptr [RBP + -0x3c],0x1
LAB_00101473:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x68]
JL 0x0010143d
MOV EAX,dword ptr [RBP + -0x6c]
SUB EAX,0x1
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101a42
MOV EBX,dword ptr [RAX]
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x001019e8
MOV EAX,EBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001014ec
JMP 0x001014e7
LAB_001014e7:
CALL 0x00101190
LAB_001014ec:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int,
int) */
int4 func0(vector *param_1,vector *param_2,int param_3,int param_4,int param_5)
{
int iVar1;
int4 uVar2;
int *piVar3;
int4 *puVar4;
long in_FS_OFFSET;
allocator local_4d;
int local_4c;
int local_48;
int local_44;
allocator *local_40;
vector<int,std::allocator<int>> local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = &local_4d;
/* try { // try from 0010131a to 0010131e has its CatchHandler @ 001014b4 */
std::vector<int,std::allocator<int>>::vector(local_38,(long)(param_4 + param_3),&local_4d);
std::__new_allocator<int>::~__new_allocator((__new_allocator<int> *)&local_4d);
local_4c = 0;
local_48 = 0;
local_44 = 0;
while ((local_4c < param_3 && (local_48 < param_4))) {
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_4c);
iVar1 = *piVar3;
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_2,(long)local_48);
if (iVar1 < *piVar3) {
puVar4 = (int4 *)
std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_4c);
uVar2 = *puVar4;
puVar4 = (int4 *)
std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_44);
*puVar4 = uVar2;
local_4c = local_4c + 1;
}
else {
puVar4 = (int4 *)
std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_2,(long)local_48);
uVar2 = *puVar4;
puVar4 = (int4 *)
std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_44);
*puVar4 = uVar2;
local_48 = local_48 + 1;
}
local_44 = local_44 + 1;
}
for (; local_4c < param_3; local_4c = local_4c + 1) {
puVar4 = (int4 *)
std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_4c);
uVar2 = *puVar4;
puVar4 = (int4 *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_44)
;
*puVar4 = uVar2;
local_44 = local_44 + 1;
}
for (; local_48 < param_4; local_48 = local_48 + 1) {
puVar4 = (int4 *)
std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_2,(long)local_48);
uVar2 = *puVar4;
puVar4 = (int4 *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_44)
;
*puVar4 = uVar2;
local_44 = local_44 + 1;
}
puVar4 = (int4 *)
std::vector<int,std::allocator<int>>::operator[](local_38,(long)(param_5 + -1));
uVar2 = *puVar4;
std::vector<int,std::allocator<int>>::~vector(local_38);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,385 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(std::vector<int>& arr1, std::vector<int>& arr2, int m, int n, int k) {
std::vector<int> sorted1(m + n);
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
j++;
}
d++;
}
while (i < m) {
sorted1[d] = arr1[i];
i++;
d++;
}
while (j < n) {
sorted1[d] = arr2[j];
j++;
d++;
}
return sorted1[k - 1];
}
| int main() {
std::vector<int> arr1 = {2, 3, 6, 7, 9};
std::vector<int> arr2 = {1, 4, 8, 10};
assert(func0(arr1, arr2, 5, 4, 5) == 6);
arr1 = {100, 112, 256, 349, 770};
arr2 = {72, 86, 113, 119, 265, 445, 892};
assert(func0(arr1, arr2, 5, 7, 7) == 256);
arr1 = {3, 4, 7, 8, 10};
arr2 = {2, 5, 9, 11};
assert(func0(arr1, arr2, 5, 4, 6) == 8);
std::cout << "All tests passed successfully.\n";
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
lea (%rdx,%rcx,1),%r15d
movslq %r15d,%r15
movabs $0x1fffffffffffffff,%rax
cmp %rax,%r15
ja 130f <_Z5func0RSt6vectorIiSaIiEES2_iii+0x86>
mov %rdi,%r14
mov %rsi,%r13
mov %edx,%ebx
mov %ecx,%ebp
mov %r8d,%r12d
mov $0x0,%edi
test %r15,%r15
je 12ec <_Z5func0RSt6vectorIiSaIiEES2_iii+0x63>
shl $0x2,%r15
mov %r15,%rdi
callq 1150 <_Znwm@plt>
mov %rax,%rdi
add %rax,%r15
mov %rax,%rdx
movl $0x0,(%rdx)
add $0x4,%rdx
cmp %r15,%rdx
jne 12dd <_Z5func0RSt6vectorIiSaIiEES2_iii+0x54>
test %ebx,%ebx
jle 131b <_Z5func0RSt6vectorIiSaIiEES2_iii+0x92>
test %ebp,%ebp
jle 131b <_Z5func0RSt6vectorIiSaIiEES2_iii+0x92>
mov (%r14),%r10
mov 0x0(%r13),%r9
mov $0x1,%ecx
mov $0x0,%edx
mov $0x0,%esi
jmpq 13bf <_Z5func0RSt6vectorIiSaIiEES2_iii+0x136>
lea 0xcf2(%rip),%rdi
callq 10f0 <_ZSt20__throw_length_errorPKc@plt>
mov $0x0,%r8d
mov $0x0,%edx
mov $0x0,%esi
cmp %esi,%ebx
jle 1357 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xce>
mov (%r14),%r10
movslq %esi,%rcx
movslq %r8d,%rax
sub %rcx,%rax
lea (%rdi,%rax,4),%r9
mov (%r10,%rcx,4),%eax
mov %eax,(%r9,%rcx,4)
add $0x1,%rcx
cmp %ecx,%ebx
jg 133f <_Z5func0RSt6vectorIiSaIiEES2_iii+0xb6>
add %r8d,%ebx
sub %esi,%ebx
mov %ebx,%r8d
cmp %edx,%ebp
jle 137a <_Z5func0RSt6vectorIiSaIiEES2_iii+0xf1>
mov 0x0(%r13),%rsi
movslq %edx,%rdx
movslq %r8d,%rbx
sub %rdx,%rbx
lea (%rdi,%rbx,4),%rcx
mov (%rsi,%rdx,4),%eax
mov %eax,(%rcx,%rdx,4)
add $0x1,%rdx
cmp %edx,%ebp
jg 136c <_Z5func0RSt6vectorIiSaIiEES2_iii+0xe3>
sub $0x1,%r12d
movslq %r12d,%r12
mov (%rdi,%r12,4),%ebx
test %rdi,%rdi
je 138f <_Z5func0RSt6vectorIiSaIiEES2_iii+0x106>
callq 1130 <_ZdlPv@plt>
mov %ebx,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov %r8d,-0x4(%rdi,%rcx,4)
add $0x1,%edx
mov %ecx,%r8d
add $0x1,%rcx
cmp %ebx,%esi
jge 132b <_Z5func0RSt6vectorIiSaIiEES2_iii+0xa2>
cmp %ebp,%edx
jge 132b <_Z5func0RSt6vectorIiSaIiEES2_iii+0xa2>
movslq %esi,%rax
mov (%r10,%rax,4),%eax
movslq %edx,%r8
mov (%r9,%r8,4),%r8d
cmp %r8d,%eax
jge 13a0 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x117>
mov %eax,-0x4(%rdi,%rcx,4)
add $0x1,%esi
jmp 13a8 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x11f>
| _Z5func0RSt6vectorIiSaIiEES2_iii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_3C], r8d
lea r12d, [rdx+rcx]
movsxd r12, r12d
mov rax, r12
shr rax, 3Dh
jnz short loc_12BC
mov r14, rdi
mov r13, rsi
mov ebp, edx
mov ebx, ecx
test r12, r12
jz short loc_12C8
lea r15, ds:0[r12*4]
mov rdi, r15; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax
mov dword ptr [rax], 0
cmp r12, 1
jz short loc_12D0
lea rdx, [rax+r15]
lea rax, [rax+4]
cmp rax, rdx
jz short loc_12D0
loc_12AB:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdx
jnz short loc_12AB
jmp short loc_12D0
loc_12BC:
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_12C8:
mov r15, r12
mov edi, 0; void *
loc_12D0:
test ebx, ebx
jle short loc_1321
test ebp, ebp
jle short loc_1321
mov r10, [r14]
mov r9, [r13+0]
mov ecx, 1
mov esi, 0
mov eax, 0
jmp short loc_1309
loc_12F0:
add esi, 1
mov edx, r8d
loc_12F6:
mov [rdi+rcx*4-4], edx
lea rdx, [rcx+1]
cmp eax, ebp
jge short loc_1330
cmp esi, ebx
jge short loc_1330
mov rcx, rdx
loc_1309:
movsxd rdx, eax
mov edx, [r10+rdx*4]
movsxd r8, esi
mov r8d, [r9+r8*4]
cmp edx, r8d
jge short loc_12F0
add eax, 1
jmp short loc_12F6
loc_1321:
mov ecx, 0
mov esi, 0
mov eax, 0
loc_1330:
cmp ebp, eax
jle short loc_136E
mov r8d, eax
mov r9d, ebp
sub r9d, eax
shl r9, 2
cdqe
mov rdx, [r14]
lea r11, [rdx+rax*4]
movsxd rax, ecx
lea r10, [rdi+rax*4]
mov eax, 0
loc_1356:
mov edx, [r11+rax]
mov [r10+rax], edx
add rax, 4
cmp rax, r9
jnz short loc_1356
add ebp, ecx
mov ecx, ebp
sub ecx, r8d
loc_136E:
cmp ebx, esi
jle short loc_139E
sub ebx, esi
shl rbx, 2
movsxd rax, esi
mov rdx, [r13+0]
lea rsi, [rdx+rax*4]
movsxd rcx, ecx
lea rcx, [rdi+rcx*4]
mov eax, 0
loc_138F:
mov edx, [rsi+rax]
mov [rcx+rax], edx
add rax, 4
cmp rax, rbx
jnz short loc_138F
loc_139E:
mov eax, [rsp+48h+var_3C]
sub eax, 1
cdqe
mov ebx, [rdi+rax*4]
test rdi, rdi
jz short loc_13B7
mov rsi, r15; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_13B7:
mov eax, ebx
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long *a1, long long *a2, int a3, int a4, int a5)
{
unsigned long long v5; // r12
unsigned long long v10; // r15
_DWORD *v11; // rax
_DWORD *v12; // rdi
_DWORD *v13; // rdx
_DWORD *i; // rax
long long v15; // r10
long long v16; // r9
long long v17; // rcx
int v18; // esi
int v19; // eax
int v20; // edx
int v21; // r8d
int v22; // r8d
long long v23; // r9
long long v24; // r11
unsigned long long v25; // rax
long long v26; // rbx
long long v27; // rsi
char *v28; // rcx
long long v29; // rax
unsigned int v30; // ebx
v5 = a3 + a4;
if ( v5 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( a3 + a4 )
{
v10 = v5;
v11 = (_DWORD *)operator new(4 * v5);
v12 = v11;
*v11 = 0;
if ( v5 != 1 )
{
v13 = &v11[v10];
for ( i = v11 + 1; i != v13; ++i )
*i = 0;
}
}
else
{
v10 = 0LL;
v12 = 0LL;
}
if ( a4 <= 0 || a3 <= 0 )
{
LODWORD(v17) = 0;
v18 = 0;
v19 = 0;
}
else
{
v15 = *a1;
v16 = *a2;
v17 = 1LL;
v18 = 0;
v19 = 0;
while ( 1 )
{
v20 = *(_DWORD *)(v15 + 4LL * v19);
v21 = *(_DWORD *)(v16 + 4LL * v18);
if ( v20 >= v21 )
{
++v18;
v20 = v21;
}
else
{
++v19;
}
v12[v17 - 1] = v20;
if ( v19 >= a3 || v18 >= a4 )
break;
++v17;
}
}
if ( a3 > v19 )
{
v22 = v19;
v23 = 4LL * (unsigned int)(a3 - v19);
v24 = *a1 + 4LL * v19;
v25 = 0LL;
do
{
v12[(int)v17 + v25 / 4] = *(_DWORD *)(v24 + v25);
v25 += 4LL;
}
while ( v25 != v23 );
LODWORD(v17) = v17 + a3 - v22;
}
if ( a4 > v18 )
{
v26 = 4LL * (unsigned int)(a4 - v18);
v27 = *a2 + 4LL * v18;
v28 = (char *)&v12[(int)v17];
v29 = 0LL;
do
{
*(_DWORD *)&v28[v29] = *(_DWORD *)(v27 + v29);
v29 += 4LL;
}
while ( v29 != v26 );
}
v30 = v12[a5 - 1];
if ( v12 )
operator delete(v12, v10 * 4);
return v30;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],R8D
LEA R12D,[RDX + RCX*0x1]
MOVSXD R12,R12D
MOV RAX,R12
SHR RAX,0x3d
JNZ 0x001012bc
MOV R14,RDI
MOV R13,RSI
MOV EBP,EDX
MOV EBX,ECX
TEST R12,R12
JZ 0x001012c8
LEA R15,[R12*0x4]
MOV RDI,R15
CALL 0x00101110
MOV RDI,RAX
MOV dword ptr [RAX],0x0
CMP R12,0x1
JZ 0x001012d0
LEA RDX,[RAX + R15*0x1]
LEA RAX,[RAX + 0x4]
CMP RAX,RDX
JZ 0x001012d0
LAB_001012ab:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001012ab
JMP 0x001012d0
LAB_001012bc:
LEA RDI,[0x102008]
CALL 0x001010d0
LAB_001012c8:
MOV R15,R12
MOV EDI,0x0
LAB_001012d0:
TEST EBX,EBX
JLE 0x00101321
TEST EBP,EBP
JLE 0x00101321
MOV R10,qword ptr [R14]
MOV R9,qword ptr [R13]
MOV ECX,0x1
MOV ESI,0x0
MOV EAX,0x0
JMP 0x00101309
LAB_001012f0:
ADD ESI,0x1
MOV EDX,R8D
LAB_001012f6:
MOV dword ptr [RDI + RCX*0x4 + -0x4],EDX
LEA RDX,[RCX + 0x1]
CMP EAX,EBP
JGE 0x00101330
CMP ESI,EBX
JGE 0x00101330
MOV RCX,RDX
LAB_00101309:
MOVSXD RDX,EAX
MOV EDX,dword ptr [R10 + RDX*0x4]
MOVSXD R8,ESI
MOV R8D,dword ptr [R9 + R8*0x4]
CMP EDX,R8D
JGE 0x001012f0
ADD EAX,0x1
JMP 0x001012f6
LAB_00101321:
MOV ECX,0x0
MOV ESI,0x0
MOV EAX,0x0
LAB_00101330:
CMP EBP,EAX
JLE 0x0010136e
MOV R8D,EAX
MOV R9D,EBP
SUB R9D,EAX
SHL R9,0x2
CDQE
MOV RDX,qword ptr [R14]
LEA R11,[RDX + RAX*0x4]
MOVSXD RAX,ECX
LEA R10,[RDI + RAX*0x4]
MOV EAX,0x0
LAB_00101356:
MOV EDX,dword ptr [R11 + RAX*0x1]
MOV dword ptr [R10 + RAX*0x1],EDX
ADD RAX,0x4
CMP RAX,R9
JNZ 0x00101356
ADD EBP,ECX
MOV ECX,EBP
SUB ECX,R8D
LAB_0010136e:
CMP EBX,ESI
JLE 0x0010139e
SUB EBX,ESI
SHL RBX,0x2
MOVSXD RAX,ESI
MOV RDX,qword ptr [R13]
LEA RSI,[RDX + RAX*0x4]
MOVSXD RCX,ECX
LEA RCX,[RDI + RCX*0x4]
MOV EAX,0x0
LAB_0010138f:
MOV EDX,dword ptr [RSI + RAX*0x1]
MOV dword ptr [RCX + RAX*0x1],EDX
ADD RAX,0x4
CMP RAX,RBX
JNZ 0x0010138f
LAB_0010139e:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x1
CDQE
MOV EBX,dword ptr [RDI + RAX*0x4]
TEST RDI,RDI
JZ 0x001013b7
MOV RSI,R15
CALL 0x00101120
LAB_001013b7:
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | /* func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int,
int) */
int4 func0(vector *param_1,vector *param_2,int param_3,int param_4,int param_5)
{
int4 uVar1;
long lVar2;
int4 *puVar3;
long lVar4;
int iVar5;
int4 *puVar6;
long lVar7;
int iVar8;
long lVar9;
int iVar10;
int unaff_EBX;
int unaff_EBP;
int iVar11;
ulong uVar12;
vector *unaff_R13;
vector *unaff_R14;
ulong uVar13;
uVar12 = (ulong)(param_3 + param_4);
if (uVar12 >> 0x3d == 0) {
unaff_R13 = param_2;
unaff_R14 = param_1;
if (uVar12 != 0) {
uVar13 = uVar12 * 4;
puVar6 = (int4 *)operator_new(uVar13);
*puVar6 = 0;
if (uVar12 != 1) {
puVar3 = puVar6;
while (puVar3 = puVar3 + 1, puVar3 != puVar6 + uVar12) {
*puVar3 = 0;
}
}
goto LAB_001012d0;
}
}
else {
std::__throw_length_error("cannot create std::vector larger than max_size()");
param_3 = unaff_EBP;
param_4 = unaff_EBX;
}
puVar6 = (int4 *)0x0;
uVar13 = uVar12;
LAB_001012d0:
if ((param_4 < 1) || (param_3 < 1)) {
lVar9 = 0;
iVar11 = 0;
iVar5 = 0;
}
else {
lVar7 = *(long *)unaff_R14;
lVar2 = *(long *)unaff_R13;
iVar11 = 0;
iVar5 = 0;
lVar4 = 1;
do {
lVar9 = lVar4;
iVar8 = *(int *)(lVar7 + (long)iVar5 * 4);
iVar10 = *(int *)(lVar2 + (long)iVar11 * 4);
if (iVar8 < iVar10) {
iVar5 = iVar5 + 1;
iVar10 = iVar8;
}
else {
iVar11 = iVar11 + 1;
}
puVar6[lVar9 + -1] = iVar10;
} while ((iVar5 < param_3) && (lVar4 = lVar9 + 1, iVar11 < param_4));
}
iVar8 = (int)lVar9;
if (iVar5 < param_3) {
lVar9 = *(long *)unaff_R14;
lVar7 = 0;
do {
*(int4 *)((long)puVar6 + lVar7 + (long)iVar8 * 4) =
*(int4 *)(lVar9 + (long)iVar5 * 4 + lVar7);
lVar7 = lVar7 + 4;
} while (lVar7 != (ulong)(uint)(param_3 - iVar5) << 2);
iVar8 = (param_3 + iVar8) - iVar5;
}
if (iVar11 < param_4) {
lVar9 = *(long *)unaff_R13;
lVar7 = 0;
do {
*(int4 *)((long)puVar6 + lVar7 + (long)iVar8 * 4) =
*(int4 *)(lVar9 + (long)iVar11 * 4 + lVar7);
lVar7 = lVar7 + 4;
} while (lVar7 != (ulong)(uint)(param_4 - iVar11) << 2);
}
uVar1 = puVar6[param_5 + -1];
if (puVar6 != (int4 *)0x0) {
operator_delete(puVar6,uVar13);
}
return uVar1;
} |
2,386 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(std::vector<int>& arr1, std::vector<int>& arr2, int m, int n, int k) {
std::vector<int> sorted1(m + n);
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
j++;
}
d++;
}
while (i < m) {
sorted1[d] = arr1[i];
i++;
d++;
}
while (j < n) {
sorted1[d] = arr2[j];
j++;
d++;
}
return sorted1[k - 1];
}
| int main() {
std::vector<int> arr1 = {2, 3, 6, 7, 9};
std::vector<int> arr2 = {1, 4, 8, 10};
assert(func0(arr1, arr2, 5, 4, 5) == 6);
arr1 = {100, 112, 256, 349, 770};
arr2 = {72, 86, 113, 119, 265, 445, 892};
assert(func0(arr1, arr2, 5, 7, 7) == 256);
arr1 = {3, 4, 7, 8, 10};
arr2 = {2, 5, 9, 11};
assert(func0(arr1, arr2, 5, 4, 6) == 8);
std::cout << "All tests passed successfully.\n";
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int, int):
endbr64
push %r15
lea (%rdx,%rcx,1),%eax
push %r14
cltq
push %r13
push %r12
push %rbp
push %rbx
mov %edx,%ebx
movabs $0x1fffffffffffffff,%rdx
sub $0x8,%rsp
cmp %rdx,%rax
ja 1724 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x164>
mov %rdi,%r13
mov %rsi,%r12
mov %ecx,%ebp
mov %r8d,%r14d
xor %edi,%edi
test %rax,%rax
je 1630 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x70>
lea 0x0(,%rax,4),%r15
mov %r15,%rdi
callq 1150 <_Znwm@plt>
mov %rax,%rdi
lea (%rax,%r15,1),%rax
mov %rdi,%r9
nopl 0x0(%rax,%rax,1)
movl $0x0,(%r9)
add $0x4,%r9
cmp %rax,%r9
jne 1620 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x60>
test %ebp,%ebp
jle 1718 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x158>
test %ebx,%ebx
jle 1718 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x158>
mov 0x0(%r13),%r11
mov (%r12),%r8
mov $0x1,%r9d
xor %edx,%edx
xor %r10d,%r10d
jmp 1671 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xb1>
nopl (%rax)
add $0x1,%r10d
mov %esi,-0x4(%rdi,%r9,4)
mov %r9d,%ecx
add $0x1,%r9
cmp %ebx,%r10d
jge 1697 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xd7>
cmp %ebp,%edx
jge 1697 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xd7>
movslq %r10d,%rax
mov (%r11,%rax,4),%esi
movslq %edx,%rax
mov (%r8,%rax,4),%ecx
cmp %ecx,%esi
jl 1658 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x98>
mov %ecx,-0x4(%rdi,%r9,4)
add $0x1,%edx
mov %r9d,%ecx
add $0x1,%r9
cmp %ebx,%r10d
jl 166d <_Z5func0RSt6vectorIiSaIiEES2_iii+0xad>
cmp %r10d,%ebx
jle 16c8 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x108>
movslq %r10d,%r9
movslq %ecx,%rax
mov 0x0(%r13),%r8
sub %r9,%rax
lea (%rdi,%rax,4),%rsi
nopl (%rax)
mov (%r8,%r9,4),%eax
mov %eax,(%rsi,%r9,4)
add $0x1,%r9
cmp %r9d,%ebx
jg 16b0 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xf0>
add %ecx,%ebx
sub %r10d,%ebx
mov %ebx,%ecx
cmp %edx,%ebp
jle 16ee <_Z5func0RSt6vectorIiSaIiEES2_iii+0x12e>
movslq %ecx,%rbx
movslq %edx,%rdx
mov (%r12),%rsi
sub %rdx,%rbx
lea (%rdi,%rbx,4),%rcx
nopl (%rax)
mov (%rsi,%rdx,4),%eax
mov %eax,(%rcx,%rdx,4)
add $0x1,%rdx
cmp %edx,%ebp
jg 16e0 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x120>
sub $0x1,%r14d
movslq %r14d,%r14
mov (%rdi,%r14,4),%r12d
test %rdi,%rdi
je 1703 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x143>
callq 1130 <_ZdlPv@plt>
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
xor %ecx,%ecx
xor %edx,%edx
xor %r10d,%r10d
jmpq 1697 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xd7>
lea 0x8dd(%rip),%rdi
callq 10f0 <_ZSt20__throw_length_errorPKc@plt>
| _Z5func0RSt6vectorIiSaIiEES2_iii:
endbr64
push r15
push r14
push r13
mov r13, rsi
lea esi, [rdx+rcx]
push r12
movsxd rsi, esi
push rbp
mov rax, rsi
push rbx
sub rsp, 18h
shr rax, 3Dh
jnz loc_16A4
mov r15, rdi
mov ebp, edx
mov ebx, ecx
mov r14d, r8d
xor r12d, r12d
test rsi, rsi
jz short loc_1573
lea rcx, ds:0[rsi*4]
mov [rsp+48h+var_48], rsi
mov rdi, rcx; unsigned __int64
mov [rsp+48h+var_40], rcx
call __Znwm; operator new(ulong)
mov rsi, [rsp+48h+var_48]
mov dword ptr [rax], 0
mov r12, rax
cmp rsi, 1
jz loc_1680
mov rcx, [rsp+48h+var_40]
lea rdi, [rax+4]; s
lea rax, [rax+rcx]
cmp rdi, rax
jz loc_169C
xor esi, esi; c
lea rdx, [rcx-4]; n
mov [rsp+48h+var_48], rcx
call _memset
mov rsi, [rsp+48h+var_48]; unsigned __int64
loc_1573:
test ebp, ebp
jle loc_1690
test ebx, ebx
jle loc_1690
mov r10, [r15]
mov r9, [r13+0]
mov eax, 1
xor edx, edx
xor ecx, ecx
jmp short loc_15B2
loc_1598:
mov edi, r8d
add ecx, 1
mov [r12+rax*4-4], edi
lea rdi, [rax+1]
cmp ecx, ebp
jge short loc_15D5
loc_15AB:
cmp edx, ebx
jge short loc_15D5
mov rax, rdi
loc_15B2:
movsxd rdi, ecx
mov r8d, [r10+rdi*4]
movsxd rdi, edx
mov edi, [r9+rdi*4]
cmp edi, r8d
jg short loc_1598
mov [r12+rax*4-4], edi
add edx, 1
lea rdi, [rax+1]
cmp ecx, ebp
jl short loc_15AB
loc_15D5:
mov r8d, eax
loc_15D8:
cmp ebp, ecx
jle short loc_161A
mov rdi, [r15]
movsxd rax, ecx
mov r9d, ebp
sub r9d, ecx
lea r11, [rdi+rax*4]
movsxd rax, r8d
shl r9, 2
lea r10, [r12+rax*4]
xor eax, eax
nop dword ptr [rax+00000000h]
loc_1600:
mov edi, [r11+rax]
mov [r10+rax], edi
add rax, 4
cmp r9, rax
jnz short loc_1600
add ebp, r8d
mov r8d, ebp
sub r8d, ecx
loc_161A:
cmp ebx, edx
jle short loc_164F
mov rax, [r13+0]
sub ebx, edx
movsxd rdx, edx
shl rbx, 2
lea rdi, [rax+rdx*4]
movsxd rax, r8d
lea rcx, [r12+rax*4]
xor eax, eax
nop dword ptr [rax+rax+00000000h]
loc_1640:
mov edx, [rdi+rax]
mov [rcx+rax], edx
add rax, 4
cmp rbx, rax
jnz short loc_1640
loc_164F:
sub r14d, 1
movsxd r14, r14d
mov ebx, [r12+r14*4]
test r12, r12
jz short loc_1667
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1667:
add rsp, 18h
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1680:
mov esi, 4
jmp loc_1573
loc_1690:
xor r8d, r8d
xor edx, edx
xor ecx, ecx
jmp loc_15D8
loc_169C:
mov rsi, rcx
jmp loc_1573
loc_16A4:
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*) | long long func0(long long *a1, long long *a2, int a3, int a4, int a5)
{
unsigned long long v6; // rsi
_DWORD *v11; // r12
_DWORD *v12; // rax
long long v13; // r10
long long v14; // r9
long long v15; // rax
int v16; // edx
int v17; // ecx
long long v18; // rdi
int v19; // r8d
int v20; // edi
int v21; // r8d
long long v22; // r11
long long v23; // rax
long long v24; // rbx
long long v25; // rdi
unsigned long long v26; // rax
unsigned int v27; // ebx
long long v29; // [rsp+8h] [rbp-40h]
v6 = a3 + a4;
if ( v6 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v11 = 0LL;
if ( a3 + a4 )
{
v29 = v6;
v12 = (_DWORD *)operator new(4 * v6);
*v12 = 0;
v11 = v12;
if ( v6 == 1 )
{
v6 = 4LL;
}
else
{
if ( v12 + 1 != &v12[v29] )
memset(v12 + 1, 0, v29 * 4 - 4);
v6 *= 4LL;
}
}
if ( a3 > 0 && a4 > 0 )
{
v13 = *a1;
v14 = *a2;
v15 = 1LL;
v16 = 0;
v17 = 0;
while ( 1 )
{
v19 = *(_DWORD *)(v13 + 4LL * v17);
v20 = *(_DWORD *)(v14 + 4LL * v16);
if ( v20 > v19 )
{
++v17;
v11[v15 - 1] = v19;
v18 = v15 + 1;
if ( v17 >= a3 )
goto LABEL_15;
}
else
{
v11[v15 - 1] = v20;
++v16;
v18 = v15 + 1;
if ( v17 >= a3 )
{
LABEL_15:
v21 = v15;
goto LABEL_16;
}
}
if ( v16 >= a4 )
goto LABEL_15;
v15 = v18;
}
}
v21 = 0;
v16 = 0;
v17 = 0;
LABEL_16:
if ( a3 > v17 )
{
v22 = *a1 + 4LL * v17;
v23 = 0LL;
do
{
v11[v21 + v23] = *(_DWORD *)(v22 + v23 * 4);
++v23;
}
while ( a3 - v17 != v23 );
v21 = v21 + a3 - v17;
}
if ( a4 > v16 )
{
v24 = 4LL * (unsigned int)(a4 - v16);
v25 = *a2 + 4LL * v16;
v26 = 0LL;
do
{
v11[v21 + v26 / 4] = *(_DWORD *)(v25 + v26);
v26 += 4LL;
}
while ( v24 != v26 );
}
v27 = v11[a5 - 1];
if ( v11 )
operator delete(v11, v6);
return v27;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
LEA ESI,[RDX + RCX*0x1]
PUSH R12
MOVSXD RSI,ESI
PUSH RBP
MOV RAX,RSI
PUSH RBX
SUB RSP,0x18
SHR RAX,0x3d
JNZ 0x001016a4
MOV R15,RDI
MOV EBP,EDX
MOV EBX,ECX
MOV R14D,R8D
XOR R12D,R12D
TEST RSI,RSI
JZ 0x00101573
LEA RCX,[RSI*0x4]
MOV qword ptr [RSP],RSI
MOV RDI,RCX
MOV qword ptr [RSP + 0x8],RCX
CALL 0x00101120
MOV RSI,qword ptr [RSP]
MOV dword ptr [RAX],0x0
MOV R12,RAX
CMP RSI,0x1
JZ 0x00101680
MOV RCX,qword ptr [RSP + 0x8]
LEA RDI,[RAX + 0x4]
LEA RAX,[RAX + RCX*0x1]
CMP RDI,RAX
JZ 0x0010169c
XOR ESI,ESI
LEA RDX,[RCX + -0x4]
MOV qword ptr [RSP],RCX
CALL 0x001010f0
MOV RSI,qword ptr [RSP]
LAB_00101573:
TEST EBP,EBP
JLE 0x00101690
TEST EBX,EBX
JLE 0x00101690
MOV R10,qword ptr [R15]
MOV R9,qword ptr [R13]
MOV EAX,0x1
XOR EDX,EDX
XOR ECX,ECX
JMP 0x001015b2
LAB_00101598:
MOV EDI,R8D
ADD ECX,0x1
MOV dword ptr [R12 + RAX*0x4 + -0x4],EDI
LEA RDI,[RAX + 0x1]
CMP ECX,EBP
JGE 0x001015d5
LAB_001015ab:
CMP EDX,EBX
JGE 0x001015d5
MOV RAX,RDI
LAB_001015b2:
MOVSXD RDI,ECX
MOV R8D,dword ptr [R10 + RDI*0x4]
MOVSXD RDI,EDX
MOV EDI,dword ptr [R9 + RDI*0x4]
CMP EDI,R8D
JG 0x00101598
MOV dword ptr [R12 + RAX*0x4 + -0x4],EDI
ADD EDX,0x1
LEA RDI,[RAX + 0x1]
CMP ECX,EBP
JL 0x001015ab
LAB_001015d5:
MOV R8D,EAX
LAB_001015d8:
CMP EBP,ECX
JLE 0x0010161a
MOV RDI,qword ptr [R15]
MOVSXD RAX,ECX
MOV R9D,EBP
SUB R9D,ECX
LEA R11,[RDI + RAX*0x4]
MOVSXD RAX,R8D
SHL R9,0x2
LEA R10,[R12 + RAX*0x4]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101600:
MOV EDI,dword ptr [R11 + RAX*0x1]
MOV dword ptr [R10 + RAX*0x1],EDI
ADD RAX,0x4
CMP R9,RAX
JNZ 0x00101600
ADD EBP,R8D
MOV R8D,EBP
SUB R8D,ECX
LAB_0010161a:
CMP EBX,EDX
JLE 0x0010164f
MOV RAX,qword ptr [R13]
SUB EBX,EDX
MOVSXD RDX,EDX
SHL RBX,0x2
LEA RDI,[RAX + RDX*0x4]
MOVSXD RAX,R8D
LEA RCX,[R12 + RAX*0x4]
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101640:
MOV EDX,dword ptr [RDI + RAX*0x1]
MOV dword ptr [RCX + RAX*0x1],EDX
ADD RAX,0x4
CMP RBX,RAX
JNZ 0x00101640
LAB_0010164f:
SUB R14D,0x1
MOVSXD R14,R14D
MOV EBX,dword ptr [R12 + R14*0x4]
TEST R12,R12
JZ 0x00101667
MOV RDI,R12
CALL 0x00101130
LAB_00101667:
ADD RSP,0x18
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101680:
MOV ESI,0x4
JMP 0x00101573
LAB_00101690:
XOR R8D,R8D
XOR EDX,EDX
XOR ECX,ECX
JMP 0x001015d8
LAB_0010169c:
MOV RSI,RCX
JMP 0x00101573
LAB_001016a4:
LEA RDI,[0x102008]
CALL 0x001010e0 | /* func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int,
int) */
int * func0(vector *param_1,vector *param_2,int param_3,int param_4,int param_5)
{
int *piVar1;
int iVar2;
uint uVar3;
long lVar4;
void *pvVar5;
long lVar6;
int4 *puVar7;
long lVar8;
long lVar9;
int *extraout_RAX;
int *extraout_RAX_00;
int iVar10;
int iVar11;
int *extraout_RDX;
int *piVar12;
int *piVar13;
char *pcVar14;
int iVar15;
ulong uVar16;
piVar12 = (int *)(long)(param_3 + param_4);
if ((ulong)piVar12 >> 0x3d == 0) {
puVar7 = (int4 *)0x0;
piVar13 = piVar12;
if (piVar12 != (int *)0x0) {
piVar13 = (int *)((long)piVar12 * 4);
puVar7 = (int4 *)operator_new((ulong)piVar13);
*puVar7 = 0;
if (piVar12 == (int *)0x1) {
piVar13 = (int *)0x4;
}
else if (puVar7 + 1 != puVar7 + (long)piVar12) {
memset(puVar7 + 1,0,(size_t)(piVar13 + -1));
}
}
if ((param_3 < 1) || (param_4 < 1)) {
iVar15 = 0;
iVar11 = 0;
iVar10 = 0;
}
else {
lVar4 = *(long *)param_1;
lVar9 = *(long *)param_2;
iVar11 = 0;
iVar10 = 0;
lVar6 = 1;
do {
lVar8 = lVar6;
iVar15 = *(int *)(lVar4 + (long)iVar10 * 4);
iVar2 = *(int *)(lVar9 + (long)iVar11 * 4);
if (iVar15 < iVar2) {
iVar10 = iVar10 + 1;
puVar7[lVar8 + -1] = iVar15;
}
else {
puVar7[lVar8 + -1] = iVar2;
iVar11 = iVar11 + 1;
}
} while ((iVar10 < param_3) && (lVar6 = lVar8 + 1, iVar11 < param_4));
iVar15 = (int)lVar8;
}
if (iVar10 < param_3) {
lVar4 = *(long *)param_1;
lVar9 = 0;
do {
*(int4 *)((long)puVar7 + lVar9 + (long)iVar15 * 4) =
*(int4 *)(lVar4 + (long)iVar10 * 4 + lVar9);
lVar9 = lVar9 + 4;
} while ((ulong)(uint)(param_3 - iVar10) << 2 != lVar9);
iVar15 = (param_3 + iVar15) - iVar10;
}
if (iVar11 < param_4) {
lVar4 = *(long *)param_2;
lVar9 = 0;
do {
*(int4 *)((long)puVar7 + lVar9 + (long)iVar15 * 4) =
*(int4 *)(lVar4 + (long)iVar11 * 4 + lVar9);
lVar9 = lVar9 + 4;
} while ((ulong)(uint)(param_4 - iVar11) << 2 != lVar9);
}
uVar3 = puVar7[param_5 + -1];
if (puVar7 != (int4 *)0x0) {
operator_delete(puVar7,(ulong)piVar13);
}
return (int *)(ulong)uVar3;
}
pcVar14 = "cannot create std::vector larger than max_size()";
std::__throw_length_error("cannot create std::vector larger than max_size()");
piVar13 = *(int **)pcVar14;
uVar16 = (long)extraout_RDX - (long)piVar12;
if ((ulong)(*(long *)(pcVar14 + 0x10) - (long)piVar13) < uVar16) {
if (0x7ffffffffffffffc < uVar16) {
pcVar14 = "cannot create std::vector larger than max_size()";
std::__throw_length_error("cannot create std::vector larger than max_size()");
piVar12 = *(int **)pcVar14;
if (piVar12 == (int *)0x0) {
return piVar12;
}
operator_delete(piVar12,*(long *)(pcVar14 + 0x10) - (long)piVar12);
return extraout_RAX_00;
}
piVar13 = (int *)operator_new(uVar16);
piVar12 = std::__copy_move<false,true,std::random_access_iterator_tag>::__copy_m<int_const,int>
(piVar12,extraout_RDX,piVar13);
pvVar5 = *(void **)pcVar14;
if (pvVar5 != (void *)0x0) {
operator_delete(pvVar5,*(long *)(pcVar14 + 0x10) - (long)pvVar5);
piVar12 = extraout_RAX;
}
*(int **)pcVar14 = piVar13;
*(ulong *)(pcVar14 + 8) = (long)piVar13 + uVar16;
*(ulong *)(pcVar14 + 0x10) = (long)piVar13 + uVar16;
}
else {
if ((ulong)(*(long *)(pcVar14 + 8) - (long)piVar13) < uVar16) {
piVar1 = (int *)((long)piVar12 + (*(long *)(pcVar14 + 8) - (long)piVar13));
std::__copy_move<false,true,std::random_access_iterator_tag>::__copy_m<int_const,int>
(piVar12,piVar1,piVar13);
piVar12 = std::__copy_move<false,true,std::random_access_iterator_tag>::
__copy_m<int_const,int>(piVar1,extraout_RDX,*(int **)(pcVar14 + 8));
}
else {
piVar12 = std::__copy_move<false,true,std::random_access_iterator_tag>::
__copy_m<int_const,int>(piVar12,extraout_RDX,piVar13);
if (piVar12 == *(int **)(pcVar14 + 8)) {
return piVar12;
}
}
*(int **)(pcVar14 + 8) = piVar12;
}
return piVar12;
} |
2,387 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| int func0(std::vector<int>& arr1, std::vector<int>& arr2, int m, int n, int k) {
std::vector<int> sorted1(m + n);
int i = 0, j = 0, d = 0;
while (i < m && j < n) {
if (arr1[i] < arr2[j]) {
sorted1[d] = arr1[i];
i++;
} else {
sorted1[d] = arr2[j];
j++;
}
d++;
}
while (i < m) {
sorted1[d] = arr1[i];
i++;
d++;
}
while (j < n) {
sorted1[d] = arr2[j];
j++;
d++;
}
return sorted1[k - 1];
}
| int main() {
std::vector<int> arr1 = {2, 3, 6, 7, 9};
std::vector<int> arr2 = {1, 4, 8, 10};
assert(func0(arr1, arr2, 5, 4, 5) == 6);
arr1 = {100, 112, 256, 349, 770};
arr2 = {72, 86, 113, 119, 265, 445, 892};
assert(func0(arr1, arr2, 5, 7, 7) == 256);
arr1 = {3, 4, 7, 8, 10};
arr2 = {2, 5, 9, 11};
assert(func0(arr1, arr2, 5, 4, 6) == 8);
std::cout << "All tests passed successfully.\n";
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %edx,%ebx
add %ecx,%edx
movslq %edx,%rdx
sub $0x8,%rsp
cmp %rax,%rdx
ja 1874 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x304>
mov %rdi,%r14
mov %rsi,%r13
mov %ecx,%ebp
mov %r8d,%r12d
xor %edi,%edi
test %rdx,%rdx
je 15ce <_Z5func0RSt6vectorIiSaIiEES2_iii+0x5e>
lea 0x0(,%rdx,4),%r15
mov %r15,%rdi
callq 1170 <_Znwm@plt>
mov %r15,%rdx
xor %esi,%esi
mov %rax,%rdi
callq 1110 <memset@plt>
mov %rax,%rdi
test %ebp,%ebp
jle 1648 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xd8>
test %ebx,%ebx
jle 1648 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xd8>
mov (%r14),%r11
mov 0x0(%r13),%r10
mov $0x1,%eax
xor %edx,%edx
xor %esi,%esi
xor %r9d,%r9d
xor %r8d,%r8d
nopl 0x0(%rax)
mov (%r11,%r9,4),%r15d
mov (%r10,%r8,4),%ecx
cmp %r15d,%ecx
jle 1627 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xb7>
mov %r15d,-0x4(%rdi,%rax,4)
mov %eax,%ecx
add $0x1,%esi
add $0x1,%rax
cmp %edx,%ebp
jle 1650 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xe0>
cmp %esi,%ebx
jle 172f <_Z5func0RSt6vectorIiSaIiEES2_iii+0x1bf>
movslq %esi,%r9
mov (%r10,%r8,4),%ecx
mov (%r11,%r9,4),%r15d
cmp %r15d,%ecx
jg 15fd <_Z5func0RSt6vectorIiSaIiEES2_iii+0x8d>
mov %ecx,-0x4(%rdi,%rax,4)
add $0x1,%edx
mov %eax,%ecx
add $0x1,%rax
cmp %esi,%ebx
jle 172f <_Z5func0RSt6vectorIiSaIiEES2_iii+0x1bf>
cmp %edx,%ebp
jle 1650 <_Z5func0RSt6vectorIiSaIiEES2_iii+0xe0>
movslq %edx,%r8
jmp 15f0 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x80>
nopl (%rax)
xor %ecx,%ecx
xor %edx,%edx
xor %esi,%esi
xchg %ax,%ax
cmp %esi,%ebx
jle 172f <_Z5func0RSt6vectorIiSaIiEES2_iii+0x1bf>
mov (%r14),%r11
movslq %ecx,%r8
movslq %esi,%rax
lea 0x0(,%rax,4),%r15
lea 0x0(,%r8,4),%r14
lea (%r11,%r15,1),%r9
lea (%rdi,%r14,1),%r10
lea 0x10(%r11,%r15,1),%r15
lea 0x10(%rdi,%r8,4),%r8
cmp %r15,%r10
setae %r15b
cmp %r8,%r9
setae %r8b
or %r8b,%r15b
je 1820 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x2b0>
lea -0x1(%rbx),%r8d
sub %esi,%r8d
cmp $0x3,%r8d
jbe 1820 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x2b0>
mov %ebx,%r14d
xor %eax,%eax
sub %esi,%r14d
mov %r14d,%r8d
shr $0x2,%r8d
shl $0x4,%r8
xchg %ax,%ax
movdqu (%r9,%rax,1),%xmm0
movups %xmm0,(%r10,%rax,1)
add $0x10,%rax
cmp %r8,%rax
jne 16c0 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x150>
mov %r14d,%r9d
and $0xfffffffc,%r9d
lea (%rsi,%r9,1),%eax
lea (%rcx,%r9,1),%r8d
cmp %r9d,%r14d
je 172b <_Z5func0RSt6vectorIiSaIiEES2_iii+0x1bb>
movslq %eax,%r9
mov (%r11,%r9,4),%r10d
movslq %r8d,%r9
add $0x1,%r8d
mov %r10d,(%rdi,%r9,4)
lea 0x1(%rax),%r9d
cmp %r9d,%ebx
jle 172b <_Z5func0RSt6vectorIiSaIiEES2_iii+0x1bb>
movslq %r9d,%r9
movslq %r8d,%r8
add $0x2,%eax
mov (%r11,%r9,4),%r9d
lea 0x0(,%r8,4),%r10
mov %r9d,(%rdi,%r8,4)
cmp %ebx,%eax
jge 172b <_Z5func0RSt6vectorIiSaIiEES2_iii+0x1bb>
cltq
mov (%r11,%rax,4),%eax
mov %eax,0x4(%rdi,%r10,1)
add %ebx,%ecx
sub %esi,%ecx
cmp %edx,%ebp
jle 17f0 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x280>
mov 0x0(%r13),%r9
movslq %ecx,%rsi
movslq %edx,%rax
shl $0x2,%rsi
lea 0x10(%rdi,%rsi,1),%r11
lea (%r9,%rax,4),%r10
cmp %r11,%r10
lea (%rdi,%rsi,1),%r8
lea 0x10(%r9,%rax,4),%r11
setae %bl
cmp %r11,%r8
setae %r11b
or %r11b,%bl
je 1850 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x2e0>
lea -0x1(%rbp),%r11d
sub %edx,%r11d
cmp $0x3,%r11d
jbe 1850 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x2e0>
mov %ebp,%r11d
xor %eax,%eax
sub %edx,%r11d
mov %r11d,%esi
shr $0x2,%esi
shl $0x4,%rsi
movdqu (%r10,%rax,1),%xmm1
movups %xmm1,(%r8,%rax,1)
add $0x10,%rax
cmp %rsi,%rax
jne 1790 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x220>
mov %r11d,%eax
and $0xfffffffc,%eax
add %eax,%edx
add %eax,%ecx
cmp %eax,%r11d
je 17f0 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x280>
movslq %edx,%rax
mov (%r9,%rax,4),%esi
movslq %ecx,%rax
add $0x1,%ecx
mov %esi,(%rdi,%rax,4)
lea 0x1(%rdx),%eax
cmp %eax,%ebp
jle 17f0 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x280>
cltq
movslq %ecx,%rcx
add $0x2,%edx
mov (%r9,%rax,4),%eax
lea 0x0(,%rcx,4),%rsi
mov %eax,(%rdi,%rcx,4)
cmp %edx,%ebp
jle 17f0 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x280>
movslq %edx,%rdx
mov (%r9,%rdx,4),%eax
mov %eax,0x4(%rdi,%rsi,1)
sub $0x1,%r12d
movslq %r12d,%r12
mov (%rdi,%r12,4),%r12d
test %rdi,%rdi
je 1805 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x295>
callq 1150 <_ZdlPv@plt>
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov %rax,%r8
neg %r8
lea (%r14,%r8,4),%r9
add %rdi,%r9
nopl (%rax)
mov (%r11,%rax,4),%r8d
mov %r8d,(%r9,%rax,4)
add $0x1,%rax
cmp %eax,%ebx
jg 1830 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x2c0>
add %ebx,%ecx
sub %esi,%ecx
jmpq 172f <_Z5func0RSt6vectorIiSaIiEES2_iii+0x1bf>
nopl 0x0(%rax)
mov %rax,%rdx
neg %rdx
lea (%rsi,%rdx,4),%rcx
add %rdi,%rcx
nopl (%rax)
mov (%r9,%rax,4),%edx
mov %edx,(%rcx,%rax,4)
add $0x1,%rax
cmp %eax,%ebp
jg 1860 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x2f0>
jmpq 17f0 <_Z5func0RSt6vectorIiSaIiEES2_iii+0x280>
lea 0x78d(%rip),%rdi
callq 1100 <_ZSt20__throw_length_errorPKc@plt>
| _Z5func0RSt6vectorIiSaIiEES2_iii:
endbr64
push r15
push r14
push r13
lea r13d, [rdx+rcx]
push r12
movsxd r13, r13d
push rbp
mov rax, r13
push rbx
sub rsp, 18h
shr rax, 3Dh
mov [rsp+48h+var_48], rsi
mov [rsp+48h+var_3C], r8d
jnz loc_1963
mov r14, rdi
mov ebp, edx
mov r12d, ecx
xor ebx, ebx
test r13, r13
jz short loc_1680
lea r15, ds:0[r13*4]
mov rdi, r15; unsigned __int64
call __Znwm; operator new(ulong)
mov dword ptr [rax], 0
mov rbx, rax
cmp r13, 1
jz loc_1950
lea rdi, [rax+4]; s
lea rax, [rax+r15]
cmp rdi, rax
jz loc_195B
lea rdx, [r15-4]; n
xor esi, esi; c
mov r13, r15
call _memset
loc_1680:
test ebp, ebp
jle short loc_1700
test r12d, r12d
jle short loc_1700
mov rax, [rsp+48h+var_48]
mov r11, [r14]
xor edx, edx
xor ecx, ecx
xor esi, esi
xor r9d, r9d
mov r10, [rax]
mov eax, 1
nop dword ptr [rax+00000000h]
loc_16A8:
mov r8d, [r11+rsi*4]
mov edi, [r10+r9*4]
cmp edi, r8d
jle short loc_16DD
loc_16B5:
mov [rbx+rax*4-4], r8d
add ecx, 1
lea rsi, [rax+1]
cmp r12d, edx
jle short loc_1710
cmp ebp, ecx
jle short loc_1710
mov rax, rsi
movsxd rsi, ecx
mov edi, [r10+r9*4]
mov r8d, [r11+rsi*4]
cmp edi, r8d
jg short loc_16B5
loc_16DD:
mov [rbx+rax*4-4], edi
add edx, 1
lea rdi, [rax+1]
cmp ebp, ecx
jle short loc_1710
cmp r12d, edx
jle short loc_1710
mov rax, rdi
movsxd r9, edx
jmp short loc_16A8
loc_1700:
xor eax, eax
xor edx, edx
xor ecx, ecx
nop word ptr [rax+rax+00000000h]
loc_1710:
cmp ebp, ecx
jle short loc_177B
mov r8d, ebp
mov r10, [r14]
sub r8d, ecx
lea esi, [r8-1]
cmp esi, 2
jbe loc_1940
movsxd rdi, eax
movsxd rsi, ecx
lea r9, [rbx+rdi*4]
lea r11, ds:4[rsi*4]
lea r15, [r10+r11]
mov r14, r9
sub r14, r15
cmp r14, 8
ja loc_1810
loc_1750:
mov r9d, r8d
lea r10, [r10+rsi*4]
lea rdi, [rbx+rdi*4]
xor ecx, ecx
shl r9, 2
nop dword ptr [rax+00000000h]
loc_1768:
mov esi, [r10+rcx]
mov [rdi+rcx], esi
add rcx, 4
cmp r9, rcx
jnz short loc_1768
loc_1778:
add eax, r8d
loc_177B:
cmp r12d, edx
jle short loc_17E0
mov esi, r12d
mov rdi, [rsp+48h+var_48]
movsxd r9, edx
sub esi, edx
lea ecx, [rsi-1]
mov r8, [rdi]
movsxd rdi, eax
cmp ecx, 2
jbe short loc_17C0
movsxd rdi, eax
movsxd r9, edx
lea r10, [rbx+rdi*4]
lea rcx, ds:4[r9*4]
lea rbp, [r8+rcx]
mov r11, r10
sub r11, rbp
cmp r11, 8
ja loc_18B0
loc_17C0:
mov edx, esi
lea r8, [r8+r9*4]
lea rsi, [rbx+rdi*4]
xor eax, eax
shl rdx, 2
loc_17D0:
mov ecx, [r8+rax]
mov [rsi+rax], ecx
add rax, 4
cmp rax, rdx
jnz short loc_17D0
loc_17E0:
mov eax, [rsp+48h+var_3C]
sub eax, 1
cdqe
mov ebp, [rbx+rax*4]
test rbx, rbx
jz short loc_17FC
mov rsi, r13; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_17FC:
add rsp, 18h
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1810:
mov edi, r8d
lea r11, [r10+r11-4]
xor esi, esi
shr edi, 2
shl rdi, 4
nop dword ptr [rax+00000000h]
loc_1828:
movdqu xmm0, xmmword ptr [r11+rsi]
movups xmmword ptr [r9+rsi], xmm0
add rsi, 10h
cmp rsi, rdi
jnz short loc_1828
mov esi, r8d
and esi, 0FFFFFFFCh
add ecx, esi
add esi, eax
test r8b, 3
jz loc_1778
movsxd rdi, ecx
mov r9d, [r10+rdi*4]
movsxd rdi, esi
add esi, 1
mov [rbx+rdi*4], r9d
lea edi, [rcx+1]
cmp ebp, edi
jle loc_1778
movsxd rdi, edi
movsxd rsi, esi
add ecx, 2
lea r9, ds:0[rdi*4]
mov edi, [r10+rdi*4]
lea r11, ds:0[rsi*4]
mov [rbx+rsi*4], edi
cmp ecx, ebp
jge loc_1778
mov ecx, [r10+r9+4]
add eax, r8d
mov [rbx+r11+4], ecx
jmp loc_177B
loc_18B0:
mov edi, esi
lea r9, [r8+rcx-4]
xor ecx, ecx
shr edi, 2
shl rdi, 4
loc_18C0:
movdqu xmm1, xmmword ptr [r9+rcx]
movups xmmword ptr [r10+rcx], xmm1
add rcx, 10h
cmp rdi, rcx
jnz short loc_18C0
mov ecx, esi
and ecx, 0FFFFFFFCh
add edx, ecx
add eax, ecx
and esi, 3
jz loc_17E0
movsxd rcx, edx
mov esi, [r8+rcx*4]
movsxd rcx, eax
add eax, 1
mov [rbx+rcx*4], esi
lea ecx, [rdx+1]
cmp r12d, ecx
jle loc_17E0
movsxd rcx, ecx
cdqe
add edx, 2
lea rdi, ds:0[rcx*4]
mov ecx, [r8+rcx*4]
lea rsi, ds:0[rax*4]
mov [rbx+rax*4], ecx
cmp r12d, edx
jle loc_17E0
mov eax, [r8+rdi+4]
mov [rbx+rsi+4], eax
jmp loc_17E0
loc_1940:
movsxd rsi, ecx
movsxd rdi, eax
jmp loc_1750
loc_1950:
mov r13d, 4
jmp loc_1680
loc_195B:
mov r13, r15
jmp loc_1680
loc_1963:
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*) | long long func0(long long *a1, long long *a2, int a3, int a4, int a5)
{
unsigned long long v5; // r13
_DWORD *v9; // rbx
long long v10; // r15
_DWORD *v11; // rax
long long v12; // r11
int v13; // edx
int v14; // ecx
long long v15; // rsi
long long v16; // r9
long long v17; // r10
long long i; // rax
int v19; // r8d
int v20; // edi
long long v21; // r10
unsigned int v22; // r8d
long long v23; // rdi
long long v24; // rsi
long long v25; // r10
char *v26; // rdi
long long v27; // rcx
long long v28; // r9
unsigned int v29; // esi
long long v30; // r8
long long v31; // rdi
long long v32; // r8
long long v33; // rax
unsigned int v34; // ebp
long long v36; // rsi
signed int v37; // ecx
int v38; // esi
long long v39; // rdi
int v40; // esi
long long v41; // r9
long long v42; // rcx
signed int v43; // edx
int v44; // eax
long long v45; // rcx
int v46; // eax
long long v47; // rdi
v5 = a3 + a4;
if ( v5 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v9 = 0LL;
if ( a3 + a4 )
{
v10 = v5;
v11 = (_DWORD *)operator new(4 * v5);
*v11 = 0;
v9 = v11;
if ( v5 == 1 )
{
v5 = 4LL;
}
else
{
v5 *= 4LL;
if ( v11 + 1 != &v11[v10] )
memset(v11 + 1, 0, v10 * 4 - 4);
}
}
if ( a3 <= 0 || a4 <= 0 )
{
LODWORD(i) = 0;
v13 = 0;
v14 = 0;
}
else
{
v12 = *a1;
v13 = 0;
v14 = 0;
v15 = 0LL;
v16 = 0LL;
v17 = *a2;
for ( i = 1LL; ; ++i )
{
v19 = *(_DWORD *)(v12 + 4 * v15);
v20 = *(_DWORD *)(v17 + 4 * v16);
if ( v20 > v19 )
break;
LABEL_13:
v9[i - 1] = v20;
++v13;
if ( a3 <= v14 || a4 <= v13 )
goto LABEL_17;
v16 = v13;
}
while ( 1 )
{
v9[i - 1] = v19;
++v14;
if ( a4 <= v13 || a3 <= v14 )
break;
++i;
v15 = v14;
v20 = *(_DWORD *)(v17 + 4 * v16);
v19 = *(_DWORD *)(v12 + 4LL * v14);
if ( v20 <= v19 )
goto LABEL_13;
}
}
LABEL_17:
if ( a3 > v14 )
{
v21 = *a1;
v22 = a3 - v14;
if ( (unsigned int)(a3 - v14 - 1) <= 2 )
{
v24 = v14;
v23 = (int)i;
LABEL_20:
v25 = v21 + 4 * v24;
v26 = (char *)&v9[v23];
v27 = 0LL;
do
{
*(_DWORD *)&v26[v27] = *(_DWORD *)(v25 + v27);
v27 += 4LL;
}
while ( 4LL * v22 != v27 );
LABEL_22:
LODWORD(i) = v22 + i;
goto LABEL_23;
}
v23 = (int)i;
v24 = v14;
if ( (unsigned long long)&v9[(int)i - 1] - v21 + -4 * v14 <= 8 )
goto LABEL_20;
v36 = 0LL;
do
{
*(__m128i *)&v9[(int)i + v36] = _mm_loadu_si128((const __m128i *)(v21 + 4LL * v14 + v36 * 4));
v36 += 4LL;
}
while ( v36 != 4LL * (v22 >> 2) );
v37 = (v22 & 0xFFFFFFFC) + v14;
v38 = i + (v22 & 0xFFFFFFFC);
if ( (v22 & 3) == 0 )
goto LABEL_22;
v39 = v38;
v40 = v38 + 1;
v9[v39] = *(_DWORD *)(v21 + 4LL * v37);
if ( a3 <= v37 + 1 )
goto LABEL_22;
v41 = 4LL * (v37 + 1);
v9[v40] = *(_DWORD *)(v21 + v41);
if ( v37 + 2 >= a3 )
goto LABEL_22;
LODWORD(i) = v22 + i;
v9[v40 + 1] = *(_DWORD *)(v21 + v41 + 4);
}
LABEL_23:
if ( a4 > v13 )
{
v28 = v13;
v29 = a4 - v13;
v30 = *a2;
v31 = (int)i;
if ( (unsigned int)(a4 - v13 - 1) > 2
&& (v31 = (int)i, v28 = v13, (unsigned long long)&v9[(int)i - 1] - v30 + -4 * v13 > 8) )
{
v42 = 0LL;
do
{
*(__m128i *)&v9[(int)i + v42] = _mm_loadu_si128((const __m128i *)(v30 + 4LL * v13 + v42 * 4));
v42 += 4LL;
}
while ( 4LL * (v29 >> 2) != v42 );
v43 = (v29 & 0xFFFFFFFC) + v13;
v44 = (v29 & 0xFFFFFFFC) + i;
if ( (v29 & 3) != 0 )
{
v45 = v44;
v46 = v44 + 1;
v9[v45] = *(_DWORD *)(v30 + 4LL * v43);
if ( a4 > v43 + 1 )
{
v47 = 4LL * (v43 + 1);
v9[v46] = *(_DWORD *)(v30 + v47);
if ( a4 > v43 + 2 )
v9[v46 + 1] = *(_DWORD *)(v30 + v47 + 4);
}
}
}
else
{
v32 = v30 + 4 * v28;
v33 = 0LL;
do
{
v9[v31 + v33] = *(_DWORD *)(v32 + v33 * 4);
++v33;
}
while ( v33 != v29 );
}
}
v34 = v9[a5 - 1];
if ( v9 )
operator delete(v9, v5);
return v34;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
LEA R13D,[RDX + RCX*0x1]
PUSH R12
MOVSXD R13,R13D
PUSH RBP
MOV RAX,R13
PUSH RBX
SUB RSP,0x18
SHR RAX,0x3d
MOV qword ptr [RSP],RSI
MOV dword ptr [RSP + 0xc],R8D
JNZ 0x00101963
MOV R14,RDI
MOV EBP,EDX
MOV R12D,ECX
XOR EBX,EBX
TEST R13,R13
JZ 0x00101680
LEA R15,[R13*0x4]
MOV RDI,R15
CALL 0x00101120
MOV dword ptr [RAX],0x0
MOV RBX,RAX
CMP R13,0x1
JZ 0x00101950
LEA RDI,[RAX + 0x4]
LEA RAX,[RAX + R15*0x1]
CMP RDI,RAX
JZ 0x0010195b
LEA RDX,[R15 + -0x4]
XOR ESI,ESI
MOV R13,R15
CALL 0x001010f0
LAB_00101680:
TEST EBP,EBP
JLE 0x00101700
TEST R12D,R12D
JLE 0x00101700
MOV RAX,qword ptr [RSP]
MOV R11,qword ptr [R14]
XOR EDX,EDX
XOR ECX,ECX
XOR ESI,ESI
XOR R9D,R9D
MOV R10,qword ptr [RAX]
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_001016a8:
MOV R8D,dword ptr [R11 + RSI*0x4]
MOV EDI,dword ptr [R10 + R9*0x4]
CMP EDI,R8D
JLE 0x001016dd
LAB_001016b5:
MOV dword ptr [RBX + RAX*0x4 + -0x4],R8D
ADD ECX,0x1
LEA RSI,[RAX + 0x1]
CMP R12D,EDX
JLE 0x00101710
CMP EBP,ECX
JLE 0x00101710
MOV RAX,RSI
MOVSXD RSI,ECX
MOV EDI,dword ptr [R10 + R9*0x4]
MOV R8D,dword ptr [R11 + RSI*0x4]
CMP EDI,R8D
JG 0x001016b5
LAB_001016dd:
MOV dword ptr [RBX + RAX*0x4 + -0x4],EDI
ADD EDX,0x1
LEA RDI,[RAX + 0x1]
CMP EBP,ECX
JLE 0x00101710
CMP R12D,EDX
JLE 0x00101710
MOV RAX,RDI
MOVSXD R9,EDX
JMP 0x001016a8
LAB_00101700:
XOR EAX,EAX
XOR EDX,EDX
XOR ECX,ECX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101710:
CMP EBP,ECX
JLE 0x0010177b
MOV R8D,EBP
MOV R10,qword ptr [R14]
SUB R8D,ECX
LEA ESI,[R8 + -0x1]
CMP ESI,0x2
JBE 0x00101940
MOVSXD RDI,EAX
MOVSXD RSI,ECX
LEA R9,[RBX + RDI*0x4]
LEA R11,[0x4 + RSI*0x4]
LEA R15,[R10 + R11*0x1]
MOV R14,R9
SUB R14,R15
CMP R14,0x8
JA 0x00101810
LAB_00101750:
MOV R9D,R8D
LEA R10,[R10 + RSI*0x4]
LEA RDI,[RBX + RDI*0x4]
XOR ECX,ECX
SHL R9,0x2
NOP dword ptr [RAX]
LAB_00101768:
MOV ESI,dword ptr [R10 + RCX*0x1]
MOV dword ptr [RDI + RCX*0x1],ESI
ADD RCX,0x4
CMP R9,RCX
JNZ 0x00101768
LAB_00101778:
ADD EAX,R8D
LAB_0010177b:
CMP R12D,EDX
JLE 0x001017e0
MOV ESI,R12D
MOV RDI,qword ptr [RSP]
MOVSXD R9,EDX
SUB ESI,EDX
LEA ECX,[RSI + -0x1]
MOV R8,qword ptr [RDI]
MOVSXD RDI,EAX
CMP ECX,0x2
JBE 0x001017c0
MOVSXD RDI,EAX
MOVSXD R9,EDX
LEA R10,[RBX + RDI*0x4]
LEA RCX,[0x4 + R9*0x4]
LEA RBP,[R8 + RCX*0x1]
MOV R11,R10
SUB R11,RBP
CMP R11,0x8
JA 0x001018b0
LAB_001017c0:
MOV EDX,ESI
LEA R8,[R8 + R9*0x4]
LEA RSI,[RBX + RDI*0x4]
XOR EAX,EAX
SHL RDX,0x2
LAB_001017d0:
MOV ECX,dword ptr [R8 + RAX*0x1]
MOV dword ptr [RSI + RAX*0x1],ECX
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001017d0
LAB_001017e0:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x1
CDQE
MOV EBP,dword ptr [RBX + RAX*0x4]
TEST RBX,RBX
JZ 0x001017fc
MOV RSI,R13
MOV RDI,RBX
CALL 0x00101130
LAB_001017fc:
ADD RSP,0x18
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101810:
MOV EDI,R8D
LEA R11,[R10 + R11*0x1 + -0x4]
XOR ESI,ESI
SHR EDI,0x2
SHL RDI,0x4
NOP dword ptr [RAX]
LAB_00101828:
MOVDQU XMM0,xmmword ptr [R11 + RSI*0x1]
MOVUPS xmmword ptr [R9 + RSI*0x1],XMM0
ADD RSI,0x10
CMP RSI,RDI
JNZ 0x00101828
MOV ESI,R8D
AND ESI,0xfffffffc
ADD ECX,ESI
ADD ESI,EAX
TEST R8B,0x3
JZ 0x00101778
MOVSXD RDI,ECX
MOV R9D,dword ptr [R10 + RDI*0x4]
MOVSXD RDI,ESI
ADD ESI,0x1
MOV dword ptr [RBX + RDI*0x4],R9D
LEA EDI,[RCX + 0x1]
CMP EBP,EDI
JLE 0x00101778
MOVSXD RDI,EDI
MOVSXD RSI,ESI
ADD ECX,0x2
LEA R9,[RDI*0x4]
MOV EDI,dword ptr [R10 + RDI*0x4]
LEA R11,[RSI*0x4]
MOV dword ptr [RBX + RSI*0x4],EDI
CMP ECX,EBP
JGE 0x00101778
MOV ECX,dword ptr [R10 + R9*0x1 + 0x4]
ADD EAX,R8D
MOV dword ptr [RBX + R11*0x1 + 0x4],ECX
JMP 0x0010177b
LAB_001018b0:
MOV EDI,ESI
LEA R9,[R8 + RCX*0x1 + -0x4]
XOR ECX,ECX
SHR EDI,0x2
SHL RDI,0x4
LAB_001018c0:
MOVDQU XMM1,xmmword ptr [R9 + RCX*0x1]
MOVUPS xmmword ptr [R10 + RCX*0x1],XMM1
ADD RCX,0x10
CMP RDI,RCX
JNZ 0x001018c0
MOV ECX,ESI
AND ECX,0xfffffffc
ADD EDX,ECX
ADD EAX,ECX
AND ESI,0x3
JZ 0x001017e0
MOVSXD RCX,EDX
MOV ESI,dword ptr [R8 + RCX*0x4]
MOVSXD RCX,EAX
ADD EAX,0x1
MOV dword ptr [RBX + RCX*0x4],ESI
LEA ECX,[RDX + 0x1]
CMP R12D,ECX
JLE 0x001017e0
MOVSXD RCX,ECX
CDQE
ADD EDX,0x2
LEA RDI,[RCX*0x4]
MOV ECX,dword ptr [R8 + RCX*0x4]
LEA RSI,[RAX*0x4]
MOV dword ptr [RBX + RAX*0x4],ECX
CMP R12D,EDX
JLE 0x001017e0
MOV EAX,dword ptr [R8 + RDI*0x1 + 0x4]
MOV dword ptr [RBX + RSI*0x1 + 0x4],EAX
JMP 0x001017e0
LAB_00101940:
MOVSXD RSI,ECX
MOVSXD RDI,EAX
JMP 0x00101750
LAB_00101950:
MOV R13D,0x4
JMP 0x00101680
LAB_0010195b:
MOV R13,R15
JMP 0x00101680
LAB_00101963:
LEA RDI,[0x102008]
CALL 0x001010e0
NOP | /* func0(std::vector<int, std::allocator<int> >&, std::vector<int, std::allocator<int> >&, int, int,
int) */
void * func0(vector *param_1,vector *param_2,int param_3,int param_4,int param_5)
{
int iVar1;
int8 *puVar2;
int8 *puVar3;
long lVar4;
void *pvVar5;
int8 uVar6;
int iVar7;
int4 *puVar8;
long lVar9;
long lVar10;
long lVar11;
void *extraout_RAX;
int iVar12;
long lVar13;
int iVar14;
int iVar15;
long lVar16;
char *pcVar17;
uint uVar18;
long lVar19;
ulong uVar20;
ulong uVar21;
uVar20 = (ulong)(param_3 + param_4);
if (uVar20 >> 0x3d != 0) {
pcVar17 = s_cannot_create_std__vector_larger_00102008;
std::__throw_length_error(s_cannot_create_std__vector_larger_00102008);
pvVar5 = *(void **)pcVar17;
if (pvVar5 == (void *)0x0) {
return pvVar5;
}
operator_delete(pvVar5,*(long *)(pcVar17 + 0x10) - (long)pvVar5);
return extraout_RAX;
}
puVar8 = (int4 *)0x0;
uVar21 = uVar20;
if (uVar20 != 0) {
uVar21 = uVar20 * 4;
puVar8 = (int4 *)operator_new(uVar21);
*puVar8 = 0;
if (uVar20 == 1) {
uVar21 = 4;
}
else if (puVar8 + 1 != puVar8 + uVar20) {
memset(puVar8 + 1,0,uVar21 - 4);
}
}
if ((param_3 < 1) || (param_4 < 1)) {
lVar11 = 0;
iVar14 = 0;
iVar12 = 0;
}
else {
lVar13 = *(long *)param_1;
iVar14 = 0;
iVar12 = 0;
lVar16 = 0;
lVar19 = 0;
lVar4 = *(long *)param_2;
lVar9 = 1;
while( true ) {
iVar7 = *(int *)(lVar13 + lVar16 * 4);
iVar15 = *(int *)(lVar4 + lVar19 * 4);
lVar10 = lVar9;
if (iVar7 < iVar15) {
do {
puVar8[lVar9 + -1] = iVar7;
iVar12 = iVar12 + 1;
lVar10 = lVar9 + 1;
lVar11 = lVar9;
if ((param_4 <= iVar14) || (param_3 <= iVar12)) goto LAB_00101710;
lVar16 = (long)iVar12;
iVar15 = *(int *)(lVar4 + lVar19 * 4);
iVar7 = *(int *)(lVar13 + lVar16 * 4);
lVar9 = lVar10;
} while (iVar7 < iVar15);
}
puVar8[lVar10 + -1] = iVar15;
iVar14 = iVar14 + 1;
lVar9 = lVar10 + 1;
lVar11 = lVar10;
if ((param_3 <= iVar12) || (param_4 <= iVar14)) break;
lVar19 = (long)iVar14;
}
}
LAB_00101710:
iVar7 = (int)lVar11;
if (iVar12 < param_3) {
lVar11 = *(long *)param_1;
uVar18 = param_3 - iVar12;
if (uVar18 - 1 < 3) {
LAB_00101750:
lVar9 = 0;
do {
*(int4 *)((long)puVar8 + lVar9 + (long)iVar7 * 4) =
*(int4 *)(lVar11 + (long)iVar12 * 4 + lVar9);
lVar9 = lVar9 + 4;
} while ((ulong)uVar18 << 2 != lVar9);
}
else {
lVar9 = (long)iVar12 * 4 + 4;
if ((ulong)((long)puVar8 + ((long)iVar7 * 4 - (lVar11 + lVar9))) < 9) goto LAB_00101750;
lVar13 = 0;
do {
puVar2 = (int8 *)(lVar11 + -4 + lVar9 + lVar13);
uVar6 = puVar2[1];
puVar3 = (int8 *)((long)puVar8 + lVar13 + (long)iVar7 * 4);
*puVar3 = *puVar2;
puVar3[1] = uVar6;
lVar13 = lVar13 + 0x10;
} while (lVar13 != (ulong)(uVar18 >> 2) << 4);
iVar12 = iVar12 + (uVar18 & 0xfffffffc);
iVar15 = (uVar18 & 0xfffffffc) + iVar7;
if ((uVar18 & 3) != 0) {
puVar8[iVar15] = *(int4 *)(lVar11 + (long)iVar12 * 4);
iVar1 = iVar12 + 1;
if (iVar1 < param_3) {
lVar9 = (long)(iVar15 + 1);
puVar8[lVar9] = *(int4 *)(lVar11 + (long)iVar1 * 4);
if (iVar12 + 2 < param_3) {
iVar7 = iVar7 + uVar18;
puVar8[lVar9 + 1] = *(int4 *)(lVar11 + 4 + (long)iVar1 * 4);
goto LAB_0010177b;
}
}
}
}
iVar7 = iVar7 + uVar18;
}
LAB_0010177b:
if (iVar14 < param_4) {
uVar18 = param_4 - iVar14;
lVar11 = *(long *)param_2;
if (2 < uVar18 - 1) {
lVar9 = (long)iVar14 * 4 + 4;
if (8 < (ulong)((long)puVar8 + ((long)iVar7 * 4 - (lVar11 + lVar9)))) {
lVar13 = 0;
do {
puVar2 = (int8 *)(lVar11 + -4 + lVar9 + lVar13);
uVar6 = puVar2[1];
puVar3 = (int8 *)((long)puVar8 + lVar13 + (long)iVar7 * 4);
*puVar3 = *puVar2;
puVar3[1] = uVar6;
lVar13 = lVar13 + 0x10;
} while ((ulong)(uVar18 >> 2) << 4 != lVar13);
iVar14 = iVar14 + (uVar18 & 0xfffffffc);
iVar7 = iVar7 + (uVar18 & 0xfffffffc);
if ((uVar18 & 3) != 0) {
puVar8[iVar7] = *(int4 *)(lVar11 + (long)iVar14 * 4);
iVar12 = iVar14 + 1;
if (iVar12 < param_4) {
lVar9 = (long)(iVar7 + 1);
puVar8[lVar9] = *(int4 *)(lVar11 + (long)iVar12 * 4);
if (iVar14 + 2 < param_4) {
puVar8[lVar9 + 1] = *(int4 *)(lVar11 + 4 + (long)iVar12 * 4);
}
}
}
goto LAB_001017e0;
}
}
lVar9 = 0;
do {
*(int4 *)((long)puVar8 + lVar9 + (long)iVar7 * 4) =
*(int4 *)(lVar11 + (long)iVar14 * 4 + lVar9);
lVar9 = lVar9 + 4;
} while (lVar9 != (ulong)uVar18 << 2);
}
LAB_001017e0:
uVar18 = puVar8[param_5 + -1];
if (puVar8 != (int4 *)0x0) {
operator_delete(puVar8,uVar21);
}
return (void *)(ulong)uVar18;
} |
2,388 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| bool func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while(temp > 0) {
times++;
temp /= 10;
}
temp = number;
while(temp > 0) {
int reminder = temp % 10;
sum += std::pow(reminder, times);
temp /= 10;
}
if(number == sum) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(153) == true);
assert(func0(259) == false);
assert(func0(4458) == false);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jle 11f6 <_Z5func0i+0x4d>
addl $0x1,-0xc(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x8(%rbp)
jmp 11cc <_Z5func0i+0x23>
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
jle 126e <_Z5func0i+0xc5>
mov -0x8(%rbp),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
shl $0x2,%eax
add %ecx,%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x4(%rbp)
mov -0xc(%rbp),%edx
mov -0x4(%rbp),%eax
mov %edx,%esi
mov %eax,%edi
callq 138a <_ZSt3powIiiEN9__gnu_cxx11__promote_2IT_T0_NS0_9__promoteIS2_XsrSt12__is_integerIS2_E7__valueEE6__typeENS4_IS3_XsrS5_IS3_E7__valueEE6__typeEE6__typeES2_S3_>
cvtsi2sdl -0x10(%rbp),%xmm1
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov %eax,-0x10(%rbp)
mov -0x8(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x8(%rbp)
jmp 11fc <_Z5func0i+0x53>
mov -0x14(%rbp),%eax
cmp -0x10(%rbp),%eax
jne 127d <_Z5func0i+0xd4>
mov $0x1,%eax
jmp 1282 <_Z5func0i+0xd9>
mov $0x0,%eax
leaveq
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
jmp short loc_11B0
loc_118E:
add [rbp+var_C], 1
mov eax, [rbp+var_8]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_8], eax
loc_11B0:
cmp [rbp+var_8], 0
jg short loc_118E
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
jmp short loc_122A
loc_11BE:
mov edx, [rbp+var_8]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
mov ecx, eax
sar ecx, 2
mov eax, edx
sar eax, 1Fh
sub ecx, eax
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
sub edx, eax
mov [rbp+var_4], edx
mov edx, [rbp+var_C]
mov eax, [rbp+var_4]
mov esi, edx
mov edi, eax
call _ZSt3powIiiEN9__gnu_cxx11__promote_2IDTplcvNS1_IT_XsrSt12__is_integerIS2_E7__valueEE6__typeELi0EcvNS1_IT0_XsrS3_IS7_E7__valueEE6__typeELi0EEXsrS3_ISB_E7__valueEE6__typeES2_S7_
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_10]
addsd xmm0, xmm1
cvttsd2si eax, xmm0
mov [rbp+var_10], eax
mov eax, [rbp+var_8]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_8], eax
loc_122A:
cmp [rbp+var_8], 0
jg short loc_11BE
mov eax, [rbp+var_14]
cmp eax, [rbp+var_10]
jnz short loc_123F
mov eax, 1
jmp short locret_1244
loc_123F:
mov eax, 0
locret_1244:
leave
retn | _BOOL8 func0(int a1)
{
int v2; // [rsp+10h] [rbp-10h]
unsigned int v3; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int j; // [rsp+18h] [rbp-8h]
v2 = 0;
v3 = 0;
for ( i = a1; i > 0; i /= 10 )
++v3;
for ( j = a1; j > 0; j /= 10 )
v2 = (int)(std::pow<int,int>((unsigned int)(j % 10), v3) + (double)v2);
return a1 == v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001011b0
LAB_0010118e:
ADD dword ptr [RBP + -0xc],0x1
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
LAB_001011b0:
CMP dword ptr [RBP + -0x8],0x0
JG 0x0010118e
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
JMP 0x0010122a
LAB_001011be:
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV ECX,EAX
SAR ECX,0x2
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
SUB EDX,EAX
MOV dword ptr [RBP + -0x4],EDX
MOV EDX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x4]
MOV ESI,EDX
MOV EDI,EAX
CALL 0x00101301
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x10]
ADDSD XMM0,XMM1
CVTTSD2SI EAX,XMM0
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
LAB_0010122a:
CMP dword ptr [RBP + -0x8],0x0
JG 0x001011be
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x10]
JNZ 0x0010123f
MOV EAX,0x1
JMP 0x00101244
LAB_0010123f:
MOV EAX,0x0
LAB_00101244:
LEAVE
RET | /* func0(int) */
bool func0(int param_1)
{
int iVar1;
double extraout_XMM0_Qa;
int local_18;
int local_14;
int local_10;
local_18 = 0;
local_14 = 0;
for (local_10 = param_1; iVar1 = param_1, 0 < local_10; local_10 = local_10 / 10) {
local_14 = local_14 + 1;
}
while (local_10 = iVar1, 0 < local_10) {
std::pow<int,int>(local_10 % 10,local_14);
local_18 = (int)(extraout_XMM0_Qa + (double)local_18);
iVar1 = local_10 / 10;
}
return param_1 == local_18;
} |
2,389 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| bool func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while(temp > 0) {
times++;
temp /= 10;
}
temp = number;
while(temp > 0) {
int reminder = temp % 10;
sum += std::pow(reminder, times);
temp /= 10;
}
if(number == sum) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(153) == true);
assert(func0(259) == false);
assert(func0(4458) == false);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,%ebp
test %edi,%edi
jle 1263 <_Z5func0i+0xba>
mov %edi,%eax
mov $0x0,%ecx
add $0x1,%ecx
mov %eax,%esi
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
cmp $0x9,%esi
jg 11c8 <_Z5func0i+0x1f>
mov %ebp,%r13d
mov $0x0,%r12d
pxor %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
movsd %xmm2,0x8(%rsp)
movslq %r13d,%rbx
imul $0x66666667,%rbx,%rbx
sar $0x22,%rbx
mov %r13d,%eax
sar $0x1f,%eax
sub %eax,%ebx
lea (%rbx,%rbx,4),%eax
add %eax,%eax
mov %r13d,%edi
sub %eax,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movsd 0x8(%rsp),%xmm1
callq 10b0 <pow@plt>
movapd %xmm0,%xmm1
pxor %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%r12d
mov %r13d,%eax
mov %ebx,%r13d
cmp $0x9,%eax
jg 11fe <_Z5func0i+0x55>
cmp %r12d,%ebp
sete %al
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x0,%r12d
jmp 1252 <_Z5func0i+0xa9>
| _Z5func0i:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r13d, edi
test edi, edi
jle loc_121C
mov edx, edi
mov ecx, 0
loc_1187:
add ecx, 1
mov esi, edx
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov edi, edx
sar edi, 1Fh
sub eax, edi
mov edx, eax
cmp esi, 9
jg short loc_1187
mov ebp, r13d
mov r12d, 0
pxor xmm2, xmm2
cvtsi2sd xmm2, ecx
movq r14, xmm2
loc_11BE:
movsxd rbx, ebp
imul rbx, 66666667h
sar rbx, 22h
mov eax, ebp
sar eax, 1Fh
sub ebx, eax
lea eax, [rbx+rbx*4]
add eax, eax
mov edx, ebp
sub edx, eax
pxor xmm0, xmm0
cvtsi2sd xmm0, edx; x
movq xmm1, r14; y
call _pow
movapd xmm1, xmm0
pxor xmm0, xmm0
cvtsi2sd xmm0, r12d
addsd xmm0, xmm1
cvttsd2si r12d, xmm0
mov eax, ebp
mov ebp, ebx
cmp eax, 9
jg short loc_11BE
loc_120D:
cmp r13d, r12d
setz al
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_121C:
mov r12d, 0
jmp short loc_120D | bool func0(int a1)
{
int v1; // edx
int v2; // ecx
int v3; // esi
int v4; // ebp
int v5; // r12d
double v6; // r14
int v7; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 10;
}
while ( v3 > 9 );
v4 = a1;
v5 = 0;
v6 = (double)v2;
do
{
v5 = (int)((double)v5 + pow((double)(v4 % 10), v6));
v7 = v4;
v4 /= 10;
}
while ( v7 > 9 );
}
return a1 == v5;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13D,EDI
TEST EDI,EDI
JLE 0x0010121c
MOV EDX,EDI
MOV ECX,0x0
LAB_00101187:
ADD ECX,0x1
MOV ESI,EDX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDI,EDX
SAR EDI,0x1f
SUB EAX,EDI
MOV EDX,EAX
CMP ESI,0x9
JG 0x00101187
MOV EBP,R13D
MOV R12D,0x0
PXOR XMM2,XMM2
CVTSI2SD XMM2,ECX
MOVQ R14,XMM2
LAB_001011be:
MOVSXD RBX,EBP
IMUL RBX,RBX,0x66666667
SAR RBX,0x22
MOV EAX,EBP
SAR EAX,0x1f
SUB EBX,EAX
LEA EAX,[RBX + RBX*0x4]
ADD EAX,EAX
MOV EDX,EBP
SUB EDX,EAX
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
MOVQ XMM1,R14
CALL 0x00101070
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,R12D
ADDSD XMM0,XMM1
CVTTSD2SI R12D,XMM0
MOV EAX,EBP
MOV EBP,EBX
CMP EAX,0x9
JG 0x001011be
LAB_0010120d:
CMP R13D,R12D
SETZ AL
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010121c:
MOV R12D,0x0
JMP 0x0010120d | /* func0(int) */
bool func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
int iVar4;
double dVar5;
if (param_1 < 1) {
iVar4 = 0;
}
else {
iVar2 = 0;
iVar4 = param_1;
do {
iVar2 = iVar2 + 1;
bVar1 = 9 < iVar4;
iVar4 = iVar4 / 10;
} while (bVar1);
iVar4 = 0;
iVar3 = param_1;
do {
dVar5 = pow((double)(iVar3 % 10),(double)iVar2);
iVar4 = (int)((double)iVar4 + dVar5);
bVar1 = 9 < iVar3;
iVar3 = iVar3 / 10;
} while (bVar1);
}
return param_1 == iVar4;
} |
2,390 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| bool func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while(temp > 0) {
times++;
temp /= 10;
}
temp = number;
while(temp > 0) {
int reminder = temp % 10;
sum += std::pow(reminder, times);
temp /= 10;
}
if(number == sum) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(153) == true);
assert(func0(259) == false);
assert(func0(4458) == false);
return 0;
}
| O2 | cpp | func0(int):
endbr64
push %r14
push %r13
push %r12
mov %edi,%r12d
push %rbp
push %rbx
sub $0x10,%rsp
test %edi,%edi
jle 1340 <_Z5func0i+0xb0>
mov %edi,%eax
xor %ecx,%ecx
mov $0xcccccccd,%esi
nopl 0x0(%rax)
mov %eax,%eax
add $0x1,%ecx
mov %rax,%rdx
imul %rsi,%rax
shr $0x23,%rax
cmp $0x9,%edx
jg 12b8 <_Z5func0i+0x28>
pxor %xmm1,%xmm1
mov %r12d,%r14d
xor %ebp,%ebp
mov $0xcccccccd,%r13d
cvtsi2sd %ecx,%xmm1
mov %r14d,%ebx
mov %r14d,%edi
pxor %xmm0,%xmm0
movsd %xmm1,0x8(%rsp)
imul %r13,%rbx
shr $0x23,%rbx
lea (%rbx,%rbx,4),%eax
add %eax,%eax
sub %eax,%edi
cvtsi2sd %edi,%xmm0
callq 10b0 <pow@plt>
mov %r14d,%eax
movsd 0x8(%rsp),%xmm1
mov %ebx,%r14d
movapd %xmm0,%xmm2
pxor %xmm0,%xmm0
cmp $0x9,%eax
cvtsi2sd %ebp,%xmm0
addsd %xmm2,%xmm0
cvttsd2si %xmm0,%ebp
jg 12e0 <_Z5func0i+0x50>
cmp %ebp,%r12d
sete %al
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xor %ebp,%ebp
jmp 132d <_Z5func0i+0x9d>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0i:
endbr64
push r14
push r13
push r12
push rbp
mov ebp, edi
push rbx
sub rsp, 10h
test edi, edi
jle loc_12D0
mov eax, edi
xor ecx, ecx
mov esi, 0CCCCCCCDh
nop dword ptr [rax+rax+00h]
loc_1238:
mov eax, eax
add ecx, 1
mov rdx, rax
imul rax, rsi
shr rax, 23h
cmp edx, 9
jg short loc_1238
pxor xmm1, xmm1
mov r12d, ebp
xor r14d, r14d
mov r13d, 0CCCCCCCDh
cvtsi2sd xmm1, ecx; y
nop dword ptr [rax+00000000h]
loc_1268:
mov ebx, r12d
mov edx, r12d
pxor xmm0, xmm0
movsd [rsp+38h+var_30], xmm1
imul rbx, r13
shr rbx, 23h
lea eax, [rbx+rbx*4]
add eax, eax
sub edx, eax
cvtsi2sd xmm0, edx; x
call _pow
mov eax, r12d
movsd xmm1, [rsp+38h+var_30]
mov r12d, ebx
movapd xmm2, xmm0
pxor xmm0, xmm0
cmp eax, 9
cvtsi2sd xmm0, r14d
addsd xmm0, xmm2
cvttsd2si r14d, xmm0
jg short loc_1268
loc_12B7:
cmp ebp, r14d
setz al
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_12D0:
xor r14d, r14d
jmp short loc_12B7 | bool func0(int a1)
{
unsigned int v1; // eax
int v2; // ecx
int v3; // edx
unsigned int v4; // r12d
int v5; // r14d
double v6; // xmm1_8
double v7; // xmm0_8
int v8; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 0xAu;
}
while ( v3 > 9 );
v4 = a1;
v5 = 0;
v6 = (double)v2;
do
{
v7 = pow((double)(v4 % 0xA), v6);
v8 = v4;
v4 /= 0xAu;
v5 = (int)((double)v5 + v7);
}
while ( v8 > 9 );
}
return a1 == v5;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x10
TEST EDI,EDI
JLE 0x001012d0
MOV EAX,EDI
XOR ECX,ECX
MOV ESI,0xcccccccd
NOP dword ptr [RAX + RAX*0x1]
LAB_00101238:
MOV EAX,EAX
ADD ECX,0x1
MOV RDX,RAX
IMUL RAX,RSI
SHR RAX,0x23
CMP EDX,0x9
JG 0x00101238
PXOR XMM1,XMM1
MOV R12D,EBP
XOR R14D,R14D
MOV R13D,0xcccccccd
CVTSI2SD XMM1,ECX
NOP dword ptr [RAX]
LAB_00101268:
MOV EBX,R12D
MOV EDX,R12D
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
IMUL RBX,R13
SHR RBX,0x23
LEA EAX,[RBX + RBX*0x4]
ADD EAX,EAX
SUB EDX,EAX
CVTSI2SD XMM0,EDX
CALL 0x00101070
MOV EAX,R12D
MOVSD XMM1,qword ptr [RSP + 0x8]
MOV R12D,EBX
MOVAPD XMM2,XMM0
PXOR XMM0,XMM0
CMP EAX,0x9
CVTSI2SD XMM0,R14D
ADDSD XMM0,XMM2
CVTTSD2SI R14D,XMM0
JG 0x00101268
LAB_001012b7:
CMP EBP,R14D
SETZ AL
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001012d0:
XOR R14D,R14D
JMP 0x001012b7 | /* func0(int) */
bool func0(int param_1)
{
bool bVar1;
ulong uVar2;
int iVar3;
uint uVar4;
int iVar5;
double dVar6;
if (param_1 < 1) {
iVar5 = 0;
}
else {
iVar3 = 0;
uVar2 = (ulong)(uint)param_1;
do {
iVar3 = iVar3 + 1;
iVar5 = (int)uVar2;
uVar2 = uVar2 / 10;
} while (9 < iVar5);
iVar5 = 0;
uVar4 = param_1;
do {
dVar6 = pow((double)(uVar4 % 10),(double)iVar3);
iVar5 = (int)((double)iVar5 + dVar6);
bVar1 = 9 < (int)uVar4;
uVar4 = uVar4 / 10;
} while (bVar1);
}
return param_1 == iVar5;
} |
2,391 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| bool func0(int number) {
int sum = 0;
int times = 0;
int temp = number;
while(temp > 0) {
times++;
temp /= 10;
}
temp = number;
while(temp > 0) {
int reminder = temp % 10;
sum += std::pow(reminder, times);
temp /= 10;
}
if(number == sum) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(153) == true);
assert(func0(259) == false);
assert(func0(4458) == false);
return 0;
}
| O3 | cpp | func0(int):
endbr64
push %r14
push %r13
push %r12
mov %edi,%r12d
push %rbp
push %rbx
sub $0x10,%rsp
test %edi,%edi
jle 1340 <_Z5func0i+0xb0>
mov %edi,%eax
xor %ecx,%ecx
mov $0xcccccccd,%esi
nopl 0x0(%rax)
mov %eax,%eax
add $0x1,%ecx
mov %rax,%rdx
imul %rsi,%rax
shr $0x23,%rax
cmp $0x9,%edx
jg 12b8 <_Z5func0i+0x28>
pxor %xmm1,%xmm1
mov %r12d,%r14d
xor %ebp,%ebp
mov $0xcccccccd,%r13d
cvtsi2sd %ecx,%xmm1
mov %r14d,%ebx
mov %r14d,%edi
pxor %xmm0,%xmm0
movsd %xmm1,0x8(%rsp)
imul %r13,%rbx
shr $0x23,%rbx
lea (%rbx,%rbx,4),%eax
add %eax,%eax
sub %eax,%edi
cvtsi2sd %edi,%xmm0
callq 10b0 <pow@plt>
mov %r14d,%eax
movsd 0x8(%rsp),%xmm1
mov %ebx,%r14d
movapd %xmm0,%xmm2
pxor %xmm0,%xmm0
cmp $0x9,%eax
cvtsi2sd %ebp,%xmm0
addsd %xmm2,%xmm0
cvttsd2si %xmm0,%ebp
jg 12e0 <_Z5func0i+0x50>
cmp %ebp,%r12d
sete %al
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xor %ebp,%ebp
jmp 132d <_Z5func0i+0x9d>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0i:
endbr64
push r14
push r13
push r12
push rbp
mov ebp, edi
push rbx
sub rsp, 10h
test edi, edi
jle loc_12D0
mov eax, edi
xor ecx, ecx
mov esi, 0CCCCCCCDh
nop dword ptr [rax+rax+00h]
loc_1238:
mov eax, eax
add ecx, 1
mov rdx, rax
imul rax, rsi
shr rax, 23h
cmp edx, 9
jg short loc_1238
pxor xmm1, xmm1
mov r12d, ebp
xor r14d, r14d
mov r13d, 0CCCCCCCDh
cvtsi2sd xmm1, ecx; y
nop dword ptr [rax+00000000h]
loc_1268:
mov ebx, r12d
mov edx, r12d
pxor xmm0, xmm0
movsd [rsp+38h+var_30], xmm1
imul rbx, r13
shr rbx, 23h
lea eax, [rbx+rbx*4]
add eax, eax
sub edx, eax
cvtsi2sd xmm0, edx; x
call _pow
mov eax, r12d
movsd xmm1, [rsp+38h+var_30]
mov r12d, ebx
movapd xmm2, xmm0
pxor xmm0, xmm0
cmp eax, 9
cvtsi2sd xmm0, r14d
addsd xmm0, xmm2
cvttsd2si r14d, xmm0
jg short loc_1268
loc_12B7:
cmp ebp, r14d
setz al
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_12D0:
xor r14d, r14d
jmp short loc_12B7 | bool func0(int a1)
{
unsigned int v1; // eax
int v2; // ecx
int v3; // edx
unsigned int v4; // r12d
int v5; // r14d
double v6; // xmm1_8
double v7; // xmm0_8
int v8; // eax
if ( a1 <= 0 )
{
v5 = 0;
}
else
{
v1 = a1;
v2 = 0;
do
{
++v2;
v3 = v1;
v1 /= 0xAu;
}
while ( v3 > 9 );
v4 = a1;
v5 = 0;
v6 = (double)v2;
do
{
v7 = pow((double)(v4 % 0xA), v6);
v8 = v4;
v4 /= 0xAu;
v5 = (int)((double)v5 + v7);
}
while ( v8 > 9 );
}
return a1 == v5;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x10
TEST EDI,EDI
JLE 0x001012d0
MOV EAX,EDI
XOR ECX,ECX
MOV ESI,0xcccccccd
NOP dword ptr [RAX + RAX*0x1]
LAB_00101238:
MOV EAX,EAX
ADD ECX,0x1
MOV RDX,RAX
IMUL RAX,RSI
SHR RAX,0x23
CMP EDX,0x9
JG 0x00101238
PXOR XMM1,XMM1
MOV R12D,EBP
XOR R14D,R14D
MOV R13D,0xcccccccd
CVTSI2SD XMM1,ECX
NOP dword ptr [RAX]
LAB_00101268:
MOV EBX,R12D
MOV EDX,R12D
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
IMUL RBX,R13
SHR RBX,0x23
LEA EAX,[RBX + RBX*0x4]
ADD EAX,EAX
SUB EDX,EAX
CVTSI2SD XMM0,EDX
CALL 0x00101070
MOV EAX,R12D
MOVSD XMM1,qword ptr [RSP + 0x8]
MOV R12D,EBX
MOVAPD XMM2,XMM0
PXOR XMM0,XMM0
CMP EAX,0x9
CVTSI2SD XMM0,R14D
ADDSD XMM0,XMM2
CVTTSD2SI R14D,XMM0
JG 0x00101268
LAB_001012b7:
CMP EBP,R14D
SETZ AL
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001012d0:
XOR R14D,R14D
JMP 0x001012b7 | /* func0(int) */
bool func0(int param_1)
{
bool bVar1;
ulong uVar2;
int iVar3;
uint uVar4;
int iVar5;
double dVar6;
if (param_1 < 1) {
iVar5 = 0;
}
else {
iVar3 = 0;
uVar2 = (ulong)(uint)param_1;
do {
iVar3 = iVar3 + 1;
iVar5 = (int)uVar2;
uVar2 = uVar2 / 10;
} while (9 < iVar5);
iVar5 = 0;
uVar4 = param_1;
do {
dVar6 = pow((double)(uVar4 % 10),(double)iVar3);
iVar5 = (int)((double)iVar5 + dVar6);
bVar1 = 9 < (int)uVar4;
uVar4 = uVar4 / 10;
} while (bVar1);
}
return param_1 == iVar5;
} |
2,392 | func0 |
#include <cassert>
#include <utility>
| std::pair<int, double> func0(int number) {
int total = 0;
for (int value = 1; value <= number; ++value) {
total += value;
}
double average = static_cast<double>(total) / number;
return {total, average};
}
| int main() {
assert(func0(10) == std::make_pair(55, 5.5));
assert(func0(15) == std::make_pair(120, 8.0));
assert(func0(20) == std::make_pair(210, 10.5));
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x40(%rbp)
movl $0x1,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cmp -0x44(%rbp),%eax
jg 11cf <_Z5func0i+0x46>
mov -0x40(%rbp),%edx
mov -0x3c(%rbp),%eax
add %edx,%eax
mov %eax,-0x40(%rbp)
addl $0x1,-0x3c(%rbp)
jmp 11b6 <_Z5func0i+0x2d>
mov -0x40(%rbp),%eax
cvtsi2sd %eax,%xmm0
cvtsi2sdl -0x44(%rbp),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x38(%rbp)
lea -0x38(%rbp),%rdx
lea -0x40(%rbp),%rcx
lea -0x30(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 1416 <_ZNSt4pairIidEC1IRiRdLb1EEEOT_OT0_>
mov -0x30(%rbp),%rax
mov -0x28(%rbp),%rdx
mov %rax,%rcx
mov %rdx,%rbx
mov %rax,%rsi
mov %rdx,%rdi
mov %ecx,%eax
movq %rdi,%xmm0
mov -0x18(%rbp),%rbx
xor %fs:0x28,%rbx
je 122a <_Z5func0i+0xa1>
callq 1080 <__stack_chk_fail@plt>
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_44], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_40], 0
mov [rbp+var_3C], 1
jmp short loc_11A7
loc_1198:
mov edx, [rbp+var_40]
mov eax, [rbp+var_3C]
add eax, edx
mov [rbp+var_40], eax
add [rbp+var_3C], 1
loc_11A7:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_44]
jle short loc_1198
mov eax, [rbp+var_40]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_44]
divsd xmm0, xmm1
movsd [rbp+var_38], xmm0
lea rdx, [rbp+var_38]
lea rcx, [rbp+var_40]
lea rax, [rbp+var_30]
mov rsi, rcx
mov rdi, rax
call _ZNSt4pairIidEC2IRiRdLb1EEEOT_OT0_; std::pair<int,double>::pair<int &,double &,true>(int &,double &)
mov rax, [rbp+var_30]
mov rdx, [rbp+var_28]
mov rcx, rax
mov rbx, rdx
mov rsi, rax
mov rdi, rdx
mov eax, ecx
movq xmm0, rdi
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1212
call ___stack_chk_fail
loc_1212:
mov rbx, [rbp+var_8]
leave
retn | double func0(int a1)
{
int v2; // [rsp+10h] [rbp-40h] BYREF
int i; // [rsp+14h] [rbp-3Ch]
double v4; // [rsp+18h] [rbp-38h] BYREF
_QWORD v5[5]; // [rsp+20h] [rbp-30h] BYREF
v5[3] = __readfsqword(0x28u);
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += i;
v4 = (double)v2 / (double)a1;
std::pair<int,double>::pair<int &,double &,true>(v5, &v2, &v4);
return *(double *)&v5[1];
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x44],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x3c],0x1
JMP 0x001011a7
LAB_00101198:
MOV EDX,dword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,EDX
MOV dword ptr [RBP + -0x40],EAX
ADD dword ptr [RBP + -0x3c],0x1
LAB_001011a7:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x44]
JLE 0x00101198
MOV EAX,dword ptr [RBP + -0x40]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x44]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x38],XMM0
LEA RDX,[RBP + -0x38]
LEA RCX,[RBP + -0x40]
LEA RAX,[RBP + -0x30]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001013f2
MOV RAX,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,RAX
MOV RBX,RDX
MOV RSI,RAX
MOV RDI,RDX
MOV EAX,ECX
MOVQ XMM0,RDI
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101212
CALL 0x00101060
LAB_00101212:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(int) */
ulong func0(int param_1)
{
long in_FS_OFFSET;
int local_48;
int local_44;
double local_40;
ulong local_38;
int8 local_30;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = 0;
for (local_44 = 1; local_44 <= param_1; local_44 = local_44 + 1) {
local_48 = local_44 + local_48;
}
local_40 = (double)local_48 / (double)param_1;
std::pair<int,double>::pair<int&,double&,true>((pair<int,double> *)&local_38,&local_48,&local_40);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail(local_30,local_38);
}
return local_38 & 0xffffffff;
} |
2,393 | func0 |
#include <cassert>
#include <utility>
| std::pair<int, double> func0(int number) {
int total = 0;
for (int value = 1; value <= number; ++value) {
total += value;
}
double average = static_cast<double>(total) / number;
return {total, average};
}
| int main() {
assert(func0(10) == std::make_pair(55, 5.5));
assert(func0(15) == std::make_pair(120, 8.0));
assert(func0(20) == std::make_pair(210, 10.5));
return 0;
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
jle 117e <_Z5func0i+0x35>
lea 0x1(%rdi),%ecx
mov $0x0,%edx
mov $0x1,%eax
add %eax,%edx
add $0x1,%eax
cmp %eax,%ecx
jne 115e <_Z5func0i+0x15>
mov %edx,%eax
pxor %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
retq
mov $0x0,%edx
jmp 1167 <_Z5func0i+0x1e>
| _Z5func0i:
endbr64
test edi, edi
jle short loc_117C
lea ecx, [rdi+1]
mov eax, 0
mov edx, 1
loc_115E:
add eax, edx
add edx, 1
cmp ecx, edx
jnz short loc_115E
loc_1167:
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
pxor xmm1, xmm1
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
retn
loc_117C:
mov eax, 0
jmp short loc_1167 | double func0(int a1)
{
int v1; // eax
int v2; // edx
if ( a1 <= 0 )
{
v1 = 0;
}
else
{
v1 = 0;
v2 = 1;
do
v1 += v2++;
while ( a1 + 1 != v2 );
}
return (double)v1 / (double)a1;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x0010117c
LEA ECX,[RDI + 0x1]
MOV EAX,0x0
MOV EDX,0x1
LAB_0010115e:
ADD EAX,EDX
ADD EDX,0x1
CMP ECX,EDX
JNZ 0x0010115e
LAB_00101167:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
RET
LAB_0010117c:
MOV EAX,0x0
JMP 0x00101167 | /* func0(int) */
double func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar1 = 0;
}
else {
iVar1 = 0;
iVar2 = 1;
do {
iVar1 = iVar1 + iVar2;
iVar2 = iVar2 + 1;
} while (param_1 + 1 != iVar2);
}
return (double)iVar1 / (double)param_1;
} |
2,394 | func0 |
#include <cassert>
#include <utility>
| std::pair<int, double> func0(int number) {
int total = 0;
for (int value = 1; value <= number; ++value) {
total += value;
}
double average = static_cast<double>(total) / number;
return {total, average};
}
| int main() {
assert(func0(10) == std::make_pair(55, 5.5));
assert(func0(15) == std::make_pair(120, 8.0));
assert(func0(20) == std::make_pair(210, 10.5));
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
jle 1180 <_Z5func0i+0x40>
lea 0x1(%rdi),%ecx
xor %eax,%eax
mov $0x1,%edx
nopw 0x0(%rax,%rax,1)
add %edx,%eax
add $0x1,%edx
cmp %edx,%ecx
jne 1158 <_Z5func0i+0x18>
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm0
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
pxor %xmm0,%xmm0
xor %eax,%eax
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0i:
endbr64
test edi, edi
jle short loc_1190
lea ecx, [rdi+1]
xor eax, eax
mov edx, 1
test dil, 1
jz short loc_1170
mov eax, 1
mov edx, 2
cmp ecx, 2
jz short loc_117B
nop word ptr [rax+rax+00000000h]
loc_1170:
lea eax, [rax+rdx*2+1]
add edx, 2
cmp ecx, edx
jnz short loc_1170
loc_117B:
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, eax
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
retn
loc_1190:
pxor xmm1, xmm1
pxor xmm0, xmm0
xor eax, eax
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
retn | double func0(int a1)
{
int v1; // eax
int v2; // edx
if ( a1 <= 0 )
return 0.0 / (double)a1;
v1 = 0;
v2 = 1;
if ( (a1 & 1) == 0 || (v1 = 1, v2 = 2, a1 != 1) )
{
do
{
v1 += 2 * v2 + 1;
v2 += 2;
}
while ( a1 + 1 != v2 );
}
return (double)v1 / (double)a1;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101190
LEA ECX,[RDI + 0x1]
XOR EAX,EAX
MOV EDX,0x1
TEST DIL,0x1
JZ 0x00101170
MOV EAX,0x1
MOV EDX,0x2
CMP ECX,0x2
JZ 0x0010117b
NOP word ptr [RAX + RAX*0x1]
LAB_00101170:
LEA EAX,[RAX + RDX*0x2 + 0x1]
ADD EDX,0x2
CMP ECX,EDX
JNZ 0x00101170
LAB_0010117b:
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EAX
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
RET
LAB_00101190:
PXOR XMM1,XMM1
PXOR XMM0,XMM0
XOR EAX,EAX
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
return 0;
}
iVar1 = 0;
iVar2 = 1;
if ((param_1 & 1U) != 0) {
iVar1 = 1;
iVar2 = 2;
if (param_1 + 1 == 2) {
return 1;
}
}
do {
iVar1 = iVar1 + 1 + iVar2 * 2;
iVar2 = iVar2 + 2;
} while (param_1 + 1 != iVar2);
return iVar1;
} |
2,395 | func0 |
#include <cassert>
#include <utility>
| std::pair<int, double> func0(int number) {
int total = 0;
for (int value = 1; value <= number; ++value) {
total += value;
}
double average = static_cast<double>(total) / number;
return {total, average};
}
| int main() {
assert(func0(10) == std::make_pair(55, 5.5));
assert(func0(15) == std::make_pair(120, 8.0));
assert(func0(20) == std::make_pair(210, 10.5));
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11e0 <_Z5func0i+0xa0>
lea -0x1(%rdi),%eax
cmp $0x11,%eax
jbe 11f3 <_Z5func0i+0xb3>
mov %edi,%edx
movdqa 0xeae(%rip),%xmm1
xor %eax,%eax
pxor %xmm0,%xmm0
movdqa 0xeb0(%rip),%xmm3
shr $0x2,%edx
nopl 0x0(%rax,%rax,1)
movdqa %xmm1,%xmm2
add $0x1,%eax
paddd %xmm3,%xmm1
paddd %xmm2,%xmm0
cmp %edx,%eax
jne 1178 <_Z5func0i+0x38>
movdqa %xmm0,%xmm1
mov %edi,%ecx
psrldq $0x8,%xmm1
and $0xfffffffc,%ecx
paddd %xmm1,%xmm0
lea 0x1(%rcx),%edx
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
cmp %ecx,%edi
je 11c1 <_Z5func0i+0x81>
nopl (%rax)
add %edx,%eax
add $0x1,%edx
cmp %edi,%edx
jle 11b8 <_Z5func0i+0x78>
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm0
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
pxor %xmm1,%xmm1
pxor %xmm0,%xmm0
xor %eax,%eax
cvtsi2sd %edi,%xmm1
divsd %xmm1,%xmm0
retq
xor %eax,%eax
mov $0x1,%edx
jmp 11b8 <_Z5func0i+0x78>
nopl 0x0(%rax)
| _Z5func0i:
endbr64
mov edx, edi
test edi, edi
jle loc_1220
lea eax, [rdi-1]
cmp eax, 9
jbe loc_1233
mov ecx, edi
movdqa xmm1, cs:xmmword_2010
xor eax, eax
pxor xmm0, xmm0
movdqa xmm3, cs:xmmword_2020
shr ecx, 2
nop dword ptr [rax]
loc_1178:
movdqa xmm2, xmm1
add eax, 1
paddd xmm1, xmm3
paddd xmm0, xmm2
cmp eax, ecx
jnz short loc_1178
movdqa xmm1, xmm0
mov ecx, edx
psrldq xmm1, 8
and ecx, 0FFFFFFFCh
paddd xmm0, xmm1
add ecx, 1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test dl, 3
jz short loc_120B
loc_11B6:
lea esi, [rcx+1]
add eax, ecx
cmp edx, esi
jl short loc_120B
add eax, esi
lea esi, [rcx+2]
cmp edx, esi
jl short loc_120B
add eax, esi
lea esi, [rcx+3]
cmp edx, esi
jl short loc_120B
add eax, esi
lea esi, [rcx+4]
cmp edx, esi
jl short loc_120B
add eax, esi
lea esi, [rcx+5]
cmp edx, esi
jl short loc_120B
add eax, esi
lea esi, [rcx+6]
cmp edx, esi
jl short loc_120B
add eax, esi
lea esi, [rcx+7]
cmp edx, esi
jl short loc_120B
add eax, esi
lea esi, [rcx+8]
cmp edx, esi
jl short loc_120B
add eax, esi
add ecx, 9
lea esi, [rax+rcx]
cmp edx, ecx
cmovge eax, esi
loc_120B:
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, eax
cvtsi2sd xmm1, edx
divsd xmm0, xmm1
retn
loc_1220:
pxor xmm1, xmm1
pxor xmm0, xmm0
xor eax, eax
cvtsi2sd xmm1, edx
divsd xmm0, xmm1
retn
loc_1233:
xor eax, eax
mov ecx, 1
jmp loc_11B6 | double func0(int a1)
{
__m128i si128; // xmm1
int v2; // eax
__m128i v3; // xmm0
__m128i v4; // xmm3
__m128i v5; // xmm2
__m128i v6; // xmm0
unsigned int v7; // ecx
int v8; // eax
int v9; // ecx
if ( a1 > 0 )
{
if ( (unsigned int)(a1 - 1) <= 9 )
{
v8 = 0;
v7 = 1;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v2 = 0;
v3 = 0LL;
v4 = _mm_load_si128((const __m128i *)&xmmword_2020);
do
{
v5 = si128;
++v2;
si128 = _mm_add_epi32(si128, v4);
v3 = _mm_add_epi32(v3, v5);
}
while ( v2 != (unsigned int)a1 >> 2 );
v6 = _mm_add_epi32(v3, _mm_srli_si128(v3, 8));
v7 = (a1 & 0xFFFFFFFC) + 1;
v8 = _mm_cvtsi128_si32(_mm_add_epi32(v6, _mm_srli_si128(v6, 4)));
if ( (a1 & 3) == 0 )
return (double)v8 / (double)a1;
}
v8 += v7;
if ( a1 >= (int)(v7 + 1) )
{
v8 += v7 + 1;
if ( a1 >= (int)(v7 + 2) )
{
v8 += v7 + 2;
if ( a1 >= (int)(v7 + 3) )
{
v8 += v7 + 3;
if ( a1 >= (int)(v7 + 4) )
{
v8 += v7 + 4;
if ( a1 >= (int)(v7 + 5) )
{
v8 += v7 + 5;
if ( a1 >= (int)(v7 + 6) )
{
v8 += v7 + 6;
if ( a1 >= (int)(v7 + 7) )
{
v8 += v7 + 7;
if ( a1 >= (int)(v7 + 8) )
{
v8 += v7 + 8;
v9 = v7 + 9;
if ( a1 >= v9 )
v8 += v9;
}
}
}
}
}
}
}
}
return (double)v8 / (double)a1;
}
return 0.0 / (double)a1;
} | func0:
ENDBR64
MOV EDX,EDI
TEST EDI,EDI
JLE 0x00101220
LEA EAX,[RDI + -0x1]
CMP EAX,0x9
JBE 0x00101233
MOV ECX,EDI
MOVDQA XMM1,xmmword ptr [0x00102010]
XOR EAX,EAX
PXOR XMM0,XMM0
MOVDQA XMM3,xmmword ptr [0x00102020]
SHR ECX,0x2
NOP dword ptr [RAX]
LAB_00101178:
MOVDQA XMM2,XMM1
ADD EAX,0x1
PADDD XMM1,XMM3
PADDD XMM0,XMM2
CMP EAX,ECX
JNZ 0x00101178
MOVDQA XMM1,XMM0
MOV ECX,EDX
PSRLDQ XMM1,0x8
AND ECX,0xfffffffc
PADDD XMM0,XMM1
ADD ECX,0x1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST DL,0x3
JZ 0x0010120b
LAB_001011b6:
LEA ESI,[RCX + 0x1]
ADD EAX,ECX
CMP EDX,ESI
JL 0x0010120b
ADD EAX,ESI
LEA ESI,[RCX + 0x2]
CMP EDX,ESI
JL 0x0010120b
ADD EAX,ESI
LEA ESI,[RCX + 0x3]
CMP EDX,ESI
JL 0x0010120b
ADD EAX,ESI
LEA ESI,[RCX + 0x4]
CMP EDX,ESI
JL 0x0010120b
ADD EAX,ESI
LEA ESI,[RCX + 0x5]
CMP EDX,ESI
JL 0x0010120b
ADD EAX,ESI
LEA ESI,[RCX + 0x6]
CMP EDX,ESI
JL 0x0010120b
ADD EAX,ESI
LEA ESI,[RCX + 0x7]
CMP EDX,ESI
JL 0x0010120b
ADD EAX,ESI
LEA ESI,[RCX + 0x8]
CMP EDX,ESI
JL 0x0010120b
ADD EAX,ESI
ADD ECX,0x9
LEA ESI,[RAX + RCX*0x1]
CMP EDX,ECX
CMOVGE EAX,ESI
LAB_0010120b:
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EAX
CVTSI2SD XMM1,EDX
DIVSD XMM0,XMM1
RET
LAB_00101220:
PXOR XMM1,XMM1
PXOR XMM0,XMM0
XOR EAX,EAX
CVTSI2SD XMM1,EDX
DIVSD XMM0,XMM1
RET
LAB_00101233:
XOR EAX,EAX
MOV ECX,0x1
JMP 0x001011b6 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
uint uVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
if (param_1 < 1) {
return 0;
}
if (param_1 - 1U < 10) {
iVar5 = 0;
iVar3 = 1;
}
else {
uVar1 = 0;
iVar4 = 0;
iVar6 = 0;
iVar7 = 0;
iVar8 = 0;
iVar5 = _DAT_00102010;
iVar3 = _UNK_00102014;
iVar2 = _UNK_00102018;
iVar9 = _UNK_0010201c;
do {
uVar1 = uVar1 + 1;
iVar4 = iVar4 + iVar5;
iVar6 = iVar6 + iVar3;
iVar7 = iVar7 + iVar2;
iVar8 = iVar8 + iVar9;
iVar5 = iVar5 + _DAT_00102020;
iVar3 = iVar3 + _UNK_00102024;
iVar2 = iVar2 + _UNK_00102028;
iVar9 = iVar9 + _UNK_0010202c;
} while (uVar1 != (uint)param_1 >> 2);
iVar3 = (param_1 & 0xfffffffcU) + 1;
iVar5 = iVar4 + iVar7 + iVar6 + iVar8;
if ((param_1 & 3U) == 0) {
return iVar5;
}
}
iVar2 = iVar5 + iVar3;
if (iVar3 + 1 <= param_1) {
iVar2 = iVar5 + iVar3 + iVar3 + 1;
if (iVar3 + 2 <= param_1) {
iVar2 = iVar2 + iVar3 + 2;
if (iVar3 + 3 <= param_1) {
iVar2 = iVar2 + iVar3 + 3;
if (iVar3 + 4 <= param_1) {
iVar2 = iVar2 + iVar3 + 4;
if (iVar3 + 5 <= param_1) {
iVar2 = iVar2 + iVar3 + 5;
if (iVar3 + 6 <= param_1) {
iVar2 = iVar2 + iVar3 + 6;
if (iVar3 + 7 <= param_1) {
iVar2 = iVar2 + iVar3 + 7;
if (iVar3 + 8 <= param_1) {
iVar2 = iVar2 + iVar3 + 8;
if (iVar3 + 9 <= param_1) {
iVar2 = iVar2 + iVar3 + 9;
}
}
}
}
}
}
}
}
}
return iVar2;
} |
2,396 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
xor $0x1,%eax
mov %eax,%edx
mov -0x4(%rbp),%eax
add $0x1,%eax
cmp %eax,%edx
jne 11ad <_Z5func0i+0x24>
mov $0x1,%eax
jmp 11b2 <_Z5func0i+0x29>
mov $0x0,%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
xor eax, 1
mov edx, eax
mov eax, [rbp+var_4]
add eax, 1
cmp edx, eax
jnz short loc_116D
mov eax, 1
jmp short loc_1172
loc_116D:
mov eax, 0
loc_1172:
pop rbp
retn | _BOOL8 func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
XOR EAX,0x1
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
CMP EDX,EAX
JNZ 0x0010116d
MOV EAX,0x1
JMP 0x00101172
LAB_0010116d:
MOV EAX,0x0
LAB_00101172:
POP RBP
RET | /* func0(int) */
bool func0(int param_1)
{
return (param_1 ^ 1U) == param_1 + 1U;
} |
2,397 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov %edi,%eax
xor $0x1,%eax
add $0x1,%edi
cmp %edi,%eax
sete %al
retq
| _Z5func0i:
endbr64
mov eax, edi
xor eax, 1
add edi, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
XOR EAX,0x1
ADD EDI,0x1
CMP EAX,EDI
SETZ AL
RET | /* func0(int) */
bool func0(int param_1)
{
return (param_1 ^ 1U) == param_1 + 1U;
} |
2,398 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%eax
add $0x1,%edi
xor $0x1,%eax
cmp %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0i:
endbr64
mov eax, edi
add edi, 1
xor eax, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
ADD EDI,0x1
XOR EAX,0x1
CMP EAX,EDI
SETZ AL
RET | /* func0(int) */
bool func0(int param_1)
{
return (param_1 ^ 1U) == param_1 + 1U;
} |
2,399 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int n) {
if ((n ^ 1) == n + 1) {
return true;
} else {
return false;
}
}
| int main() {
assert(func0(1) == false);
assert(func0(2) == true);
assert(func0(3) == false);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%eax
add $0x1,%edi
xor $0x1,%eax
cmp %edi,%eax
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0i:
endbr64
mov eax, edi
add edi, 1
xor eax, 1
cmp eax, edi
setz al
retn | bool func0(int a1)
{
return (a1 ^ 1) == a1 + 1;
} | func0:
ENDBR64
MOV EAX,EDI
ADD EDI,0x1
XOR EAX,0x1
CMP EAX,EDI
SETZ AL
RET | /* func0(int) */
bool func0(int param_1)
{
return (param_1 ^ 1U) == param_1 + 1U;
} |
2,400 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
class Pair {
public:
int a, b;
Pair(int a, int b) : a(a), b(b) {}
};
| int func0(std::vector<Pair> arr, int n) {
int max = 0;
std::vector<int> mcl(n, 1);
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mcl[i]) {
max = mcl[i];
}
}
return max;
}
| int main() {
assert(func0({Pair(5, 24), Pair(15, 25), Pair(27, 40), Pair(50, 60)}, 4) == 3);
assert(func0({Pair(1, 2), Pair(3, 4), Pair(5, 6), Pair(7, 8)}, 4) == 4);
assert(func0({Pair(19, 10), Pair(11, 12), Pair(13, 14), Pair(15, 16), Pair(31, 54)}, 5) == 5);
return 0;
}
| O0 | cpp | func0(std::vector<Pair, std::allocator<Pair> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x40(%rbp)
lea -0x45(%rbp),%rax
mov %rax,%rdi
callq 18d4 <_ZNSaIiEC1Ev>
movl $0x1,-0x44(%rbp)
mov -0x5c(%rbp),%eax
movslq %eax,%rsi
lea -0x45(%rbp),%rcx
lea -0x44(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 1914 <_ZNSt6vectorIiSaIiEEC1EmRKiRKS0_>
lea -0x45(%rbp),%rax
mov %rax,%rdi
callq 18f4 <_ZNSaIiED1Ev>
movl $0x1,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cmp -0x5c(%rbp),%eax
jge 138a <_Z5func0St6vectorI4PairSaIS0_EEi+0x141>
movl $0x0,-0x38(%rbp)
mov -0x38(%rbp),%eax
cmp -0x3c(%rbp),%eax
jge 1381 <_Z5func0St6vectorI4PairSaIS0_EEi+0x138>
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 19e4 <_ZNSt6vectorI4PairSaIS0_EEixEm>
mov (%rax),%ebx
mov -0x38(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 19e4 <_ZNSt6vectorI4PairSaIS0_EEixEm>
mov 0x4(%rax),%eax
cmp %eax,%ebx
jle 133e <_Z5func0St6vectorI4PairSaIS0_EEi+0xf5>
mov -0x38(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a08 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a08 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
cmp %eax,%ebx
jl 133e <_Z5func0St6vectorI4PairSaIS0_EEi+0xf5>
mov $0x1,%eax
jmp 1343 <_Z5func0St6vectorI4PairSaIS0_EEi+0xfa>
mov $0x0,%eax
test %al,%al
je 1378 <_Z5func0St6vectorI4PairSaIS0_EEi+0x12f>
mov -0x38(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a08 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
lea 0x1(%rax),%ebx
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a08 <_ZNSt6vectorIiSaIiEEixEm>
mov %ebx,(%rax)
addl $0x1,-0x38(%rbp)
jmpq 12c6 <_Z5func0St6vectorI4PairSaIS0_EEi+0x7d>
addl $0x1,-0x3c(%rbp)
jmpq 12b3 <_Z5func0St6vectorI4PairSaIS0_EEi+0x6a>
movl $0x0,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x5c(%rbp),%eax
jge 13da <_Z5func0St6vectorI4PairSaIS0_EEi+0x191>
mov -0x34(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a08 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
cmp %eax,-0x40(%rbp)
setl %al
test %al,%al
je 13d4 <_Z5func0St6vectorI4PairSaIS0_EEi+0x18b>
mov -0x34(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a08 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
mov %eax,-0x40(%rbp)
addl $0x1,-0x34(%rbp)
jmp 1391 <_Z5func0St6vectorI4PairSaIS0_EEi+0x148>
mov -0x40(%rbp),%ebx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 199c <_ZNSt6vectorIiSaIiEED1Ev>
mov %ebx,%eax
mov -0x18(%rbp),%rcx
xor %fs:0x28,%rcx
je 141f <_Z5func0St6vectorI4PairSaIS0_EEi+0x1d6>
jmp 141a <_Z5func0St6vectorI4PairSaIS0_EEi+0x1d1>
endbr64
mov %rax,%rbx
lea -0x45(%rbp),%rax
mov %rax,%rdi
callq 18f4 <_ZNSaIiED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1150 <_Unwind_Resume@plt>
callq 1130 <__stack_chk_fail@plt>
add $0x58,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0St6vectorI4PairSaIS0_EEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_48], 0
lea rax, [rbp+var_4D]
mov [rbp+var_38], rax
nop
nop
mov [rbp+var_4C], 1
mov eax, [rbp+var_5C]
movsxd rsi, eax
lea rcx, [rbp+var_4D]
lea rdx, [rbp+var_4C]
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2EmRKiRKS0_; std::vector<int>::vector(ulong,int const&,std::allocator<int> const&)
lea rax, [rbp+var_4D]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
mov [rbp+var_44], 1
jmp loc_135D
loc_1297:
mov [rbp+var_40], 0
jmp loc_134D
loc_12A3:
mov eax, [rbp+var_44]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorI4PairSaIS0_EEixEm; std::vector<Pair>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_40]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorI4PairSaIS0_EEixEm; std::vector<Pair>::operator[](ulong)
mov eax, [rax+4]
cmp ebx, eax
jle short loc_130F
mov eax, [rbp+var_40]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_44]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
cmp ebx, eax
jl short loc_130F
mov eax, 1
jmp short loc_1314
loc_130F:
mov eax, 0
loc_1314:
test al, al
jz short loc_1349
mov eax, [rbp+var_40]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
lea ebx, [rax+1]
mov eax, [rbp+var_44]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rax], ebx
loc_1349:
add [rbp+var_40], 1
loc_134D:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_44]
jl loc_12A3
add [rbp+var_44], 1
loc_135D:
mov eax, [rbp+var_44]
cmp eax, [rbp+var_5C]
jl loc_1297
mov [rbp+var_3C], 0
jmp short loc_13B1
loc_1372:
mov eax, [rbp+var_3C]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
cmp [rbp+var_48], eax
setl al
test al, al
jz short loc_13AD
mov eax, [rbp+var_3C]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
mov [rbp+var_48], eax
loc_13AD:
add [rbp+var_3C], 1
loc_13B1:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_5C]
jl short loc_1372
mov ebx, [rbp+var_48]
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov eax, ebx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1413
jmp short loc_140E
endbr64
mov rbx, rax
lea rax, [rbp+var_4D]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1406
call ___stack_chk_fail
loc_1406:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_140E:
call ___stack_chk_fail
loc_1413:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2)
{
int v2; // ebx
int v3; // ebx
int v5; // ebx
_DWORD *v6; // rax
unsigned int v7; // ebx
char v9; // [rsp+13h] [rbp-4Dh] BYREF
int v10; // [rsp+14h] [rbp-4Ch] BYREF
int v11; // [rsp+18h] [rbp-48h]
int i; // [rsp+1Ch] [rbp-44h]
int j; // [rsp+20h] [rbp-40h]
int k; // [rsp+24h] [rbp-3Ch]
char *v15; // [rsp+28h] [rbp-38h]
_BYTE v16[24]; // [rsp+30h] [rbp-30h] BYREF
unsigned long long v17; // [rsp+48h] [rbp-18h]
v17 = __readfsqword(0x28u);
v11 = 0;
v15 = &v9;
v10 = 1;
std::vector<int>::vector(v16, a2, &v10, &v9);
std::__new_allocator<int>::~__new_allocator(&v9);
for ( i = 1; i < a2; ++i )
{
for ( j = 0; j < i; ++j )
{
v2 = *(_DWORD *)std::vector<Pair>::operator[](a1, i);
if ( v2 > *(_DWORD *)(std::vector<Pair>::operator[](a1, j) + 4) )
{
v3 = *(_DWORD *)std::vector<int>::operator[](v16, j);
if ( v3 >= *(_DWORD *)std::vector<int>::operator[](v16, i) )
{
v5 = *(_DWORD *)std::vector<int>::operator[](v16, j) + 1;
*(_DWORD *)std::vector<int>::operator[](v16, i) = v5;
}
}
}
}
for ( k = 0; k < a2; ++k )
{
v6 = (_DWORD *)std::vector<int>::operator[](v16, k);
if ( v11 < *v6 )
v11 = *(_DWORD *)std::vector<int>::operator[](v16, k);
}
v7 = v11;
std::vector<int>::~vector(v16);
return v7;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x48],0x0
LEA RAX,[RBP + -0x4d]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV dword ptr [RBP + -0x4c],0x1
MOV EAX,dword ptr [RBP + -0x5c]
MOVSXD RSI,EAX
LEA RCX,[RBP + -0x4d]
LEA RDX,[RBP + -0x4c]
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
LAB_00101279:
CALL 0x001018da
LEA RAX,[RBP + -0x4d]
MOV RDI,RAX
CALL 0x00101b22
NOP
MOV dword ptr [RBP + -0x44],0x1
JMP 0x0010135d
LAB_00101297:
MOV dword ptr [RBP + -0x40],0x0
JMP 0x0010134d
LAB_001012a3:
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001019ba
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x40]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001019ba
MOV EAX,dword ptr [RAX + 0x4]
CMP EBX,EAX
JLE 0x0010130f
MOV EAX,dword ptr [RBP + -0x40]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001019de
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001019de
MOV EAX,dword ptr [RAX]
CMP EBX,EAX
JL 0x0010130f
MOV EAX,0x1
JMP 0x00101314
LAB_0010130f:
MOV EAX,0x0
LAB_00101314:
TEST AL,AL
JZ 0x00101349
MOV EAX,dword ptr [RBP + -0x40]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001019de
MOV EAX,dword ptr [RAX]
LEA EBX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001019de
MOV dword ptr [RAX],EBX
LAB_00101349:
ADD dword ptr [RBP + -0x40],0x1
LAB_0010134d:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x44]
JL 0x001012a3
ADD dword ptr [RBP + -0x44],0x1
LAB_0010135d:
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x00101297
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x001013b1
LAB_00101372:
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001019de
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x48],EAX
SETL AL
TEST AL,AL
JZ 0x001013ad
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001019de
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x48],EAX
LAB_001013ad:
ADD dword ptr [RBP + -0x3c],0x1
LAB_001013b1:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x00101372
MOV EBX,dword ptr [RBP + -0x48]
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00101960
MOV EAX,EBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101413
JMP 0x0010140e
LAB_0010140e:
CALL 0x00101120
LAB_00101413:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<Pair, std::allocator<Pair> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
bool bVar2;
long lVar3;
int *piVar4;
int4 in_register_0000003c;
long in_FS_OFFSET;
allocator local_55;
int local_54;
int local_50;
int local_4c;
int local_48;
int local_44;
allocator *local_40;
vector<int,std::allocator<int>> local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_50 = 0;
local_40 = &local_55;
local_54 = 1;
/* try { // try from 00101279 to 0010127d has its CatchHandler @ 001013db */
std::vector<int,std::allocator<int>>::vector(local_38,(long)param_2,&local_54,&local_55);
std::__new_allocator<int>::~__new_allocator((__new_allocator<int> *)&local_55);
local_4c = 1;
do {
if (param_2 <= local_4c) {
for (local_44 = 0; iVar1 = local_50, local_44 < param_2; local_44 = local_44 + 1) {
piVar4 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_44);
if (local_50 < *piVar4) {
piVar4 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_44);
local_50 = *piVar4;
}
}
std::vector<int,std::allocator<int>>::~vector(local_38);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar1;
}
for (local_48 = 0; local_48 < local_4c; local_48 = local_48 + 1) {
piVar4 = (int *)std::vector<Pair,std::allocator<Pair>>::operator[]
((vector<Pair,std::allocator<Pair>> *)
CONCAT44(in_register_0000003c,param_1),(long)local_4c);
iVar1 = *piVar4;
lVar3 = std::vector<Pair,std::allocator<Pair>>::operator[]
((vector<Pair,std::allocator<Pair>> *)CONCAT44(in_register_0000003c,param_1)
,(long)local_48);
if (*(int *)(lVar3 + 4) < iVar1) {
piVar4 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_48);
iVar1 = *piVar4;
piVar4 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_4c);
if (iVar1 < *piVar4) goto LAB_0010130f;
bVar2 = true;
}
else {
LAB_0010130f:
bVar2 = false;
}
if (bVar2) {
piVar4 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_48);
iVar1 = *piVar4;
piVar4 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_4c);
*piVar4 = iVar1 + 1;
}
}
local_4c = local_4c + 1;
} while( true );
} |
2,401 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
class Pair {
public:
int a, b;
Pair(int a, int b) : a(a), b(b) {}
};
| int func0(std::vector<Pair> arr, int n) {
int max = 0;
std::vector<int> mcl(n, 1);
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mcl[i]) {
max = mcl[i];
}
}
return max;
}
| int main() {
assert(func0({Pair(5, 24), Pair(15, 25), Pair(27, 40), Pair(50, 60)}, 4) == 3);
assert(func0({Pair(1, 2), Pair(3, 4), Pair(5, 6), Pair(7, 8)}, 4) == 4);
assert(func0({Pair(19, 10), Pair(11, 12), Pair(13, 14), Pair(15, 16), Pair(31, 54)}, 5) == 5);
return 0;
}
| O1 | cpp | func0(std::vector<Pair, std::allocator<Pair> >, int):
endbr64
push %r12
push %rbp
push %rbx
movslq %esi,%rax
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 1291 <_Z5func0St6vectorI4PairSaIS0_EEi+0x68>
mov %rdi,%rbp
mov %esi,%ebx
mov $0x0,%r12d
test %rax,%rax
je 1305 <_Z5func0St6vectorI4PairSaIS0_EEi+0xdc>
lea 0x0(,%rax,4),%r12
mov %r12,%rdi
callq 1100 <_Znwm@plt>
mov %rax,%rdi
lea (%rax,%r12,1),%rdx
movl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 126e <_Z5func0St6vectorI4PairSaIS0_EEi+0x45>
cmp $0x1,%ebx
jle 12d9 <_Z5func0St6vectorI4PairSaIS0_EEi+0xb0>
lea -0x2(%rbx),%r9d
add $0x2,%r9
mov $0x1,%ecx
jmp 12c6 <_Z5func0St6vectorI4PairSaIS0_EEi+0x9d>
lea 0xd70(%rip),%rdi
callq 10c0 <_ZSt20__throw_length_errorPKc@plt>
add $0x1,%rdx
cmp %rdx,%rcx
je 12bd <_Z5func0St6vectorI4PairSaIS0_EEi+0x94>
cmp 0x4(%rax,%rdx,8),%r8d
jle 129d <_Z5func0St6vectorI4PairSaIS0_EEi+0x74>
mov (%rdi,%rdx,4),%esi
cmp (%rdi,%rcx,4),%esi
jl 129d <_Z5func0St6vectorI4PairSaIS0_EEi+0x74>
add $0x1,%esi
mov %esi,(%rdi,%rcx,4)
jmp 129d <_Z5func0St6vectorI4PairSaIS0_EEi+0x74>
add $0x1,%rcx
cmp %r9,%rcx
je 12e3 <_Z5func0St6vectorI4PairSaIS0_EEi+0xba>
test %ecx,%ecx
jle 12bd <_Z5func0St6vectorI4PairSaIS0_EEi+0x94>
mov 0x0(%rbp),%rax
mov (%rax,%rcx,8),%r8d
mov $0x0,%edx
jmp 12a6 <_Z5func0St6vectorI4PairSaIS0_EEi+0x7d>
mov $0x0,%r12d
test %ebx,%ebx
jle 1300 <_Z5func0St6vectorI4PairSaIS0_EEi+0xd7>
mov $0x0,%eax
mov $0x0,%r12d
mov (%rdi,%rax,4),%edx
cmp %edx,%r12d
cmovl %edx,%r12d
add $0x1,%rax
cmp %eax,%ebx
jg 12ee <_Z5func0St6vectorI4PairSaIS0_EEi+0xc5>
callq 10f0 <_ZdlPv@plt>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
| _Z5func0St6vectorI4PairSaIS0_EEi:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
movsxd rbp, esi
mov rax, rbp
shr rax, 3Dh
jnz short loc_1244
mov rbx, rdi
mov r13d, esi
test rbp, rbp
jz short loc_128D
lea r12, ds:0[rbp*4]
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; void *
lea rdx, [rax+r12]
loc_1225:
mov dword ptr [rax], 1
add rax, 4
cmp rdx, rax
jnz short loc_1225
cmp r13d, 1
jle short loc_129C
mov r9d, r13d
mov edx, 1
jmp short loc_127B
loc_1244:
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_1250:
add rax, 1
cmp rdx, rax
jz short loc_1272
loc_1259:
mov ecx, [rsi+rax*8+4]
cmp [r8], ecx
jle short loc_1250
mov ecx, [rdi+rax*4]
cmp ecx, [rdi+rdx*4]
jl short loc_1250
add ecx, 1
mov [rdi+rdx*4], ecx
jmp short loc_1250
loc_1272:
add rdx, 1
cmp rdx, r9
jz short loc_129C
loc_127B:
test edx, edx
jle short loc_12D2
mov rsi, [rbx]
lea r8, [rsi+rdx*8]
mov eax, 0
jmp short loc_1259
loc_128D:
mov r12, rbp
mov edi, 0
mov ebx, 0
jmp short loc_12B8
loc_129C:
mov rax, rdi
lea rcx, [rdi+rbp*4]
mov ebx, 0
loc_12A8:
mov edx, [rax]
cmp ebx, edx
cmovl ebx, edx
add rax, 4
cmp rcx, rax
jnz short loc_12A8
loc_12B8:
test rdi, rdi
jz short loc_12C5
mov rsi, r12; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_12C5:
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_12D2:
add rdx, 1
jmp short loc_127B | long long func0(long long *a1, int a2)
{
long long v2; // rbp
unsigned long long v5; // r12
unsigned int *v6; // rax
unsigned int *v7; // rdi
unsigned int *v8; // rdx
long long i; // rdx
long long v10; // rax
int v11; // ecx
long long v12; // rsi
_DWORD *v13; // r8
unsigned int v14; // ebx
unsigned int *v15; // rax
v2 = a2;
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( a2 )
{
v5 = a2;
v6 = (unsigned int *)operator new(v5 * 4);
v7 = v6;
v8 = &v6[v5];
do
*v6++ = 1;
while ( v8 != v6 );
if ( a2 > 1 )
{
for ( i = 1LL; i != a2; ++i )
{
while ( (int)i <= 0 )
++i;
v12 = *a1;
v13 = (_DWORD *)(*a1 + 8 * i);
v10 = 0LL;
do
{
if ( *v13 > *(_DWORD *)(v12 + 8 * v10 + 4) )
{
v11 = v7[v10];
if ( v11 >= (int)v7[i] )
v7[i] = v11 + 1;
}
++v10;
}
while ( i != v10 );
}
}
v15 = v7;
v14 = 0;
do
{
if ( (int)v14 < (int)*v15 )
v14 = *v15;
++v15;
}
while ( &v7[v2] != v15 );
}
else
{
v5 = 0LL;
v7 = 0LL;
v14 = 0;
}
if ( v7 )
operator delete(v7, v5 * 4);
return v14;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVSXD RBP,ESI
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x00101244
MOV RBX,RDI
MOV R13D,ESI
TEST RBP,RBP
JZ 0x0010128d
LEA R12,[RBP*0x4]
MOV RDI,R12
CALL 0x001010c0
MOV RDI,RAX
LEA RDX,[RAX + R12*0x1]
LAB_00101225:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x00101225
CMP R13D,0x1
JLE 0x0010129c
MOV R9D,R13D
MOV EDX,0x1
JMP 0x0010127b
LAB_00101244:
LEA RDI,[0x102008]
CALL 0x001010a0
LAB_00101250:
ADD RAX,0x1
CMP RDX,RAX
JZ 0x00101272
LAB_00101259:
MOV ECX,dword ptr [RSI + RAX*0x8 + 0x4]
CMP dword ptr [R8],ECX
JLE 0x00101250
MOV ECX,dword ptr [RDI + RAX*0x4]
CMP ECX,dword ptr [RDI + RDX*0x4]
JL 0x00101250
ADD ECX,0x1
MOV dword ptr [RDI + RDX*0x4],ECX
JMP 0x00101250
LAB_00101272:
ADD RDX,0x1
CMP RDX,R9
JZ 0x0010129c
LAB_0010127b:
TEST EDX,EDX
JLE 0x001012d2
MOV RSI,qword ptr [RBX]
LEA R8,[RSI + RDX*0x8]
MOV EAX,0x0
JMP 0x00101259
LAB_0010128d:
MOV R12,RBP
MOV EDI,0x0
MOV EBX,0x0
JMP 0x001012b8
LAB_0010129c:
MOV RAX,RDI
LEA RCX,[RDI + RBP*0x4]
MOV EBX,0x0
LAB_001012a8:
MOV EDX,dword ptr [RAX]
CMP EBX,EDX
CMOVL EBX,EDX
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x001012a8
LAB_001012b8:
TEST RDI,RDI
JZ 0x001012c5
MOV RSI,R12
CALL 0x001010d0
LAB_001012c5:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001012d2:
ADD RDX,0x1
JMP 0x0010127b | /* func0(std::vector<Pair, std::allocator<Pair> >, int) */
int func0(vector param_1,int param_2)
{
int auVar1 [16];
int auVar2 [16];
char *pcVar3;
ulong uVar4;
int *piVar5;
ulong uVar6;
int iVar7;
long *unaff_RBX;
long *plVar8;
ulong uVar9;
int4 in_register_00000034;
long lVar10;
int4 in_register_0000003c;
int *in_R8;
ulong in_R9;
ulong unaff_R12;
int auVar11 [16];
plVar8 = (long *)CONCAT44(in_register_0000003c,param_1);
lVar10 = CONCAT44(in_register_00000034,param_2);
uVar9 = (ulong)param_2;
if (uVar9 >> 0x3d == 0) {
if (uVar9 == 0) {
pcVar3 = (char *)0x0;
iVar7 = 0;
unaff_R12 = 0;
}
else {
unaff_R12 = uVar9 * 4;
pcVar3 = (char *)operator_new(unaff_R12);
piVar5 = (int *)pcVar3;
do {
*piVar5 = 1;
piVar5 = piVar5 + 1;
} while ((int *)((long)pcVar3 + uVar9 * 4) != piVar5);
if (1 < param_2) {
in_R9 = (ulong)(uint)param_2;
uVar6 = 1;
do {
for (; (int)uVar6 < 1; uVar6 = uVar6 + 1) {
}
lVar10 = *plVar8;
in_R8 = (int *)(lVar10 + uVar6 * 8);
uVar4 = 0;
do {
auVar2._8_8_ = uVar6;
auVar2._0_8_ = uVar4;
auVar1._8_8_ = uVar6;
auVar1._0_8_ = uVar4;
auVar11._8_8_ = uVar6;
auVar11._0_8_ = uVar4;
if ((*(int *)(lVar10 + 4 + uVar4 * 8) < *in_R8) &&
(auVar11 = auVar1,
*(int *)((long)pcVar3 + uVar6 * 4) <= *(int *)((long)pcVar3 + uVar4 * 4))) {
*(int *)((long)pcVar3 + uVar6 * 4) = *(int *)((long)pcVar3 + uVar4 * 4) + 1;
auVar11 = auVar2;
}
LAB_00101250:
uVar6 = auVar11._8_8_;
uVar4 = auVar11._0_8_ + 1;
} while (uVar6 != uVar4);
uVar6 = uVar6 + 1;
} while (uVar6 != in_R9);
}
iVar7 = 0;
piVar5 = (int *)pcVar3;
do {
if (iVar7 < *piVar5) {
iVar7 = *piVar5;
}
piVar5 = piVar5 + 1;
} while ((int *)((long)pcVar3 + uVar9 * 4) != piVar5);
}
if ((int *)pcVar3 != (int *)0x0) {
operator_delete(pcVar3,unaff_R12);
}
return iVar7;
}
pcVar3 = "cannot create std::vector larger than max_size()";
auVar11 = std::__throw_length_error("cannot create std::vector larger than max_size()");
plVar8 = unaff_RBX;
goto LAB_00101250;
} |
2,402 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
class Pair {
public:
int a, b;
Pair(int a, int b) : a(a), b(b) {}
};
| int func0(std::vector<Pair> arr, int n) {
int max = 0;
std::vector<int> mcl(n, 1);
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mcl[i]) {
max = mcl[i];
}
}
return max;
}
| int main() {
assert(func0({Pair(5, 24), Pair(15, 25), Pair(27, 40), Pair(50, 60)}, 4) == 3);
assert(func0({Pair(1, 2), Pair(3, 4), Pair(5, 6), Pair(7, 8)}, 4) == 4);
assert(func0({Pair(19, 10), Pair(11, 12), Pair(13, 14), Pair(15, 16), Pair(31, 54)}, 5) == 5);
return 0;
}
| O2 | cpp | func0(std::vector<Pair, std::allocator<Pair> >, int):
endbr64
movabs $0x1fffffffffffffff,%rdx
movslq %esi,%rax
push %r12
push %rbp
push %rbx
cmp %rdx,%rax
ja 15b9 <_Z5func0St6vectorI4PairSaIS0_EEi+0xe9>
xor %r12d,%r12d
test %rax,%rax
je 15aa <_Z5func0St6vectorI4PairSaIS0_EEi+0xda>
lea 0x0(,%rax,4),%r12
mov %rdi,%rbp
mov %rax,%rbx
mov %r12,%rdi
callq 1100 <_Znwm@plt>
mov %rax,%r8
lea (%rax,%r12,1),%rdx
nopw 0x0(%rax,%rax,1)
movl $0x1,(%rax)
add $0x4,%rax
cmp %rax,%rdx
jne 1520 <_Z5func0St6vectorI4PairSaIS0_EEi+0x50>
cmp $0x1,%ebx
jle 15b2 <_Z5func0St6vectorI4PairSaIS0_EEi+0xe2>
lea -0x2(%rbx),%esi
mov 0x0(%rbp),%rax
mov $0x1,%ecx
add $0x2,%rsi
nopl 0x0(%rax)
mov (%rax,%rcx,8),%r9d
xor %edx,%edx
xchg %ax,%ax
cmp 0x4(%rax,%rdx,8),%r9d
jle 1568 <_Z5func0St6vectorI4PairSaIS0_EEi+0x98>
mov (%r8,%rdx,4),%edi
cmp (%r8,%rcx,4),%edi
jl 1568 <_Z5func0St6vectorI4PairSaIS0_EEi+0x98>
add $0x1,%edi
mov %edi,(%r8,%rcx,4)
add $0x1,%rdx
cmp %rcx,%rdx
jne 1550 <_Z5func0St6vectorI4PairSaIS0_EEi+0x80>
add $0x1,%rcx
cmp %rcx,%rsi
jne 1548 <_Z5func0St6vectorI4PairSaIS0_EEi+0x78>
lea -0x1(%rbx),%edx
mov %r8,%rax
xor %r12d,%r12d
lea 0x4(%r8,%rdx,4),%rcx
nopl 0x0(%rax,%rax,1)
mov (%rax),%edx
cmp %edx,%r12d
cmovl %edx,%r12d
add $0x4,%rax
cmp %rax,%rcx
jne 1590 <_Z5func0St6vectorI4PairSaIS0_EEi+0xc0>
mov %r8,%rdi
callq 10f0 <_ZdlPv@plt>
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
retq
je 157a <_Z5func0St6vectorI4PairSaIS0_EEi+0xaa>
xor %r12d,%r12d
jmp 15a2 <_Z5func0St6vectorI4PairSaIS0_EEi+0xd2>
lea 0xa48(%rip),%rdi
callq 10c0 <_ZSt20__throw_length_errorPKc@plt>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0St6vectorI4PairSaIS0_EEi:
endbr64
push r13
push r12
movsxd r12, esi
push rbp
mov rax, r12
push rbx
sub rsp, 8
shr rax, 3Dh
jnz loc_151D
xor ebx, ebx
test r12, r12
jz loc_1510
mov rbp, r12
shl r12, 2
mov r13, rdi
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; void *
lea r10, [rax+r12]
test r12b, 4
jz short loc_1460
mov dword ptr [rax], 1
lea rax, [rax+4]
cmp r10, rax
jz short loc_1476
nop word ptr [rax+rax+00000000h]
loc_1460:
mov dword ptr [rax], 1
add rax, 8
mov dword ptr [rax-4], 1
cmp r10, rax
jnz short loc_1460
loc_1476:
cmp ebp, 1
jz short loc_14C6
mov r9, [r13+0]
mov esi, ebp
mov edx, 1
lea r8, [r9+8]
nop word ptr [rax+rax+00h]
loc_1490:
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1498:
mov ebx, [r9+rax*8+4]
cmp [r8], ebx
jle short loc_14B0
mov ecx, [rdi+rax*4]
cmp ecx, [rdi+rdx*4]
jl short loc_14B0
add ecx, 1
mov [rdi+rdx*4], ecx
loc_14B0:
add rax, 1
cmp rax, rdx
jnz short loc_1498
add rdx, 1
add r8, 8
cmp rdx, rsi
jnz short loc_1490
loc_14C6:
mov rdx, r10
xor ebx, ebx
mov rax, rdi
sub rdx, rdi
and edx, 4
jz short loc_14F0
mov eax, [rdi]
cmp ebx, eax
cmovl ebx, eax
lea rax, [rdi+4]
cmp r10, rax
jz short loc_1508
nop word ptr [rax+rax+00000000h]
loc_14F0:
mov edx, [rax]
cmp ebx, edx
cmovl ebx, edx
mov edx, [rax+4]
cmp ebx, edx
cmovl ebx, edx
add rax, 8
cmp r10, rax
jnz short loc_14F0
loc_1508:
mov rsi, r12; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1510:
add rsp, 8
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_151D:
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*) | long long func0(_QWORD *a1, int a2)
{
int v2; // ebx
unsigned long long v3; // r12
int *v5; // rax
int *v6; // rdi
int *v7; // r10
long long v8; // r9
long long v9; // rdx
_DWORD *v10; // r8
long long v11; // rax
int v12; // ecx
int *v13; // rax
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v2 = 0;
if ( a2 )
{
v3 = 4LL * a2;
v5 = (int *)operator new(v3);
v6 = v5;
v7 = &v5[v3 / 4];
if ( (v3 & 4) == 0 || (*v5 = 1, ++v5, v7 != v5) )
{
do
{
*v5 = 1;
v5 += 2;
*(v5 - 1) = 1;
}
while ( v7 != v5 );
}
if ( a2 != 1 )
{
v8 = *a1;
v9 = 1LL;
v10 = (_DWORD *)(*a1 + 8LL);
do
{
v11 = 0LL;
do
{
if ( *v10 > *(_DWORD *)(v8 + 8 * v11 + 4) )
{
v12 = v6[v11];
if ( v12 >= v6[v9] )
v6[v9] = v12 + 1;
}
++v11;
}
while ( v11 != v9 );
++v9;
v10 += 2;
}
while ( v9 != a2 );
}
v2 = 0;
v13 = v6;
if ( (((_BYTE)v7 - (_BYTE)v6) & 4) == 0 )
goto LABEL_28;
if ( *v6 > 0 )
v2 = *v6;
v13 = v6 + 1;
if ( v7 != v6 + 1 )
{
LABEL_28:
do
{
if ( v2 < *v13 )
v2 = *v13;
if ( v2 < v13[1] )
v2 = v13[1];
v13 += 2;
}
while ( v7 != v13 );
}
operator delete(v6, v3);
}
return (unsigned int)v2;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RAX,R12
PUSH RBX
SUB RSP,0x8
SHR RAX,0x3d
JNZ 0x0010151d
XOR EBX,EBX
TEST R12,R12
JZ 0x00101510
MOV RBP,R12
SHL R12,0x2
MOV R13,RDI
MOV RDI,R12
CALL 0x001010e0
MOV RDI,RAX
LEA R10,[RAX + R12*0x1]
TEST R12B,0x4
JZ 0x00101460
MOV dword ptr [RAX],0x1
LEA RAX,[RAX + 0x4]
CMP R10,RAX
JZ 0x00101476
NOP word ptr [RAX + RAX*0x1]
LAB_00101460:
MOV dword ptr [RAX],0x1
ADD RAX,0x8
MOV dword ptr [RAX + -0x4],0x1
CMP R10,RAX
JNZ 0x00101460
LAB_00101476:
CMP EBP,0x1
JZ 0x001014c6
MOV R9,qword ptr [R13]
MOV ESI,EBP
MOV EDX,0x1
LEA R8,[R9 + 0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101490:
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101498:
MOV EBX,dword ptr [R9 + RAX*0x8 + 0x4]
CMP dword ptr [R8],EBX
JLE 0x001014b0
MOV ECX,dword ptr [RDI + RAX*0x4]
CMP ECX,dword ptr [RDI + RDX*0x4]
JL 0x001014b0
ADD ECX,0x1
MOV dword ptr [RDI + RDX*0x4],ECX
LAB_001014b0:
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x00101498
ADD RDX,0x1
ADD R8,0x8
CMP RDX,RSI
JNZ 0x00101490
LAB_001014c6:
MOV RDX,R10
XOR EBX,EBX
MOV RAX,RDI
SUB RDX,RDI
AND EDX,0x4
JZ 0x001014f0
MOV EAX,dword ptr [RDI]
CMP EBX,EAX
CMOVL EBX,EAX
LEA RAX,[RDI + 0x4]
CMP R10,RAX
JZ 0x00101508
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001014f0:
MOV EDX,dword ptr [RAX]
CMP EBX,EDX
CMOVL EBX,EDX
MOV EDX,dword ptr [RAX + 0x4]
CMP EBX,EDX
CMOVL EBX,EDX
ADD RAX,0x8
CMP R10,RAX
JNZ 0x001014f0
LAB_00101508:
MOV RSI,R12
CALL 0x001010f0
LAB_00101510:
ADD RSP,0x8
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_0010151d:
LEA RDI,[0x102008]
CALL 0x001010b0
NOP dword ptr [RAX] | /* func0(std::vector<Pair, std::allocator<Pair> >, int) */
void * func0(vector param_1,int param_2)
{
uint *puVar1;
void *pvVar2;
int *piVar3;
uint *puVar4;
ulong uVar5;
uint *puVar6;
void *__dest;
int8 uVar7;
long extraout_RDX;
uint uVar8;
int4 in_register_00000034;
void *pvVar9;
int4 in_register_0000003c;
char *pcVar10;
int *piVar11;
ulong uVar12;
ulong uVar13;
void *pvVar14;
pvVar9 = (void *)CONCAT44(in_register_00000034,param_2);
uVar12 = (ulong)param_2;
if (uVar12 >> 0x3d == 0) {
uVar8 = 0;
if (uVar12 != 0) {
uVar13 = uVar12 * 4;
puVar4 = (uint *)operator_new(uVar13);
puVar1 = puVar4 + uVar12;
puVar6 = puVar4;
if ((uVar13 & 4) == 0) goto LAB_00101460;
*puVar4 = 1;
for (puVar6 = puVar4 + 1; puVar1 != puVar6; puVar6 = puVar6 + 2) {
LAB_00101460:
*puVar6 = 1;
puVar6[1] = 1;
}
if (param_2 != 1) {
piVar3 = *(int **)CONCAT44(in_register_0000003c,param_1);
uVar12 = 1;
piVar11 = piVar3;
do {
piVar11 = piVar11 + 2;
uVar5 = 0;
do {
if ((piVar3[uVar5 * 2 + 1] < *piVar11) && ((int)puVar4[uVar12] <= (int)puVar4[uVar5])) {
puVar4[uVar12] = puVar4[uVar5] + 1;
}
uVar5 = uVar5 + 1;
} while (uVar5 != uVar12);
uVar12 = uVar12 + 1;
} while (uVar12 != (uint)param_2);
}
uVar8 = 0;
puVar6 = puVar4;
if (((int)puVar1 - (int)puVar4 & 4U) == 0) goto LAB_001014f0;
if (0 < (int)*puVar4) {
uVar8 = *puVar4;
}
for (puVar6 = puVar4 + 1; puVar1 != puVar6; puVar6 = puVar6 + 2) {
LAB_001014f0:
if ((int)uVar8 < (int)*puVar6) {
uVar8 = *puVar6;
}
if ((int)uVar8 < (int)puVar6[1]) {
uVar8 = puVar6[1];
}
}
operator_delete(puVar4,uVar13);
}
return (void *)(ulong)uVar8;
}
pcVar10 = "cannot create std::vector larger than max_size()";
std::__throw_length_error("cannot create std::vector larger than max_size()");
uVar12 = extraout_RDX * 8;
*(int8 *)*(int (*) [16])((long)pcVar10 + 0x10) = 0;
*(int (*) [16])pcVar10 = (int [16])0x0;
if (uVar12 < 0x7ffffffffffffff9) {
if (uVar12 != 0) {
__dest = operator_new(uVar12);
pvVar2 = (void *)((long)__dest + uVar12);
*(void **)*(int (*) [16])pcVar10 = __dest;
*(void **)*(int (*) [16])((long)pcVar10 + 0x10) = pvVar2;
pvVar14 = __dest;
if (uVar12 != 0) {
__dest = memcpy(__dest,pvVar9,uVar12);
pvVar14 = pvVar2;
}
*(void **)(*(int (*) [16])pcVar10 + 8) = pvVar14;
return __dest;
}
*(int8 *)*(int (*) [16])pcVar10 = 0;
*(int8 *)*(int (*) [16])((long)pcVar10 + 0x10) = 0;
*(int8 *)(*(int (*) [16])pcVar10 + 8) = 0;
return (void *)0x7ffffffffffffff8;
}
uVar7 = std::__throw_length_error("cannot create std::vector larger than max_size()");
pvVar9 = *(void **)*(int (*) [16])pcVar10;
if (pvVar9 != (void *)0x0) {
operator_delete(pvVar9,*(long *)*(int (*) [16])((long)pcVar10 + 0x10) - (long)pvVar9);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar7);
} |
2,403 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
class Pair {
public:
int a, b;
Pair(int a, int b) : a(a), b(b) {}
};
| int func0(std::vector<Pair> arr, int n) {
int max = 0;
std::vector<int> mcl(n, 1);
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i].a > arr[j].b && mcl[i] < mcl[j] + 1) {
mcl[i] = mcl[j] + 1;
}
}
}
for (int i = 0; i < n; i++) {
if (max < mcl[i]) {
max = mcl[i];
}
}
return max;
}
| int main() {
assert(func0({Pair(5, 24), Pair(15, 25), Pair(27, 40), Pair(50, 60)}, 4) == 3);
assert(func0({Pair(1, 2), Pair(3, 4), Pair(5, 6), Pair(7, 8)}, 4) == 4);
assert(func0({Pair(19, 10), Pair(11, 12), Pair(13, 14), Pair(15, 16), Pair(31, 54)}, 5) == 5);
return 0;
}
| O3 | cpp | func0(std::vector<Pair, std::allocator<Pair> >, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r13
push %r12
push %rbp
movslq %esi,%rbp
push %rbx
sub $0x8,%rsp
cmp %rax,%rbp
ja 1665 <_Z5func0St6vectorI4PairSaIS0_EEi+0x205>
xor %r12d,%r12d
test %rbp,%rbp
je 163d <_Z5func0St6vectorI4PairSaIS0_EEi+0x1dd>
mov %rdi,%r13
lea 0x0(,%rbp,4),%rdi
mov %rbp,%rbx
callq 1100 <_Znwm@plt>
mov %rax,%r8
lea -0x1(%rbp),%rax
cmp $0x2,%rax
mov %r8,%rax
jbe 165d <_Z5func0St6vectorI4PairSaIS0_EEi+0x1fd>
mov %rbp,%rdx
movdqa 0xcbe(%rip),%xmm0
shr $0x2,%rdx
shl $0x4,%rdx
add %r8,%rdx
nopl (%rax)
movups %xmm0,(%rax)
add $0x10,%rax
cmp %rdx,%rax
jne 14d0 <_Z5func0St6vectorI4PairSaIS0_EEi+0x70>
mov %rbp,%rdx
mov %rbp,%rcx
and $0xfffffffffffffffc,%rdx
and $0x3,%ecx
lea (%r8,%rdx,4),%rax
cmp %rdx,%rbp
je 1512 <_Z5func0St6vectorI4PairSaIS0_EEi+0xb2>
movl $0x1,(%rax)
cmp $0x1,%rcx
je 1512 <_Z5func0St6vectorI4PairSaIS0_EEi+0xb2>
movl $0x1,0x4(%rax)
cmp $0x2,%rcx
je 1512 <_Z5func0St6vectorI4PairSaIS0_EEi+0xb2>
movl $0x1,0x8(%rax)
cmp $0x1,%ebx
jle 164b <_Z5func0St6vectorI4PairSaIS0_EEi+0x1eb>
lea -0x2(%rbx),%r10d
mov 0x0(%r13),%rax
mov $0x1,%ecx
add $0x2,%r10
nopl 0x0(%rax)
mov (%rax,%rcx,8),%r9d
xor %edx,%edx
nopw %cs:0x0(%rax,%rax,1)
cmp 0x4(%rax,%rdx,8),%r9d
jle 1558 <_Z5func0St6vectorI4PairSaIS0_EEi+0xf8>
mov (%r8,%rdx,4),%edi
cmp (%r8,%rcx,4),%edi
jl 1558 <_Z5func0St6vectorI4PairSaIS0_EEi+0xf8>
add $0x1,%edi
mov %edi,(%r8,%rcx,4)
add $0x1,%rdx
cmp %rcx,%rdx
jne 1540 <_Z5func0St6vectorI4PairSaIS0_EEi+0xe0>
add $0x1,%rcx
cmp %r10,%rcx
jne 1530 <_Z5func0St6vectorI4PairSaIS0_EEi+0xd0>
lea -0x1(%rbx),%eax
cmp $0x2,%eax
jbe 1656 <_Z5func0St6vectorI4PairSaIS0_EEi+0x1f6>
mov %ebx,%edx
mov %r8,%rax
pxor %xmm2,%xmm2
shr $0x2,%edx
shl $0x4,%rdx
add %r8,%rdx
nopl 0x0(%rax)
movdqu (%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rdx,%rax
jne 1590 <_Z5func0St6vectorI4PairSaIS0_EEi+0x130>
movdqa %xmm2,%xmm1
mov %ebx,%eax
psrldq $0x8,%xmm1
and $0xfffffffc,%eax
movdqa %xmm1,%xmm0
pcmpgtd %xmm2,%xmm0
pand %xmm0,%xmm1
pandn %xmm2,%xmm0
por %xmm0,%xmm1
movdqa %xmm1,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm0
pcmpgtd %xmm1,%xmm0
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movd %xmm0,%r12d
test $0x3,%bl
je 1635 <_Z5func0St6vectorI4PairSaIS0_EEi+0x1d5>
movslq %eax,%rdx
mov (%r8,%rdx,4),%edx
cmp %edx,%r12d
cmovl %edx,%r12d
lea 0x1(%rax),%edx
cmp %ebx,%edx
jge 1635 <_Z5func0St6vectorI4PairSaIS0_EEi+0x1d5>
movslq %edx,%rdx
mov (%r8,%rdx,4),%edx
cmp %edx,%r12d
cmovl %edx,%r12d
add $0x2,%eax
cmp %ebx,%eax
jge 1635 <_Z5func0St6vectorI4PairSaIS0_EEi+0x1d5>
cltq
mov (%r8,%rax,4),%eax
cmp %eax,%r12d
cmovl %eax,%r12d
mov %r8,%rdi
callq 10f0 <_ZdlPv@plt>
add $0x8,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
je 156a <_Z5func0St6vectorI4PairSaIS0_EEi+0x10a>
xor %r12d,%r12d
jmp 1635 <_Z5func0St6vectorI4PairSaIS0_EEi+0x1d5>
xor %eax,%eax
xor %r12d,%r12d
jmp 15fe <_Z5func0St6vectorI4PairSaIS0_EEi+0x19e>
mov %rbp,%rcx
jmpq 14f2 <_Z5func0St6vectorI4PairSaIS0_EEi+0x92>
lea 0x99c(%rip),%rdi
callq 10c0 <_ZSt20__throw_length_errorPKc@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0St6vectorI4PairSaIS0_EEi:
endbr64
push r13
push r12
movsxd r12, esi
push rbp
mov rax, r12
push rbx
sub rsp, 8
shr rax, 3Dh
jnz loc_160E
xor ebx, ebx
test r12, r12
jz loc_15E9
mov rbp, r12
shl r12, 2
mov r13, rdi
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; void *
lea r8, [rax+r12]
lea rax, [r12-4]
mov rdx, rax
shr rdx, 2
add rdx, 1
cmp rax, 8
mov rax, rdi
jbe short loc_14A5
mov rcx, rdx
movdqa xmm0, cs:xmmword_2160
shr rcx, 2
shl rcx, 4
lea rsi, [rcx+rdi]
and ecx, 10h
jz short loc_1488
lea rax, [rdi+10h]
movups xmmword ptr [rdi], xmm0
cmp rax, rsi
jz short loc_1498
nop dword ptr [rax+rax+00h]
loc_1488:
movups xmmword ptr [rax], xmm0
add rax, 20h ; ' '
movups xmmword ptr [rax-10h], xmm0
cmp rax, rsi
jnz short loc_1488
loc_1498:
test dl, 3
jz short loc_14CB
and rdx, 0FFFFFFFFFFFFFFFCh
lea rax, [rdi+rdx*4]
loc_14A5:
lea rdx, [rax+4]
mov dword ptr [rax], 1
cmp r8, rdx
jz short loc_14CB
lea rdx, [rax+8]
mov dword ptr [rax+4], 1
cmp r8, rdx
jz short loc_14CB
mov dword ptr [rax+8], 1
loc_14CB:
cmp ebp, 1
jz loc_1603
mov r8, [r13+0]
mov r9d, ebp
mov edx, 1
lea rsi, [r8+8]
nop dword ptr [rax+00h]
loc_14E8:
xor eax, eax
nop word ptr [rax+rax+00h]
loc_14F0:
mov ebx, [r8+rax*8+4]
cmp [rsi], ebx
jle short loc_1507
mov ecx, [rdi+rax*4]
cmp ecx, [rdi+rdx*4]
jl short loc_1507
add ecx, 1
mov [rdi+rdx*4], ecx
loc_1507:
add rax, 1
cmp rax, rdx
jnz short loc_14F0
lea rdx, [rax+1]
add rsi, 8
cmp rdx, r9
jnz short loc_14E8
lea eax, [rbp-1]
cmp eax, 2
jbe loc_15F6
mov edx, ebp
mov rax, rdi
pxor xmm2, xmm2
shr edx, 2
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00h]
loc_1540:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rax, rdx
jnz short loc_1540
movdqa xmm1, xmm2
mov eax, ebp
psrldq xmm1, 8
and eax, 0FFFFFFFCh
movdqa xmm0, xmm1
pcmpgtd xmm0, xmm2
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd ebx, xmm1
test bpl, 3
jz short loc_15E1
movsxd rcx, eax
lea rdx, ds:0[rcx*4]
mov ecx, [rdi+rcx*4]
cmp ebx, ecx
cmovl ebx, ecx
lea ecx, [rax+1]
cmp ecx, ebp
jge short loc_15E1
loc_15C8:
mov ecx, [rdi+rdx+4]
cmp ebx, ecx
cmovl ebx, ecx
add eax, 2
cmp ebp, eax
jle short loc_15E1
mov eax, [rdi+rdx+8]
cmp ebx, eax
cmovl ebx, eax
loc_15E1:
mov rsi, r12; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_15E9:
add rsp, 8
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_15F6:
mov ebx, [rdi]
xor eax, eax
test ebx, ebx
cmovs ebx, eax
xor edx, edx
jmp short loc_15C8
loc_1603:
mov ebx, [rdi]
xor eax, eax
test ebx, ebx
cmovs ebx, eax
jmp short loc_15E1
loc_160E:
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*) | long long func0(_QWORD *a1, int a2)
{
int v2; // ebx
unsigned long long v4; // r12
__m128i *v6; // rax
__m128i *v7; // rdi
char *v8; // r8
unsigned long long v9; // rdx
__m128i si128; // xmm0
long long v11; // rcx
__m128i *v12; // rsi
long long v13; // r8
long long v14; // rdx
_DWORD *v15; // rsi
long long v16; // rax
__int32 v17; // ecx
const __m128i *v18; // rax
__m128i v19; // xmm2
__m128i v20; // xmm0
__m128i v21; // xmm1
__m128i v22; // xmm1
signed int v23; // eax
__m128i v24; // xmm0
__m128i v25; // xmm0
__m128i v26; // xmm2
__m128i v27; // xmm1
long long v28; // rdx
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v2 = 0;
if ( a2 )
{
v4 = 4LL * a2;
v6 = (__m128i *)operator new(v4);
v7 = v6;
v8 = &v6->m128i_i8[v4];
v9 = ((v4 - 4) >> 2) + 1;
if ( v4 - 4 > 8 )
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2160);
v11 = v9 >> 2;
v12 = &v6[v11];
if ( ((v11 * 16) & 0x10) == 0 || (++v6, *v7 = si128, &v7[1] != v12) )
{
do
{
*v6 = si128;
v6 += 2;
v6[-1] = si128;
}
while ( v6 != v12 );
}
if ( (v9 & 3) == 0 )
{
LABEL_12:
if ( a2 == 1 )
{
v2 = v7->m128i_i32[0];
if ( v7->m128i_i32[0] < 0 )
v2 = 0;
goto LABEL_32;
}
v13 = *a1;
v14 = 1LL;
v15 = (_DWORD *)(*a1 + 8LL);
do
{
v16 = 0LL;
do
{
if ( *v15 > *(_DWORD *)(v13 + 8 * v16 + 4) )
{
v17 = v7->m128i_i32[v16];
if ( v17 >= v7->m128i_i32[v14] )
v7->m128i_i32[v14] = v17 + 1;
}
++v16;
}
while ( v16 != v14 );
v14 = v16 + 1;
v15 += 2;
}
while ( v16 + 1 != a2 );
if ( (unsigned int)(a2 - 1) <= 2 )
{
v2 = v7->m128i_i32[0];
v23 = 0;
if ( v7->m128i_i32[0] < 0 )
v2 = 0;
v28 = 0LL;
}
else
{
v18 = v7;
v19 = 0LL;
do
{
v20 = _mm_loadu_si128(v18++);
v21 = _mm_cmpgt_epi32(v20, v19);
v19 = _mm_or_si128(_mm_andnot_si128(v21, v19), _mm_and_si128(v20, v21));
}
while ( v18 != &v7[(unsigned int)a2 >> 2] );
v22 = _mm_srli_si128(v19, 8);
v23 = a2 & 0xFFFFFFFC;
v24 = _mm_cmpgt_epi32(v22, v19);
v25 = _mm_or_si128(_mm_andnot_si128(v24, v19), _mm_and_si128(v22, v24));
v26 = _mm_srli_si128(v25, 4);
v27 = _mm_cmpgt_epi32(v26, v25);
v2 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v27, v25), _mm_and_si128(v26, v27)));
if ( (a2 & 3) == 0 )
goto LABEL_32;
v28 = v23;
if ( v2 < v7->m128i_i32[v28] )
v2 = v7->m128i_i32[v23];
if ( v23 + 1 >= a2 )
goto LABEL_32;
}
if ( v2 < v7->m128i_i32[v28 + 1] )
v2 = v7->m128i_i32[v28 + 1];
if ( a2 > v23 + 2 && v2 < v7->m128i_i32[v28 + 2] )
v2 = v7->m128i_i32[v28 + 2];
LABEL_32:
operator delete(v7, v4);
return (unsigned int)v2;
}
v6 = (__m128i *)((char *)v7 + 4 * (v9 & 0xFFFFFFFFFFFFFFFCLL));
}
v6->m128i_i32[0] = 1;
if ( v8 != (char *)v6->m128i_i64 + 4 )
{
v6->m128i_i32[1] = 1;
if ( v8 != (char *)&v6->m128i_u64[1] )
v6->m128i_i32[2] = 1;
}
goto LABEL_12;
}
return (unsigned int)v2;
} | func0:
ENDBR64
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
MOV RAX,R12
PUSH RBX
SUB RSP,0x8
SHR RAX,0x3d
JNZ 0x0010160e
XOR EBX,EBX
TEST R12,R12
JZ 0x001015e9
MOV RBP,R12
SHL R12,0x2
MOV R13,RDI
MOV RDI,R12
CALL 0x001010e0
MOV RDI,RAX
LEA R8,[RAX + R12*0x1]
LEA RAX,[R12 + -0x4]
MOV RDX,RAX
SHR RDX,0x2
ADD RDX,0x1
CMP RAX,0x8
MOV RAX,RDI
JBE 0x001014a5
MOV RCX,RDX
MOVDQA XMM0,xmmword ptr [0x00102160]
SHR RCX,0x2
SHL RCX,0x4
LEA RSI,[RCX + RDI*0x1]
AND ECX,0x10
JZ 0x00101488
LEA RAX,[RDI + 0x10]
MOVUPS xmmword ptr [RDI],XMM0
CMP RAX,RSI
JZ 0x00101498
NOP dword ptr [RAX + RAX*0x1]
LAB_00101488:
MOVUPS xmmword ptr [RAX],XMM0
ADD RAX,0x20
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP RAX,RSI
JNZ 0x00101488
LAB_00101498:
TEST DL,0x3
JZ 0x001014cb
AND RDX,-0x4
LEA RAX,[RDI + RDX*0x4]
LAB_001014a5:
LEA RDX,[RAX + 0x4]
MOV dword ptr [RAX],0x1
CMP R8,RDX
JZ 0x001014cb
LEA RDX,[RAX + 0x8]
MOV dword ptr [RAX + 0x4],0x1
CMP R8,RDX
JZ 0x001014cb
MOV dword ptr [RAX + 0x8],0x1
LAB_001014cb:
CMP EBP,0x1
JZ 0x00101603
MOV R8,qword ptr [R13]
MOV R9D,EBP
MOV EDX,0x1
LEA RSI,[R8 + 0x8]
NOP dword ptr [RAX]
LAB_001014e8:
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_001014f0:
MOV EBX,dword ptr [R8 + RAX*0x8 + 0x4]
CMP dword ptr [RSI],EBX
JLE 0x00101507
MOV ECX,dword ptr [RDI + RAX*0x4]
CMP ECX,dword ptr [RDI + RDX*0x4]
JL 0x00101507
ADD ECX,0x1
MOV dword ptr [RDI + RDX*0x4],ECX
LAB_00101507:
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x001014f0
LEA RDX,[RAX + 0x1]
ADD RSI,0x8
CMP RDX,R9
JNZ 0x001014e8
LEA EAX,[RBP + -0x1]
CMP EAX,0x2
JBE 0x001015f6
MOV EDX,EBP
MOV RAX,RDI
PXOR XMM2,XMM2
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101540:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RAX,RDX
JNZ 0x00101540
MOVDQA XMM1,XMM2
MOV EAX,EBP
PSRLDQ XMM1,0x8
AND EAX,0xfffffffc
MOVDQA XMM0,XMM1
PCMPGTD XMM0,XMM2
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EBX,XMM1
TEST BPL,0x3
JZ 0x001015e1
MOVSXD RCX,EAX
LEA RDX,[RCX*0x4]
MOV ECX,dword ptr [RDI + RCX*0x4]
CMP EBX,ECX
CMOVL EBX,ECX
LEA ECX,[RAX + 0x1]
CMP ECX,EBP
JGE 0x001015e1
LAB_001015c8:
MOV ECX,dword ptr [RDI + RDX*0x1 + 0x4]
CMP EBX,ECX
CMOVL EBX,ECX
ADD EAX,0x2
CMP EBP,EAX
JLE 0x001015e1
MOV EAX,dword ptr [RDI + RDX*0x1 + 0x8]
CMP EBX,EAX
CMOVL EBX,EAX
LAB_001015e1:
MOV RSI,R12
CALL 0x001010f0
LAB_001015e9:
ADD RSP,0x8
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001015f6:
MOV EBX,dword ptr [RDI]
XOR EAX,EAX
TEST EBX,EBX
CMOVS EBX,EAX
XOR EDX,EDX
JMP 0x001015c8
LAB_00101603:
MOV EBX,dword ptr [RDI]
XOR EAX,EAX
TEST EBX,EBX
CMOVS EBX,EAX
JMP 0x001015e1
LAB_0010160e:
LEA RDI,[0x102008]
CALL 0x001010b0
NOP word ptr [RAX + RAX*0x1] | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<Pair, std::allocator<Pair> >, int) */
void * func0(vector param_1,int param_2)
{
void *pvVar1;
int *piVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
int8 uVar6;
ulong uVar7;
uint uVar8;
uint *puVar9;
ulong uVar10;
uint *puVar11;
void *__dest;
int8 uVar12;
ulong uVar13;
long lVar14;
long extraout_RDX;
uint uVar15;
int4 in_register_00000034;
void *pvVar16;
int *piVar17;
int4 in_register_0000003c;
char *pcVar18;
ulong uVar19;
ulong uVar20;
void *pvVar21;
uint uVar22;
uint uVar23;
uint uVar24;
uint uVar25;
uint uVar26;
uint uVar27;
uint uVar28;
pvVar16 = (void *)CONCAT44(in_register_00000034,param_2);
uVar19 = (ulong)param_2;
if (uVar19 >> 0x3d != 0) {
pcVar18 = "cannot create std::vector larger than max_size()";
std::__throw_length_error("cannot create std::vector larger than max_size()");
uVar19 = extraout_RDX * 8;
*(int8 *)*(int (*) [16])((long)pcVar18 + 0x10) = 0;
*(int (*) [16])pcVar18 = (int [16])0x0;
if (0x7ffffffffffffff8 < uVar19) {
uVar12 = std::__throw_length_error("cannot create std::vector larger than max_size()");
pvVar16 = *(void **)*(int (*) [16])pcVar18;
if (pvVar16 != (void *)0x0) {
operator_delete(pvVar16,*(long *)*(int (*) [16])((long)pcVar18 + 0x10) - (long)pvVar16
);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar12);
}
if (uVar19 != 0) {
__dest = operator_new(uVar19);
pvVar1 = (void *)((long)__dest + uVar19);
*(void **)*(int (*) [16])pcVar18 = __dest;
*(void **)*(int (*) [16])((long)pcVar18 + 0x10) = pvVar1;
pvVar21 = __dest;
if (uVar19 != 0) {
__dest = memcpy(__dest,pvVar16,uVar19);
pvVar21 = pvVar1;
}
*(void **)(*(int (*) [16])pcVar18 + 8) = pvVar21;
return __dest;
}
*(int8 *)*(int (*) [16])pcVar18 = 0;
*(int8 *)*(int (*) [16])((long)pcVar18 + 0x10) = 0;
*(int8 *)(*(int (*) [16])pcVar18 + 8) = 0;
return (void *)0x7ffffffffffffff8;
}
uVar15 = 0;
if (uVar19 == 0) goto LAB_001015e9;
uVar20 = uVar19 * 4;
puVar9 = (uint *)operator_new(uVar20);
uVar6 = _UNK_00102168;
uVar12 = _DAT_00102160;
uVar13 = (uVar20 - 4 >> 2) + 1;
puVar11 = puVar9;
if (uVar20 - 4 < 9) {
LAB_001014a5:
*puVar11 = 1;
if ((puVar9 + uVar19 != puVar11 + 1) && (puVar11[1] = 1, puVar9 + uVar19 != puVar11 + 2)) {
puVar11[2] = 1;
}
}
else {
if (((uVar13 >> 2) * 0x10 & 0x10) == 0) goto LAB_00101488;
*(int8 *)puVar9 = _DAT_00102160;
*(int8 *)(puVar9 + 2) = uVar6;
for (puVar11 = puVar9 + 4; puVar11 != puVar9 + (uVar13 >> 2) * 4; puVar11 = puVar11 + 8) {
LAB_00101488:
*(int8 *)puVar11 = uVar12;
*(int8 *)(puVar11 + 2) = uVar6;
*(int8 *)(puVar11 + 4) = uVar12;
*(int8 *)(puVar11 + 6) = uVar6;
}
if ((uVar13 & 3) != 0) {
puVar11 = puVar9 + (uVar13 & 0xfffffffffffffffc);
goto LAB_001014a5;
}
}
if (param_2 == 1) {
uVar15 = *puVar9;
if ((int)uVar15 < 0) {
uVar15 = 0;
}
}
else {
piVar2 = *(int **)CONCAT44(in_register_0000003c,param_1);
uVar13 = 1;
piVar17 = piVar2;
do {
piVar17 = piVar17 + 2;
uVar7 = 0;
do {
uVar10 = uVar7;
if ((piVar2[uVar10 * 2 + 1] < *piVar17) && ((int)puVar9[uVar13] <= (int)puVar9[uVar10])) {
puVar9[uVar13] = puVar9[uVar10] + 1;
}
uVar7 = uVar10 + 1;
} while (uVar10 + 1 != uVar13);
uVar13 = uVar10 + 2;
} while (uVar13 != (uint)param_2);
if (param_2 - 1U < 3) {
uVar8 = 0;
uVar15 = *puVar9;
if ((int)*puVar9 < 0) {
uVar15 = uVar8;
}
lVar14 = 0;
LAB_001015c8:
uVar27 = *(uint *)((long)puVar9 + lVar14 + 4);
if ((int)uVar15 < (int)uVar27) {
uVar15 = uVar27;
}
if (((int)(uVar8 + 2) < param_2) &&
(uVar8 = *(uint *)((long)puVar9 + lVar14 + 8), (int)uVar15 < (int)uVar8)) {
uVar15 = uVar8;
}
}
else {
uVar15 = 0;
uVar27 = 0;
uVar23 = 0;
uVar28 = 0;
puVar11 = puVar9;
do {
uVar8 = *puVar11;
puVar3 = puVar11 + 1;
puVar4 = puVar11 + 2;
puVar5 = puVar11 + 3;
puVar11 = puVar11 + 4;
uVar22 = -(uint)((int)uVar15 < (int)uVar8);
uVar24 = -(uint)((int)uVar27 < (int)*puVar3);
uVar25 = -(uint)((int)uVar23 < (int)*puVar4);
uVar26 = -(uint)((int)uVar28 < (int)*puVar5);
uVar15 = ~uVar22 & uVar15 | uVar8 & uVar22;
uVar27 = ~uVar24 & uVar27 | *puVar3 & uVar24;
uVar23 = ~uVar25 & uVar23 | *puVar4 & uVar25;
uVar28 = ~uVar26 & uVar28 | *puVar5 & uVar26;
} while (puVar11 != puVar9 + (uVar19 >> 2 & 0x3fffffff) * 4);
uVar8 = param_2 & 0xfffffffc;
uVar15 = ~-(uint)((int)uVar15 < (int)uVar23) & uVar15 |
uVar23 & -(uint)((int)uVar15 < (int)uVar23);
uVar27 = ~-(uint)((int)uVar27 < (int)uVar28) & uVar27 |
uVar28 & -(uint)((int)uVar27 < (int)uVar28);
uVar23 = -(uint)((int)uVar15 < (int)uVar27);
uVar15 = ~uVar23 & uVar15 | uVar27 & uVar23;
if ((uVar19 & 3) != 0) {
lVar14 = (long)(int)uVar8 * 4;
if ((int)uVar15 < (int)puVar9[(int)uVar8]) {
uVar15 = puVar9[(int)uVar8];
}
if ((int)(uVar8 + 1) < param_2) goto LAB_001015c8;
}
}
}
operator_delete(puVar9,uVar20);
LAB_001015e9:
return (void *)(ulong)uVar15;
} |
2,404 | func0 |
#include <iostream>
#include <string>
#include <cassert>
| char func0(std::string str1) {
for (int index = 0; index < str1.length(); ++index) {
char c = str1[index];
int count = 0;
for (int j = 0; j <= index; ++j) {
if (str1[j] == c)
++count;
}
if (count > 1) {
return c;
}
}
return 'N'; // Using 'N' to represent "None" instead of string
}
| int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == 'N');
assert(func0("123123") == '1');
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 22c0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv@plt>
cmp %rax,%rbx
setb %al
test %al,%al
je 24cf <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xa6>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2330 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
movzbl (%rax),%eax
mov %al,-0x1d(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x1c(%rbp),%eax
jg 24ba <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x91>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2330 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
movzbl (%rax),%eax
cmp %al,-0x1d(%rbp)
sete %al
test %al,%al
je 24b4 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x8b>
addl $0x1,-0x18(%rbp)
addl $0x1,-0x14(%rbp)
jmp 2486 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5d>
cmpl $0x1,-0x18(%rbp)
jle 24c6 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x9d>
movzbl -0x1d(%rbp),%eax
jmp 24d4 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xab>
addl $0x1,-0x1c(%rbp)
jmpq 2441 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x18>
mov $0x4e,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_1C], 0
jmp short loc_13D0
loc_1363:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movzx eax, byte ptr [rax]
mov [rbp+var_1D], al
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_13B8
loc_138E:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movzx eax, byte ptr [rax]
cmp [rbp+var_1D], al
setz al
test al, al
jz short loc_13B4
add [rbp+var_18], 1
loc_13B4:
add [rbp+var_14], 1
loc_13B8:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_1C]
jle short loc_138E
cmp [rbp+var_18], 1
jle short loc_13CC
movzx eax, [rbp+var_1D]
jmp short loc_13F5
loc_13CC:
add [rbp+var_1C], 1
loc_13D0:
mov eax, [rbp+var_1C]
movsxd rbx, eax
mov rax, [rbp+var_28]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
cmp rbx, rax
setb al
test al, al
jnz loc_1363
mov eax, 4Eh ; 'N'
loc_13F5:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1)
{
unsigned __int8 v2; // [rsp+13h] [rbp-1Dh]
int i; // [rsp+14h] [rbp-1Ch]
int v4; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
for ( i = 0; i < (unsigned long long)std::string::length(a1); ++i )
{
v2 = *(_BYTE *)std::string::operator[](a1, i);
v4 = 0;
for ( j = 0; j <= i; ++j )
{
if ( v2 == *(_BYTE *)std::string::operator[](a1, j) )
++v4;
}
if ( v4 > 1 )
return v2;
}
return 78LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001013d0
LAB_00101363:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101250
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x1d],AL
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001013b8
LAB_0010138e:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101250
MOVZX EAX,byte ptr [RAX]
CMP byte ptr [RBP + -0x1d],AL
SETZ AL
TEST AL,AL
JZ 0x001013b4
ADD dword ptr [RBP + -0x18],0x1
LAB_001013b4:
ADD dword ptr [RBP + -0x14],0x1
LAB_001013b8:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x1c]
JLE 0x0010138e
CMP dword ptr [RBP + -0x18],0x1
JLE 0x001013cc
MOVZX EAX,byte ptr [RBP + -0x1d]
JMP 0x001013f5
LAB_001013cc:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001013d0:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101210
CMP RBX,RAX
SETC AL
TEST AL,AL
JNZ 0x00101363
MOV EAX,0x4e
LAB_001013f5:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::string) */
char func0(ulong param_1)
{
char cVar1;
char *pcVar2;
ulong uVar3;
int local_24;
int local_20;
int local_1c;
local_24 = 0;
while( true ) {
uVar3 = std::string::length();
if (uVar3 <= (ulong)(long)local_24) {
return 'N';
}
pcVar2 = (char *)std::string::operator[](param_1);
cVar1 = *pcVar2;
local_20 = 0;
for (local_1c = 0; local_1c <= local_24; local_1c = local_1c + 1) {
pcVar2 = (char *)std::string::operator[](param_1);
if (cVar1 == *pcVar2) {
local_20 = local_20 + 1;
}
}
if (1 < local_20) break;
local_24 = local_24 + 1;
}
return cVar1;
} |
2,405 | func0 |
#include <iostream>
#include <string>
#include <cassert>
| char func0(std::string str1) {
for (int index = 0; index < str1.length(); ++index) {
char c = str1[index];
int count = 0;
for (int j = 0; j <= index; ++j) {
if (str1[j] == c)
++count;
}
if (count > 1) {
return c;
}
}
return 'N'; // Using 'N' to represent "None" instead of string
}
| int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == 'N');
assert(func0("123123") == '1');
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
test %rax,%rax
je 1289 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x60>
mov (%rdi),%r8
lea 0x1(%r8),%rsi
lea 0x1(%r8,%rax,1),%r10
mov $0x0,%r9d
movzbl -0x1(%rsi),%edi
test %r9d,%r9d
js 1275 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4c>
mov %r8,%rax
mov $0x0,%edx
cmp %dil,(%rax)
sete %cl
movzbl %cl,%ecx
add %ecx,%edx
add $0x1,%rax
cmp %rax,%rsi
jne 1259 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x30>
cmp $0x1,%edx
jle 1275 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4c>
mov %edi,%eax
retq
add $0x1,%r9d
add $0x1,%rsi
cmp %r10,%rsi
jne 1248 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f>
mov $0x4e,%edi
jmp 1272 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x49>
mov $0x4e,%edi
jmp 1272 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x49>
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
test rax, rax
jz short loc_126B
mov r9, [rdi]
lea rsi, [r9+1]
lea r10, [rax+r9+1]
mov r8d, 0
jmp short loc_1237
loc_122A:
add r8d, 1
add rsi, 1
cmp rsi, r10
jz short loc_1264
loc_1237:
movzx edi, byte ptr [rsi-1]
test r8d, r8d
js short loc_122A
mov rax, r9
mov edx, 0
loc_1248:
cmp [rax], dil
setz cl
movzx ecx, cl
add edx, ecx
add rax, 1
cmp rax, rsi
jnz short loc_1248
cmp edx, 1
jle short loc_122A
loc_1261:
mov eax, edi
retn
loc_1264:
mov edi, 4Eh ; 'N'
jmp short loc_1261
loc_126B:
mov edi, 4Eh ; 'N'
jmp short loc_1261 | long long func0(_QWORD *a1)
{
long long v1; // rax
_BYTE *v2; // r9
long long v3; // rsi
long long v4; // r10
int i; // r8d
unsigned int v6; // edi
_BYTE *v7; // rax
int v8; // edx
v1 = a1[1];
if ( v1 )
{
v2 = (_BYTE *)*a1;
v3 = *a1 + 1LL;
v4 = v1 + *a1 + 1;
for ( i = 0; ; ++i )
{
v6 = *(unsigned __int8 *)(v3 - 1);
if ( i >= 0 )
{
v7 = v2;
v8 = 0;
do
v8 += *v7++ == (unsigned __int8)v6;
while ( v7 != (_BYTE *)v3 );
if ( v8 > 1 )
break;
}
if ( ++v3 == v4 )
return 78;
}
}
else
{
return 78;
}
return v6;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x0010126b
MOV R9,qword ptr [RDI]
LEA RSI,[R9 + 0x1]
LEA R10,[RAX + R9*0x1 + 0x1]
MOV R8D,0x0
JMP 0x00101237
LAB_0010122a:
ADD R8D,0x1
ADD RSI,0x1
CMP RSI,R10
JZ 0x00101264
LAB_00101237:
MOVZX EDI,byte ptr [RSI + -0x1]
TEST R8D,R8D
JS 0x0010122a
MOV RAX,R9
MOV EDX,0x0
LAB_00101248:
CMP byte ptr [RAX],DIL
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101248
CMP EDX,0x1
JLE 0x0010122a
LAB_00101261:
MOV EAX,EDI
RET
LAB_00101264:
MOV EDI,0x4e
JMP 0x00101261
LAB_0010126b:
MOV EDI,0x4e
JMP 0x00101261 | /* func0(std::string) */
char func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
int iVar5;
if (param_1[1] != 0) {
pcVar1 = (char *)*param_1;
pcVar4 = pcVar1 + 1;
iVar5 = 0;
do {
if (-1 < iVar5) {
iVar3 = 0;
pcVar2 = pcVar1;
do {
iVar3 = iVar3 + (uint)(*pcVar2 == pcVar4[-1]);
pcVar2 = pcVar2 + 1;
} while (pcVar2 != pcVar4);
if (1 < iVar3) {
return pcVar4[-1];
}
}
iVar5 = iVar5 + 1;
pcVar4 = pcVar4 + 1;
} while (pcVar4 != pcVar1 + param_1[1] + 1);
}
return 'N';
} |
2,406 | func0 |
#include <iostream>
#include <string>
#include <cassert>
| char func0(std::string str1) {
for (int index = 0; index < str1.length(); ++index) {
char c = str1[index];
int count = 0;
for (int j = 0; j <= index; ++j) {
if (str1[j] == c)
++count;
}
if (count > 1) {
return c;
}
}
return 'N'; // Using 'N' to represent "None" instead of string
}
| int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == 'N');
assert(func0("123123") == '1');
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rax
test %rax,%rax
je 14f1 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x51>
mov (%rdi),%rdi
lea 0x1(%rdi),%rsi
lea 0x1(%rax,%rdi,1),%r9
nopl 0x0(%rax)
movzbl -0x1(%rsi),%r8d
mov %rdi,%rax
xor %edx,%edx
nopw 0x0(%rax,%rax,1)
xor %ecx,%ecx
cmp %r8b,(%rax)
sete %cl
add $0x1,%rax
add %ecx,%edx
cmp %rsi,%rax
jne 14d0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x30>
cmp $0x1,%edx
jg 14f7 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x57>
lea 0x1(%rax),%rsi
cmp %r9,%rsi
jne 14c0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x20>
mov $0x4e,%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rax, [rdi+8]
test rax, rax
jz short loc_1381
mov r8, [rdi]
lea rsi, [r8+1]
lea r9, [rax+r8+1]
nop dword ptr [rax+00000000h]
loc_1350:
movzx edi, byte ptr [rsi-1]
mov rax, r8
xor edx, edx
nop dword ptr [rax+00000000h]
loc_1360:
xor ecx, ecx
cmp dil, [rax]
setz cl
add rax, 1
add edx, ecx
cmp rsi, rax
jnz short loc_1360
cmp edx, 1
jg short loc_1386
add rsi, 1
cmp rsi, r9
jnz short loc_1350
loc_1381:
mov edi, 4Eh ; 'N'
loc_1386:
mov eax, edi
retn | long long func0(_QWORD *a1)
{
long long v1; // rax
_BYTE *v2; // r8
long long v3; // rsi
long long v4; // r9
unsigned int v5; // edi
_BYTE *v6; // rax
int v7; // edx
int v8; // ecx
v1 = a1[1];
if ( v1 )
{
v2 = (_BYTE *)*a1;
v3 = *a1 + 1LL;
v4 = v1 + *a1 + 1;
while ( 1 )
{
v5 = *(unsigned __int8 *)(v3 - 1);
v6 = v2;
v7 = 0;
do
{
v8 = (_BYTE)v5 == *v6++;
v7 += v8;
}
while ( (_BYTE *)v3 != v6 );
if ( v7 > 1 )
break;
if ( ++v3 == v4 )
return 78;
}
}
else
{
return 78;
}
return v5;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x00101381
MOV R8,qword ptr [RDI]
LEA RSI,[R8 + 0x1]
LEA R9,[RAX + R8*0x1 + 0x1]
NOP dword ptr [RAX]
LAB_00101350:
MOVZX EDI,byte ptr [RSI + -0x1]
MOV RAX,R8
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_00101360:
XOR ECX,ECX
CMP DIL,byte ptr [RAX]
SETZ CL
ADD RAX,0x1
ADD EDX,ECX
CMP RSI,RAX
JNZ 0x00101360
CMP EDX,0x1
JG 0x00101386
ADD RSI,0x1
CMP RSI,R9
JNZ 0x00101350
LAB_00101381:
MOV EDI,0x4e
LAB_00101386:
MOV EAX,EDI
RET | /* func0(std::string) */
char func0(int8 *param_1)
{
char cVar1;
char *pcVar2;
char *pcVar3;
int iVar4;
char *pcVar5;
if (param_1[1] != 0) {
pcVar2 = (char *)*param_1;
pcVar5 = pcVar2 + 1;
do {
iVar4 = 0;
pcVar3 = pcVar2;
do {
cVar1 = *pcVar3;
pcVar3 = pcVar3 + 1;
iVar4 = iVar4 + (uint)(pcVar5[-1] == cVar1);
} while (pcVar5 != pcVar3);
if (1 < iVar4) {
return pcVar5[-1];
}
pcVar5 = pcVar5 + 1;
} while (pcVar5 != pcVar2 + param_1[1] + 1);
}
return 'N';
} |
2,407 | func0 |
#include <iostream>
#include <string>
#include <cassert>
| char func0(std::string str1) {
for (int index = 0; index < str1.length(); ++index) {
char c = str1[index];
int count = 0;
for (int j = 0; j <= index; ++j) {
if (str1[j] == c)
++count;
}
if (count > 1) {
return c;
}
}
return 'N'; // Using 'N' to represent "None" instead of string
}
| int main() {
assert(func0("abcabc") == 'a');
assert(func0("abc") == 'N');
assert(func0("123123") == '1');
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%r10
test %r10,%r10
je 1ef6 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2c6>
mov (%rdi),%rcx
mov $0x1,%r9d
xor %esi,%esi
pxor %xmm4,%xmm4
movdqa 0x1488(%rip),%xmm5
pxor %xmm3,%xmm3
nopl 0x0(%rax)
movzbl (%rcx,%rsi,1),%r8d
mov %r9d,%edi
cmp $0xe,%rsi
jbe 1f00 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2d0>
movd %r8d,%xmm7
mov %r9d,%edx
pxor %xmm1,%xmm1
mov %rcx,%rax
punpcklbw %xmm7,%xmm7
shr $0x4,%edx
punpcklwd %xmm7,%xmm7
shl $0x4,%rdx
pshufd $0x0,%xmm7,%xmm7
add %rcx,%rdx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
movdqa %xmm4,%xmm6
add $0x10,%rax
pcmpeqb %xmm7,%xmm0
pand %xmm5,%xmm0
pcmpgtb %xmm0,%xmm6
movdqa %xmm0,%xmm2
punpcklbw %xmm6,%xmm2
punpckhbw %xmm6,%xmm0
movdqa %xmm3,%xmm6
pcmpgtw %xmm2,%xmm6
movdqa %xmm2,%xmm8
punpcklwd %xmm6,%xmm8
punpckhwd %xmm6,%xmm2
movdqa %xmm0,%xmm6
paddd %xmm8,%xmm1
paddd %xmm2,%xmm1
movdqa %xmm3,%xmm2
pcmpgtw %xmm0,%xmm2
punpcklwd %xmm2,%xmm6
punpckhwd %xmm2,%xmm0
paddd %xmm6,%xmm1
paddd %xmm0,%xmm1
cmp %rax,%rdx
jne 1ca0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x70>
movdqa %xmm1,%xmm0
mov %edi,%edx
psrldq $0x8,%xmm0
and $0xfffffff0,%edx
and $0xf,%edi
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
je 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %edx,%rdi
lea 0x1(%rdx),%r11d
cmp (%rcx,%rdi,1),%r8b
sete %dil
movzbl %dil,%edi
add %edi,%eax
cmp %esi,%r11d
jg 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0x2(%rdx),%r11d
cmp %esi,%r11d
jg 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0x3(%rdx),%r11d
cmp %esi,%r11d
jg 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0x4(%rdx),%r11d
cmp %esi,%r11d
jg 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0x5(%rdx),%r11d
cmp %esi,%r11d
jg 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0x6(%rdx),%r11d
cmp %r11d,%esi
jl 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0x7(%rdx),%r11d
cmp %r11d,%esi
jl 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0x8(%rdx),%r11d
cmp %r11d,%esi
jl 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0x9(%rdx),%r11d
cmp %r11d,%esi
jl 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0xa(%rdx),%r11d
cmp %r11d,%esi
jl 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0xb(%rdx),%r11d
cmp %r11d,%esi
jl 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0xc(%rdx),%r11d
cmp %r11d,%esi
jl 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
movzbl %r11b,%r11d
add %r11d,%eax
lea 0xd(%rdx),%r11d
cmp %r11d,%esi
jl 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %r11d,%r11
cmp (%rcx,%r11,1),%r8b
sete %r11b
add $0xe,%edx
movzbl %r11b,%r11d
add %r11d,%eax
cmp %edx,%esi
jl 1ee0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
movslq %edx,%rdx
cmp (%rcx,%rdx,1),%r8b
sete %dl
movzbl %dl,%edx
add %edx,%eax
nopw 0x0(%rax,%rax,1)
cmp $0x1,%eax
jg 1efc <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2cc>
add $0x1,%rsi
add $0x1,%r9
cmp %rsi,%r10
jne 1c60 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x30>
mov $0x4e,%r8d
mov %r8d,%eax
retq
xor %edx,%edx
xor %eax,%eax
jmpq 1d30 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x100>
nopl 0x0(%rax)
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov r8, [rdi+8]
test r8, r8
jz loc_1D5F
push rbx
mov rdx, [rdi]
xor esi, esi
mov edi, 1
pxor xmm6, xmm6
pxor xmm5, xmm5
pxor xmm4, xmm4
mov r10d, edi
movzx ecx, byte ptr [rdx+rdi-1]
pxor xmm3, xmm3
cmp esi, 0Eh
jle loc_1D45
nop dword ptr [rax]
loc_1B10:
movd xmm8, ecx
mov r9d, edi
pxor xmm1, xmm1
mov rax, rdx
punpcklbw xmm8, xmm8
shr r9d, 4
punpcklwd xmm8, xmm8
shl r9, 4
pshufd xmm8, xmm8, 0
add r9, rdx
nop word ptr [rax+rax+00h]
loc_1B40:
movdqu xmm0, xmmword ptr [rax]
movdqa xmm7, xmm4
add rax, 10h
pcmpeqb xmm0, xmm8
pcmpgtb xmm7, xmm0
movdqa xmm2, xmm0
punpcklbw xmm2, xmm7
punpckhbw xmm0, xmm7
movdqa xmm7, xmm3
pcmpgtw xmm7, xmm2
movdqa xmm9, xmm2
punpcklwd xmm9, xmm7
punpckhwd xmm2, xmm7
movdqa xmm7, xmm0
psubd xmm1, xmm9
psubd xmm1, xmm2
movdqa xmm2, xmm3
pcmpgtw xmm2, xmm0
punpcklwd xmm7, xmm2
punpckhwd xmm0, xmm2
psubd xmm1, xmm7
psubd xmm1, xmm0
cmp r9, rax
jnz short loc_1B40
movdqa xmm0, xmm1
mov r11d, r10d
psrldq xmm0, 8
and r11d, 0FFFFFFF0h
and r10d, 0Fh
paddd xmm0, xmm1
mov r9d, r11d
movdqa xmm2, xmm0
psrldq xmm2, 4
paddd xmm0, xmm2
movd eax, xmm0
movdqa xmm0, xmm1
psrldq xmm1, 8
paddd xmm0, xmm1
jz loc_1D20
loc_1BE0:
mov ebx, esi
sub ebx, r11d
lea r10d, [rbx+1]
cmp ebx, 6
jbe loc_1C8D
movzx eax, cl
movq xmm1, qword ptr [rdx+r11]
movdqa xmm7, xmm6
mov ah, al
movd xmm2, eax
pshuflw xmm2, xmm2, 0
pcmpeqb xmm1, xmm2
pcmpgtb xmm7, xmm1
movdqa xmm2, xmm1
punpcklbw xmm2, xmm7
punpcklbw xmm1, xmm7
movdqa xmm7, xmm5
pcmpgtw xmm7, xmm2
movdqa xmm8, xmm2
pshufd xmm1, xmm1, 4Eh ; 'N'
punpcklwd xmm8, xmm7
punpcklwd xmm2, xmm7
movdqa xmm7, xmm1
psubd xmm0, xmm8
pshufd xmm2, xmm2, 4Eh ; 'N'
psubd xmm0, xmm2
movdqa xmm2, xmm5
pcmpgtw xmm2, xmm1
punpcklwd xmm7, xmm2
punpcklwd xmm1, xmm2
psubd xmm0, xmm7
pshufd xmm1, xmm1, 4Eh ; 'N'
psubd xmm0, xmm1
movd r11d, xmm0
pshufd xmm1, xmm0, 0E5h
movd eax, xmm1
add eax, r11d
mov r11d, r10d
and r11d, 0FFFFFFF8h
add r9d, r11d
and r10d, 7
jz loc_1D20
loc_1C8D:
movsxd r10, r9d
cmp cl, [rdx+r10]
jnz short loc_1C99
add eax, 1
loc_1C99:
lea r10d, [r9+1]
cmp esi, r10d
jl short loc_1D20
movsxd r10, r10d
cmp cl, [rdx+r10]
jnz short loc_1CAE
add eax, 1
loc_1CAE:
lea r10d, [r9+2]
cmp esi, r10d
jl short loc_1D20
movsxd r10, r10d
cmp cl, [rdx+r10]
jnz short loc_1CC3
add eax, 1
loc_1CC3:
lea r10d, [r9+3]
cmp esi, r10d
jl short loc_1D20
movsxd r10, r10d
cmp cl, [rdx+r10]
jnz short loc_1CD8
add eax, 1
loc_1CD8:
lea r10d, [r9+4]
cmp r10d, esi
jg short loc_1D20
movsxd r10, r10d
cmp cl, [rdx+r10]
jnz short loc_1CED
add eax, 1
loc_1CED:
lea r10d, [r9+5]
cmp r10d, esi
jg short loc_1D20
movsxd r10, r10d
cmp cl, [rdx+r10]
jnz short loc_1D02
add eax, 1
loc_1D02:
add r9d, 6
cmp esi, r9d
jl short loc_1D20
movsxd r9, r9d
cmp cl, [rdx+r9]
jnz short loc_1D20
add eax, 1
nop word ptr [rax+rax+00000000h]
loc_1D20:
cmp eax, 1
jg short loc_1D5B
add esi, 1
lea rax, [rdi+1]
cmp r8, rdi
jz short loc_1D56
mov rdi, rax
movzx ecx, byte ptr [rdx+rdi-1]
mov r10d, edi
cmp esi, 0Eh
jg loc_1B10
loc_1D45:
pxor xmm0, xmm0
xor r11d, r11d
xor r9d, r9d
xor eax, eax
jmp loc_1BE0
loc_1D56:
mov ecx, 4Eh ; 'N'
loc_1D5B:
mov eax, ecx
pop rbx
retn
loc_1D5F:
mov eax, 4Eh ; 'N'
retn | long long func0(const __m128i **a1)
{
const __m128i *v1; // r8
const __m128i *v2; // rdx
int v3; // esi
long long v4; // rdi
unsigned int v5; // ecx
__m128i v6; // xmm8
__m128i v7; // xmm1
const __m128i *v8; // rax
__m128i v9; // xmm8
__m128i v10; // xmm8
__m128i v11; // xmm0
__m128i v12; // xmm0
__m128i v13; // xmm7
__m128i v14; // xmm2
__m128i v15; // xmm0
__m128i v16; // xmm7
__m128i v17; // xmm1
__m128i v18; // xmm2
long long v19; // r11
__m128i v20; // xmm0
signed int v21; // r9d
int v22; // eax
__m128i v23; // xmm0
int v24; // r10d
unsigned int v25; // eax
__m128i v26; // xmm1
__m128i v27; // xmm2
__m128i v28; // xmm1
__m128i v29; // xmm2
__m128i v30; // xmm1
__m128i v31; // xmm0
int v32; // r9d
long long v33; // rax
int v34; // r10d
v1 = a1[1];
if ( !v1 )
return 78LL;
v2 = *a1;
v3 = 0;
v4 = 1LL;
v5 = v2->m128i_u8[0];
LABEL_31:
v23 = 0LL;
v19 = 0LL;
v21 = 0;
v22 = 0;
LABEL_6:
v24 = v3 - v19 + 1;
if ( (unsigned int)(v3 - v19) <= 6 )
goto LABEL_8;
v25 = (unsigned __int8)v5;
BYTE1(v25) = v5;
v26 = _mm_cmpeq_epi8(
_mm_loadl_epi64((const __m128i *)((char *)v2 + v19)),
_mm_shufflelo_epi16(_mm_cvtsi32_si128(v25), 0));
v27 = _mm_unpacklo_epi8(v26, _mm_cmpgt_epi8((__m128i)0LL, v26));
v28 = _mm_shuffle_epi32(v27, 78);
v29 = _mm_unpacklo_epi16(v27, _mm_cmpgt_epi16((__m128i)0LL, v27));
v30 = _mm_unpacklo_epi16(v28, _mm_cmpgt_epi16((__m128i)0LL, v28));
v31 = _mm_sub_epi32(
_mm_sub_epi32(_mm_sub_epi32(_mm_sub_epi32(v23, v29), _mm_shuffle_epi32(v29, 78)), v30),
_mm_shuffle_epi32(v30, 78));
v22 = _mm_cvtsi128_si32(v31) + _mm_cvtsi128_si32(_mm_shuffle_epi32(v31, 229));
v21 += v24 & 0xFFFFFFF8;
if ( (v24 & 7) != 0 )
{
LABEL_8:
if ( (_BYTE)v5 == v2->m128i_i8[v21] )
++v22;
if ( v3 >= v21 + 1 )
{
if ( (_BYTE)v5 == v2->m128i_i8[v21 + 1] )
++v22;
if ( v3 >= v21 + 2 )
{
if ( (_BYTE)v5 == v2->m128i_i8[v21 + 2] )
++v22;
if ( v3 >= v21 + 3 )
{
if ( (_BYTE)v5 == v2->m128i_i8[v21 + 3] )
++v22;
if ( v21 + 4 <= v3 )
{
if ( (_BYTE)v5 == v2->m128i_i8[v21 + 4] )
++v22;
if ( v21 + 5 <= v3 )
{
if ( (_BYTE)v5 == v2->m128i_i8[v21 + 5] )
++v22;
v32 = v21 + 6;
if ( v3 >= v32 && (_BYTE)v5 == v2->m128i_i8[v32] )
++v22;
}
}
}
}
}
}
while ( v22 <= 1 )
{
++v3;
v33 = v4 + 1;
if ( v1 == (const __m128i *)v4 )
return 78;
++v4;
v5 = v2->m128i_u8[v33 - 1];
v34 = v33;
if ( v3 <= 14 )
goto LABEL_31;
v6 = _mm_cvtsi32_si128(v5);
v7 = 0LL;
v8 = v2;
v9 = _mm_unpacklo_epi8(v6, v6);
v10 = _mm_shuffle_epi32(_mm_unpacklo_epi16(v9, v9), 0);
do
{
v11 = _mm_loadu_si128(v8++);
v12 = _mm_cmpeq_epi8(v11, v10);
v13 = _mm_cmpgt_epi8((__m128i)0LL, v12);
v14 = _mm_unpacklo_epi8(v12, v13);
v15 = _mm_unpackhi_epi8(v12, v13);
v16 = _mm_cmpgt_epi16((__m128i)0LL, v14);
v17 = _mm_sub_epi32(_mm_sub_epi32(v7, _mm_unpacklo_epi16(v14, v16)), _mm_unpackhi_epi16(v14, v16));
v18 = _mm_cmpgt_epi16((__m128i)0LL, v15);
v7 = _mm_sub_epi32(_mm_sub_epi32(v17, _mm_unpacklo_epi16(v15, v18)), _mm_unpackhi_epi16(v15, v18));
}
while ( &v2[(unsigned int)v4 >> 4] != v8 );
v19 = v34 & 0xFFFFFFF0;
v20 = _mm_add_epi32(_mm_srli_si128(v7, 8), v7);
v21 = v34 & 0xFFFFFFF0;
v22 = _mm_cvtsi128_si32(_mm_add_epi32(v20, _mm_srli_si128(v20, 4)));
v23 = _mm_add_epi32(v7, _mm_srli_si128(v7, 8));
if ( (v34 & 0xF) != 0 )
goto LABEL_6;
}
return v5;
} | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
TEST R8,R8
JZ 0x00101d5f
PUSH RBX
MOV RDX,qword ptr [RDI]
XOR ESI,ESI
MOV EDI,0x1
PXOR XMM6,XMM6
PXOR XMM5,XMM5
PXOR XMM4,XMM4
MOV R10D,EDI
MOVZX ECX,byte ptr [RDX + RDI*0x1 + -0x1]
PXOR XMM3,XMM3
CMP ESI,0xe
JLE 0x00101d45
NOP dword ptr [RAX]
LAB_00101b10:
MOVD XMM8,ECX
MOV R9D,EDI
PXOR XMM1,XMM1
MOV RAX,RDX
PUNPCKLBW XMM8,XMM8
SHR R9D,0x4
PUNPCKLWD XMM8,XMM8
SHL R9,0x4
PSHUFD XMM8,XMM8,0x0
ADD R9,RDX
NOP word ptr [RAX + RAX*0x1]
LAB_00101b40:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM7,XMM4
ADD RAX,0x10
PCMPEQB XMM0,XMM8
PCMPGTB XMM7,XMM0
MOVDQA XMM2,XMM0
PUNPCKLBW XMM2,XMM7
PUNPCKHBW XMM0,XMM7
MOVDQA XMM7,XMM3
PCMPGTW XMM7,XMM2
MOVDQA XMM9,XMM2
PUNPCKLWD XMM9,XMM7
PUNPCKHWD XMM2,XMM7
MOVDQA XMM7,XMM0
PSUBD XMM1,XMM9
PSUBD XMM1,XMM2
MOVDQA XMM2,XMM3
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM7,XMM2
PUNPCKHWD XMM0,XMM2
PSUBD XMM1,XMM7
PSUBD XMM1,XMM0
CMP R9,RAX
JNZ 0x00101b40
MOVDQA XMM0,XMM1
MOV R11D,R10D
PSRLDQ XMM0,0x8
AND R11D,0xfffffff0
AND R10D,0xf
PADDD XMM0,XMM1
MOV R9D,R11D
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
PADDD XMM0,XMM2
MOVD EAX,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
JZ 0x00101d20
LAB_00101be0:
MOV EBX,ESI
SUB EBX,R11D
LEA R10D,[RBX + 0x1]
CMP EBX,0x6
JBE 0x00101c8d
MOVZX EAX,CL
MOVQ XMM1,qword ptr [RDX + R11*0x1]
MOVDQA XMM7,XMM6
MOV AH,AL
MOVD XMM2,EAX
PSHUFLW XMM2,XMM2,0x0
PCMPEQB XMM1,XMM2
PCMPGTB XMM7,XMM1
MOVDQA XMM2,XMM1
PUNPCKLBW XMM2,XMM7
PUNPCKLBW XMM1,XMM7
MOVDQA XMM7,XMM5
PCMPGTW XMM7,XMM2
MOVDQA XMM8,XMM2
PSHUFD XMM1,XMM1,0x4e
PUNPCKLWD XMM8,XMM7
PUNPCKLWD XMM2,XMM7
MOVDQA XMM7,XMM1
PSUBD XMM0,XMM8
PSHUFD XMM2,XMM2,0x4e
PSUBD XMM0,XMM2
MOVDQA XMM2,XMM5
PCMPGTW XMM2,XMM1
PUNPCKLWD XMM7,XMM2
PUNPCKLWD XMM1,XMM2
PSUBD XMM0,XMM7
PSHUFD XMM1,XMM1,0x4e
PSUBD XMM0,XMM1
MOVD R11D,XMM0
PSHUFD XMM1,XMM0,0xe5
MOVD EAX,XMM1
ADD EAX,R11D
MOV R11D,R10D
AND R11D,0xfffffff8
ADD R9D,R11D
AND R10D,0x7
JZ 0x00101d20
LAB_00101c8d:
MOVSXD R10,R9D
CMP CL,byte ptr [RDX + R10*0x1]
JNZ 0x00101c99
ADD EAX,0x1
LAB_00101c99:
LEA R10D,[R9 + 0x1]
CMP ESI,R10D
JL 0x00101d20
MOVSXD R10,R10D
CMP CL,byte ptr [RDX + R10*0x1]
JNZ 0x00101cae
ADD EAX,0x1
LAB_00101cae:
LEA R10D,[R9 + 0x2]
CMP ESI,R10D
JL 0x00101d20
MOVSXD R10,R10D
CMP CL,byte ptr [RDX + R10*0x1]
JNZ 0x00101cc3
ADD EAX,0x1
LAB_00101cc3:
LEA R10D,[R9 + 0x3]
CMP ESI,R10D
JL 0x00101d20
MOVSXD R10,R10D
CMP CL,byte ptr [RDX + R10*0x1]
JNZ 0x00101cd8
ADD EAX,0x1
LAB_00101cd8:
LEA R10D,[R9 + 0x4]
CMP R10D,ESI
JG 0x00101d20
MOVSXD R10,R10D
CMP CL,byte ptr [RDX + R10*0x1]
JNZ 0x00101ced
ADD EAX,0x1
LAB_00101ced:
LEA R10D,[R9 + 0x5]
CMP R10D,ESI
JG 0x00101d20
MOVSXD R10,R10D
CMP CL,byte ptr [RDX + R10*0x1]
JNZ 0x00101d02
ADD EAX,0x1
LAB_00101d02:
ADD R9D,0x6
CMP ESI,R9D
JL 0x00101d20
MOVSXD R9,R9D
CMP CL,byte ptr [RDX + R9*0x1]
JNZ 0x00101d20
ADD EAX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_00101d20:
CMP EAX,0x1
JG 0x00101d5b
ADD ESI,0x1
LEA RAX,[RDI + 0x1]
CMP R8,RDI
JZ 0x00101d56
MOV RDI,RAX
MOVZX ECX,byte ptr [RDX + RDI*0x1 + -0x1]
MOV R10D,EDI
CMP ESI,0xe
JG 0x00101b10
LAB_00101d45:
PXOR XMM0,XMM0
XOR R11D,R11D
XOR R9D,R9D
XOR EAX,EAX
JMP 0x00101be0
LAB_00101d56:
MOV ECX,0x4e
LAB_00101d5b:
MOV EAX,ECX
POP RBX
RET
LAB_00101d5f:
MOV EAX,0x4e
RET | /* func0(std::string) */
char func0(int8 *param_1)
{
uint uVar1;
char *pcVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
char *pcVar11;
char *pcVar12;
char *pcVar13;
char *pcVar14;
char *pcVar15;
char *pcVar16;
char *pcVar17;
char *pcVar18;
char *pcVar19;
char *pcVar20;
char *pcVar21;
char *pcVar22;
char *pcVar23;
char *pcVar24;
char *pcVar25;
int auVar26 [14];
int auVar27 [12];
unkbyte10 Var28;
int auVar29 [12];
int auVar30 [14];
int auVar31 [12];
int auVar32 [16];
int auVar33 [16];
int auVar34 [12];
unkbyte9 Var35;
int6 uVar36;
int4 uVar37;
int2 uVar38;
char *pcVar39;
char cVar40;
int iVar41;
ulong uVar42;
ulong uVar43;
ulong uVar44;
int4 uVar45;
int iVar46;
char cVar54;
short sVar55;
int auVar50 [12];
int iVar56;
int auVar57 [12];
char cVar62;
short sVar63;
char cVar66;
int iVar64;
char cVar65;
char cVar67;
int iVar68;
int iVar70;
int auVar58 [16];
int auVar59 [16];
int iVar71;
short sVar80;
short sVar81;
int auVar73 [16];
int auVar75 [16];
int auVar76 [16];
int auVar77 [16];
char cVar91;
char cVar92;
char cVar93;
char cVar94;
char cVar95;
char cVar96;
int auVar82 [16];
int auVar87 [16];
int auVar97 [16];
int auVar100 [16];
int6 uVar47;
int8 uVar48;
int auVar49 [12];
int auVar51 [14];
int auVar53 [16];
int auVar52 [16];
int auVar60 [16];
int auVar61 [16];
long lVar69;
int auVar72 [12];
int auVar78 [16];
int auVar74 [16];
int auVar79 [16];
int auVar83 [16];
int auVar84 [16];
int auVar88 [16];
int auVar85 [16];
int auVar89 [16];
int auVar86 [16];
int auVar90 [16];
int auVar98 [16];
int auVar99 [16];
int auVar101 [16];
int auVar102 [16];
if (param_1[1] == 0) {
return 'N';
}
pcVar2 = (char *)*param_1;
iVar41 = 0;
uVar42 = 1;
cVar40 = *pcVar2;
LAB_00101d45:
iVar56 = 0;
iVar64 = 0;
uVar44 = 0;
iVar46 = 0;
do {
iVar68 = (int)uVar44;
uVar1 = (iVar41 - iVar68) + 1;
uVar43 = uVar42;
if ((uint)(iVar41 - iVar68) < 7) {
LAB_00101c8d:
if (cVar40 == pcVar2[iVar68]) {
iVar46 = iVar46 + 1;
}
if (iVar68 + 1 <= iVar41) {
if (cVar40 == pcVar2[iVar68 + 1]) {
iVar46 = iVar46 + 1;
}
if (iVar68 + 2 <= iVar41) {
if (cVar40 == pcVar2[iVar68 + 2]) {
iVar46 = iVar46 + 1;
}
if (iVar68 + 3 <= iVar41) {
if (cVar40 == pcVar2[iVar68 + 3]) {
iVar46 = iVar46 + 1;
}
if (iVar68 + 4 <= iVar41) {
if (cVar40 == pcVar2[iVar68 + 4]) {
iVar46 = iVar46 + 1;
}
if (iVar68 + 5 <= iVar41) {
if (cVar40 == pcVar2[iVar68 + 5]) {
iVar46 = iVar46 + 1;
}
if ((iVar68 + 6 <= iVar41) && (cVar40 == pcVar2[iVar68 + 6])) {
iVar46 = iVar46 + 1;
}
}
}
}
}
}
}
else {
uVar48 = *(int8 *)(pcVar2 + uVar44);
auVar75 = pshuflw(ZEXT216(CONCAT11(cVar40,cVar40)),ZEXT216(CONCAT11(cVar40,cVar40)),0);
bVar3 = (char)uVar48 == auVar75[0];
auVar58[0] = -bVar3;
bVar7 = (char)((ulong)uVar48 >> 8) == auVar75[1];
cVar54 = -bVar7;
bVar8 = (char)((ulong)uVar48 >> 0x10) == auVar75[2];
bVar9 = (char)((ulong)uVar48 >> 0x18) == auVar75[3];
bVar10 = (char)((ulong)uVar48 >> 0x20) == auVar75[4];
cVar62 = -bVar10;
bVar4 = (char)((ulong)uVar48 >> 0x28) == auVar75[5];
cVar65 = -bVar4;
bVar5 = (char)((ulong)uVar48 >> 0x30) == auVar75[6];
cVar66 = -bVar5;
bVar6 = (char)((ulong)uVar48 >> 0x38) == auVar75[7];
cVar67 = -bVar6;
cVar91 = -bVar7;
cVar92 = -bVar9;
cVar93 = -bVar10;
cVar94 = -bVar4;
cVar95 = -bVar5;
cVar96 = -bVar6;
Var28 = CONCAT91(CONCAT81((long)(CONCAT72(CONCAT61(CONCAT51(CONCAT41(CONCAT31(CONCAT21(
CONCAT11(cVar96,cVar67),cVar95),cVar66),cVar94),
cVar65),cVar93),CONCAT11(cVar62,cVar67)) >> 8),
cVar92),-bVar9);
auVar31._2_10_ = Var28;
auVar31[1] = -bVar8;
auVar31[0] = -bVar8;
auVar30._2_12_ = auVar31;
auVar30[1] = cVar91;
auVar30[0] = cVar54;
auVar76._0_2_ = CONCAT11(-bVar3,auVar58[0]);
auVar76._2_14_ = auVar30;
uVar38 = CONCAT11(cVar96,cVar67);
uVar37 = CONCAT31(CONCAT21(uVar38,cVar95),cVar66);
uVar36 = CONCAT51(CONCAT41(uVar37,cVar94),cVar65);
Var35 = CONCAT72(CONCAT61(uVar36,cVar93),CONCAT11(cVar62,cVar67));
lVar69 = (long)((unkuint9)Var35 >> 8);
auVar33._1_8_ = lVar69;
auVar33[0] = cVar92;
auVar33._9_7_ = 0;
auVar32._10_6_ = 0;
auVar32._0_10_ = SUB1610(auVar33 << 0x38,6);
auVar75._11_5_ = 0;
auVar75._0_11_ = SUB1611(auVar32 << 0x30,5);
auVar58._4_12_ = SUB1612(auVar75 << 0x28,4);
auVar58[3] = cVar91;
auVar58[2] = cVar54;
auVar58[1] = -bVar3;
sVar55 = auVar31._0_2_;
sVar63 = (short)Var28;
iVar46 = (int)((unkuint9)Var35 >> 8);
auVar57._8_4_ = auVar58._0_4_;
auVar57._0_8_ = lVar69;
auVar99._0_12_ = auVar76._0_12_;
auVar99._12_2_ = sVar63;
auVar99._14_2_ = -(ushort)(sVar63 < 0);
auVar98._12_4_ = auVar99._12_4_;
auVar98._0_10_ = auVar76._0_10_;
auVar98._10_2_ = -(ushort)(sVar55 < 0);
auVar97._10_6_ = auVar98._10_6_;
auVar97._0_8_ = auVar76._0_8_;
auVar97._8_2_ = sVar55;
auVar34._4_8_ = auVar97._8_8_;
auVar34._2_2_ = -(ushort)(auVar30._0_2_ < 0);
auVar34._0_2_ = auVar30._0_2_;
auVar79._12_2_ = sVar63;
auVar79._0_12_ = auVar99._0_12_;
auVar79._14_2_ = -(ushort)(sVar63 < 0);
auVar78._12_4_ = auVar79._12_4_;
auVar78._10_2_ = -(ushort)(sVar55 < 0);
auVar78._0_10_ = auVar98._0_10_;
auVar77._10_6_ = auVar78._10_6_;
auVar77._8_2_ = sVar55;
auVar77._0_8_ = auVar97._0_8_;
sVar55 = (short)((unkuint9)Var35 >> 8);
sVar63 = (short)uVar37;
auVar90._12_2_ = uVar38;
auVar90._0_12_ = auVar57;
auVar90._14_2_ = -(ushort)(lVar69 < 0);
auVar89._12_4_ = auVar90._12_4_;
auVar89._0_10_ = auVar57._0_10_;
auVar89._10_2_ = -(ushort)(sVar63 < 0);
auVar88._10_6_ = auVar89._10_6_;
auVar88._8_2_ = sVar63;
auVar88._0_8_ = lVar69;
auVar87._8_8_ = auVar88._8_8_;
auVar87._6_2_ = -(ushort)(iVar46 < 0);
auVar87._4_2_ = (short)uVar36;
auVar87._0_4_ = iVar46;
auVar61._12_2_ = uVar38;
auVar61._0_12_ = auVar57;
auVar61._14_2_ = -(ushort)(lVar69 < 0);
auVar60._12_4_ = auVar61._12_4_;
auVar60._10_2_ = -(ushort)(sVar63 < 0);
auVar60._0_10_ = auVar89._0_10_;
auVar59._10_6_ = auVar60._10_6_;
auVar59._8_2_ = sVar63;
auVar59._0_8_ = lVar69;
iVar46 = ((((iVar64 - auVar34._0_4_) - auVar78._12_4_) - auVar87._4_4_) - auVar60._12_4_) +
((((iVar56 - CONCAT22(-(ushort)bVar3,auVar76._0_2_)) - auVar77._8_4_) -
CONCAT22(-(ushort)(sVar55 < 0),sVar55)) - auVar59._8_4_);
iVar68 = iVar68 + (uVar1 & 0xfffffff8);
if ((uVar1 & 7) != 0) goto LAB_00101c8d;
}
do {
if (1 < iVar46) {
return cVar40;
}
iVar41 = iVar41 + 1;
uVar42 = uVar43 + 1;
if (param_1[1] == uVar43) {
return 'N';
}
cVar40 = pcVar2[uVar43];
if (iVar41 < 0xf) goto LAB_00101d45;
iVar56 = 0;
iVar64 = 0;
iVar68 = 0;
iVar70 = 0;
pcVar39 = pcVar2;
do {
cVar54 = *pcVar39;
pcVar11 = pcVar39 + 1;
pcVar12 = pcVar39 + 2;
pcVar13 = pcVar39 + 3;
pcVar14 = pcVar39 + 4;
pcVar15 = pcVar39 + 5;
pcVar16 = pcVar39 + 6;
pcVar17 = pcVar39 + 7;
pcVar18 = pcVar39 + 8;
pcVar19 = pcVar39 + 9;
pcVar20 = pcVar39 + 10;
pcVar21 = pcVar39 + 0xb;
pcVar22 = pcVar39 + 0xc;
pcVar23 = pcVar39 + 0xd;
pcVar24 = pcVar39 + 0xe;
pcVar25 = pcVar39 + 0xf;
pcVar39 = pcVar39 + 0x10;
bVar3 = cVar54 == cVar40;
cVar54 = -(*pcVar17 == cVar40);
bVar7 = *pcVar18 == cVar40;
bVar8 = *pcVar19 == cVar40;
bVar9 = *pcVar20 == cVar40;
bVar10 = *pcVar21 == cVar40;
uVar38 = CONCAT11(-(*pcVar17 == cVar40),cVar54);
uVar37 = CONCAT31(CONCAT21(uVar38,-(*pcVar16 == cVar40)),-(*pcVar16 == cVar40));
uVar36 = CONCAT51(CONCAT41(uVar37,-(*pcVar15 == cVar40)),-(*pcVar15 == cVar40));
Var35 = CONCAT72(CONCAT61(uVar36,-(*pcVar14 == cVar40)),
CONCAT11(-(*pcVar14 == cVar40),cVar54));
lVar69 = (long)((unkuint9)Var35 >> 8);
Var28 = CONCAT91(CONCAT81(lVar69,-(*pcVar13 == cVar40)),-(*pcVar13 == cVar40));
auVar27._2_10_ = Var28;
auVar27[1] = -(*pcVar12 == cVar40);
auVar27[0] = -(*pcVar12 == cVar40);
auVar26._2_12_ = auVar27;
auVar26[1] = -(*pcVar11 == cVar40);
auVar26[0] = -(*pcVar11 == cVar40);
auVar73._0_2_ = CONCAT11(-bVar3,-bVar3);
auVar73._2_14_ = auVar26;
uVar45 = CONCAT13(-bVar8,CONCAT12(-bVar8,CONCAT11(-bVar7,-bVar7)));
uVar47 = CONCAT15(-bVar9,CONCAT14(-bVar9,uVar45));
uVar48 = CONCAT17(-bVar10,CONCAT16(-bVar10,uVar47));
auVar49._0_10_ = CONCAT19(-(*pcVar22 == cVar40),CONCAT18(-(*pcVar22 == cVar40),uVar48));
auVar49[10] = -(*pcVar23 == cVar40);
auVar49[0xb] = -(*pcVar23 == cVar40);
auVar51[0xc] = -(*pcVar24 == cVar40);
auVar51._0_12_ = auVar49;
auVar51[0xd] = -(*pcVar24 == cVar40);
auVar52[0xe] = -(*pcVar25 == cVar40);
auVar52._0_14_ = auVar51;
auVar52[0xf] = -(*pcVar25 == cVar40);
sVar55 = (short)Var28;
sVar63 = (short)((unkuint9)Var35 >> 8);
sVar80 = (short)uVar36;
sVar81 = (short)uVar37;
auVar102._0_12_ = auVar73._0_12_;
auVar102._12_2_ = sVar55;
auVar102._14_2_ = -(ushort)(sVar55 < 0);
auVar101._12_4_ = auVar102._12_4_;
auVar101._0_10_ = auVar73._0_10_;
auVar101._10_2_ = -(ushort)(auVar27._0_2_ < 0);
auVar100._10_6_ = auVar101._10_6_;
auVar100._0_8_ = auVar73._0_8_;
auVar100._8_2_ = auVar27._0_2_;
auVar29._4_8_ = auVar100._8_8_;
auVar29._2_2_ = -(ushort)(auVar26._0_2_ < 0);
auVar29._0_2_ = auVar26._0_2_;
iVar71 = CONCAT22(-(ushort)(sVar63 < 0),sVar63);
auVar72._0_8_ = CONCAT26(-(ushort)(sVar80 < 0),CONCAT24(sVar80,iVar71));
auVar72._8_2_ = sVar81;
auVar72._10_2_ = -(ushort)(sVar81 < 0);
auVar74._12_2_ = uVar38;
auVar74._0_12_ = auVar72;
auVar74._14_2_ = -(ushort)(lVar69 < 0);
sVar55 = (short)((unkuint10)auVar49._0_10_ >> 0x40);
auVar86._12_2_ = (short)((ulong)uVar48 >> 0x30);
auVar86._0_12_ = auVar49;
auVar86._14_2_ = -(ushort)bVar10;
auVar85._12_4_ = auVar86._12_4_;
auVar85._10_2_ = -(ushort)bVar9;
auVar85._0_10_ = auVar49._0_10_;
auVar84._10_6_ = auVar85._10_6_;
auVar84._8_2_ = (short)((uint6)uVar47 >> 0x20);
auVar84._0_8_ = uVar48;
auVar83._8_8_ = auVar84._8_8_;
auVar83._6_2_ = -(ushort)bVar8;
auVar83._0_6_ = uVar47;
auVar82._6_10_ = auVar83._6_10_;
auVar82._4_2_ = (short)((uint)uVar45 >> 0x10);
auVar82._0_4_ = uVar45;
iVar46 = CONCAT22(-(ushort)(sVar55 < 0),sVar55);
auVar50._0_8_ = CONCAT26(-(ushort)(auVar49._10_2_ < 0),CONCAT24(auVar49._10_2_,iVar46));
auVar50._8_2_ = auVar51._12_2_;
auVar50._10_2_ = -(ushort)(auVar51._12_2_ < 0);
auVar53._12_2_ = auVar52._14_2_;
auVar53._0_12_ = auVar50;
auVar53._14_2_ = -(ushort)(auVar52._14_2_ < 0);
iVar56 = (((iVar56 - CONCAT22(-(ushort)bVar3,auVar73._0_2_)) - iVar71) -
CONCAT22(-(ushort)bVar7,CONCAT11(-bVar7,-bVar7))) - iVar46;
iVar64 = (((iVar64 - auVar29._0_4_) - (int)((ulong)auVar72._0_8_ >> 0x20)) - auVar82._4_4_)
- (int)((ulong)auVar50._0_8_ >> 0x20);
iVar68 = (((iVar68 - auVar100._8_4_) - auVar72._8_4_) - auVar84._8_4_) - auVar50._8_4_;
iVar70 = (((iVar70 - auVar101._12_4_) - auVar74._12_4_) - auVar85._12_4_) - auVar53._12_4_;
} while (pcVar2 + (uVar42 >> 4 & 0xfffffff) * 0x10 != pcVar39);
uVar44 = (ulong)((uint)uVar42 & 0xfffffff0);
iVar46 = iVar68 + iVar56 + iVar70 + iVar64;
iVar56 = iVar56 + iVar68;
iVar64 = iVar64 + iVar70;
uVar43 = uVar42;
} while ((uVar42 & 0xf) == 0);
} while( true );
} |
2,408 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(int n) {
std::vector<int> ludics;
for (int i = 1; i <= n; i++) {
ludics.push_back(i);
}
int index = 1;
while (index != ludics.size()) {
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < ludics.size()) {
ludics.erase(ludics.begin() + remove_index);
remove_index = remove_index + first_ludic - 1;
}
index += 1;
}
return ludics;
}
| int main() {
std::vector<int> result;
result = func0(10);
assert((result == std::vector<int>{1, 2, 3, 5, 7}));
result = func0(25);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25}));
result = func0(45);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43}));
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 194e <_ZNSt6vectorIiSaIiEEC1Ev>
movl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
cmp %eax,-0x4c(%rbp)
jl 12e5 <_Z5func0i+0x5c>
lea -0x20(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1a54 <_ZNSt6vectorIiSaIiEE9push_backERKi>
mov -0x20(%rbp),%eax
add $0x1,%eax
mov %eax,-0x20(%rbp)
jmp 12bf <_Z5func0i+0x36>
movl $0x1,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
movslq %eax,%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 1ad4 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,%rbx
setne %al
test %al,%al
je 13d3 <_Z5func0i+0x14a>
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1afc <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
mov %eax,-0x34(%rbp)
mov -0x3c(%rbp),%edx
mov -0x34(%rbp),%eax
add %edx,%eax
mov %eax,-0x38(%rbp)
mov -0x38(%rbp),%eax
movslq %eax,%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 1ad4 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,%rbx
setb %al
test %al,%al
je 13ac <_Z5func0i+0x123>
mov -0x38(%rbp),%eax
movslq %eax,%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 1b20 <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x30(%rbp)
lea -0x30(%rbp),%rax
mov %rbx,%rsi
mov %rax,%rdi
callq 1b6c <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEplEl>
mov %rax,-0x28(%rbp)
lea -0x28(%rbp),%rdx
lea -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1bd2 <_ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEC1IPiEERKNS0_IT_NS_11__enable_ifIXsrSt10__are_sameIS9_S8_E7__valueES5_E6__typeEEE>
mov -0x20(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1c00 <_ZNSt6vectorIiSaIiEE5eraseEN9__gnu_cxx17__normal_iteratorIPKiS1_EE>
mov -0x38(%rbp),%edx
mov -0x34(%rbp),%eax
add %edx,%eax
sub $0x1,%eax
mov %eax,-0x38(%rbp)
jmp 1331 <_Z5func0i+0xa8>
addl $0x1,-0x3c(%rbp)
jmpq 12ec <_Z5func0i+0x63>
endbr64
mov %rax,%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 1a0c <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1190 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 13e8 <_Z5func0i+0x15f>
callq 1160 <__stack_chk_fail@plt>
mov -0x48(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov dword ptr [rbp+var_20], 1
jmp short loc_12BD
loc_12A1:
lea rdx, [rbp+var_20]
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
mov eax, dword ptr [rbp+var_20]
add eax, 1
mov dword ptr [rbp+var_20], eax
loc_12BD:
mov eax, dword ptr [rbp+var_20]
cmp [rbp+var_4C], eax
jge short loc_12A1
mov [rbp+var_3C], 1
jmp loc_1375
loc_12D1:
mov eax, [rbp+var_3C]
movsxd rdx, eax
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
mov [rbp+var_34], eax
mov edx, [rbp+var_3C]
mov eax, [rbp+var_34]
add eax, edx
mov [rbp+var_38], eax
jmp short loc_1355
loc_12F8:
mov eax, [rbp+var_38]
movsxd rbx, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_30], rax
lea rax, [rbp+var_30]
mov rsi, rbx
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEplEl; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator+(long)
mov [rbp+var_28], rax
lea rdx, [rbp+var_28]
lea rax, [rbp+var_20]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEC2IPivEERKNS0_IT_S5_EE; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::__normal_iterator<int *,void>(__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&)
mov rdx, [rbp+var_20]
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5eraseEN9__gnu_cxx17__normal_iteratorIPKiS1_EE; std::vector<int>::erase(__gnu_cxx::__normal_iterator<int const*,std::vector<int>>)
mov edx, [rbp+var_38]
mov eax, [rbp+var_34]
add eax, edx
sub eax, 1
mov [rbp+var_38], eax
loc_1355:
mov eax, [rbp+var_38]
movsxd rbx, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
cmp rbx, rax
setb al
test al, al
jnz short loc_12F8
add [rbp+var_3C], 1
loc_1375:
mov eax, [rbp+var_3C]
movsxd rbx, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
cmp rbx, rax
setnz al
test al, al
jnz loc_12D1
jmp short loc_13C9
endbr64
mov rbx, rax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_13C1
call ___stack_chk_fail
loc_13C1:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_13C9:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_13DD
call ___stack_chk_fail
loc_13DD:
mov rax, [rbp+var_48]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-3Ch]
int j; // [rsp+18h] [rbp-38h]
int v5; // [rsp+1Ch] [rbp-34h]
long long v6; // [rsp+20h] [rbp-30h] BYREF
long long v7; // [rsp+28h] [rbp-28h] BYREF
_QWORD v8[3]; // [rsp+30h] [rbp-20h] BYREF
v8[1] = __readfsqword(0x28u);
std::vector<int>::vector(a1);
LODWORD(v8[0]) = 1;
while ( a2 >= SLODWORD(v8[0]) )
{
std::vector<int>::push_back(a1, v8);
++LODWORD(v8[0]);
}
for ( i = 1; i != std::vector<int>::size(a1); ++i )
{
v5 = *(_DWORD *)std::vector<int>::operator[](a1, i);
for ( j = i + v5; j < (unsigned long long)std::vector<int>::size(a1); j = j + v5 - 1 )
{
v6 = std::vector<int>::begin(a1);
v7 = __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator+(&v6, j);
__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::__normal_iterator<int *,void>(v8, &v7);
std::vector<int>::erase(a1, v8[0]);
}
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
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 0x0010191c
MOV dword ptr [RBP + -0x20],0x1
JMP 0x001012bd
LAB_001012a1:
LEA RDX,[RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
LAB_001012af:
CALL 0x00101a1a
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
LAB_001012bd:
MOV EAX,dword ptr [RBP + -0x20]
CMP dword ptr [RBP + -0x4c],EAX
JGE 0x001012a1
MOV dword ptr [RBP + -0x3c],0x1
JMP 0x00101375
LAB_001012d1:
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101b0e
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,EDX
MOV dword ptr [RBP + -0x38],EAX
JMP 0x00101355
LAB_001012f8:
MOV EAX,dword ptr [RBP + -0x38]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00101b32
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RBP + -0x30]
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00101b7e
MOV qword ptr [RBP + -0x28],RAX
LEA RDX,[RBP + -0x28]
LEA RAX,[RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101be4
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c12
MOV EDX,dword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,EDX
SUB EAX,0x1
MOV dword ptr [RBP + -0x38],EAX
LAB_00101355:
MOV EAX,dword ptr [RBP + -0x38]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00101ae6
CMP RBX,RAX
SETC AL
TEST AL,AL
JNZ 0x001012f8
ADD dword ptr [RBP + -0x3c],0x1
LAB_00101375:
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00101ae6
CMP RBX,RAX
SETNZ AL
TEST AL,AL
JNZ 0x001012d1
JMP 0x001013c9
LAB_001013c9:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001013dd
CALL 0x00101150
LAB_001013dd:
MOV RAX,qword ptr [RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int iVar1;
int *piVar2;
ulong uVar3;
long lVar4;
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_44;
int local_40;
int8 local_38;
int8 local_30;
int local_28;
int4 uStack_24;
long local_20;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<int,std::allocator<int>>::vector(this);
for (local_28 = 1; local_28 <= in_ESI; local_28 = local_28 + 1) {
/* try { // try from 001012af to 00101346 has its CatchHandler @ 00101397 */
std::vector<int,std::allocator<int>>::push_back(this,&local_28);
}
local_44 = 1;
while( true ) {
lVar4 = std::vector<int,std::allocator<int>>::size(this);
if (local_44 == lVar4) break;
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](this,(long)local_44);
iVar1 = *piVar2;
local_40 = iVar1 + local_44;
while( true ) {
uVar3 = std::vector<int,std::allocator<int>>::size(this);
if (uVar3 <= (ulong)(long)local_40) break;
local_38 = std::vector<int,std::allocator<int>>::begin(this);
local_30 = __normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator+
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)
&local_38,(long)local_40);
__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::
__normal_iterator<int*,void>
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)&local_28,
(__normal_iterator *)&local_30);
std::vector<int,std::allocator<int>>::erase(this,CONCAT44(uStack_24,local_28));
local_40 = iVar1 + local_40 + -1;
}
local_44 = local_44 + 1;
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return this;
} |
2,409 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(int n) {
std::vector<int> ludics;
for (int i = 1; i <= n; i++) {
ludics.push_back(i);
}
int index = 1;
while (index != ludics.size()) {
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < ludics.size()) {
ludics.erase(ludics.begin() + remove_index);
remove_index = remove_index + first_ludic - 1;
}
index += 1;
}
return ludics;
}
| int main() {
std::vector<int> result;
result = func0(10);
assert((result == std::vector<int>{1, 2, 3, 5, 7}));
result = func0(25);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25}));
result = func0(45);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43}));
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
movl $0x1,0x4(%rsp)
test %esi,%esi
jle 1308 <_Z5func0i+0x7f>
mov %esi,%ebx
mov $0x1,%eax
lea 0x4(%rsp),%r12
jmp 12f5 <_Z5func0i+0x6c>
mov %r12,%rdx
mov %rbp,%rdi
callq 1916 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
mov 0x4(%rsp),%eax
add $0x1,%eax
mov %eax,0x4(%rsp)
cmp %ebx,%eax
jg 1308 <_Z5func0i+0x7f>
mov 0x8(%rbp),%rsi
cmp 0x10(%rbp),%rsi
je 12db <_Z5func0i+0x52>
mov %eax,(%rsi)
addq $0x4,0x8(%rbp)
jmp 12e6 <_Z5func0i+0x5d>
mov 0x0(%rbp),%rdx
mov 0x8(%rbp),%rax
sub %rdx,%rax
cmp $0x4,%rax
je 13be <_Z5func0i+0x135>
mov $0x1,%r13d
jmp 1376 <_Z5func0i+0xed>
sub %rsi,%rdx
callq 1180 <memmove@plt>
mov 0x8(%rbp),%rax
lea -0x4(%rax),%rdx
mov %rdx,0x8(%rbp)
mov 0x0(%rbp),%rcx
add %r12,%rbx
mov %rdx,%rax
sub %rcx,%rax
sar $0x2,%rax
cmp %rbx,%rax
jbe 135e <_Z5func0i+0xd5>
lea (%rcx,%rbx,4),%rdi
lea 0x4(%rdi),%rsi
cmp %rdx,%rsi
jne 1325 <_Z5func0i+0x9c>
jmp 132d <_Z5func0i+0xa4>
mov 0x0(%rbp),%rdx
add $0x1,%r13
mov 0x8(%rbp),%rax
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%r13
je 13be <_Z5func0i+0x135>
mov (%rdx,%r13,4),%r12d
lea (%r12,%r13,1),%ebx
movslq %ebx,%rbx
mov 0x8(%rbp),%rdx
mov 0x0(%rbp),%rcx
mov %rdx,%rax
sub %rcx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 135e <_Z5func0i+0xd5>
movslq %r12d,%r12
sub $0x1,%r12
jmp 134f <_Z5func0i+0xc6>
endbr64
mov %rax,%rbx
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 13b6 <_Z5func0i+0x12d>
callq 1140 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1190 <_Unwind_Resume@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 13dc <_Z5func0i+0x153>
mov %rbp,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1160 <__stack_chk_fail@plt>
| _Z5func0i:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_34], 1
test esi, esi
jle short loc_12C6
mov r12d, esi
mov ebp, 1
lea r13, [rsp+38h+var_34]
jmp short loc_12B3
loc_129C:
mov rdx, r13
mov rdi, rbx
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int const&)
loc_12A7:
add ebp, 1
mov [rsp+38h+var_34], ebp
cmp ebp, r12d
jg short loc_12C6
loc_12B3:
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jz short loc_129C
mov [rsi], ebp
add qword ptr [rbx+8], 4
jmp short loc_12A7
loc_12C6:
mov rdx, [rbx]
mov rax, [rbx+8]
sub rax, rdx
cmp rax, 4
jz loc_1393
mov r13d, 1
jmp short loc_133D
loc_12E2:
jz short loc_131F
loc_12E4:
sub qword ptr [rbx+8], 4
mov rdx, [rbx+8]
mov rcx, [rbx]
add rbp, r12
mov rax, rdx
sub rax, rcx
sar rax, 2
cmp rbp, rax
jnb short loc_1326
loc_1302:
lea rdi, [rcx+rbp*4]; dest
lea rsi, [rdi+4]; src
cmp rsi, rdx
jz short loc_12E4
sub rdx, rsi; n
cmp rdx, 4
jle short loc_12E2
call _memmove
jmp short loc_12E4
loc_131F:
mov eax, [rdi+4]
mov [rdi], eax
jmp short loc_12E4
loc_1326:
mov rdx, [rbx]
add r13, 1
mov rax, [rbx+8]
sub rax, rdx
sar rax, 2
cmp r13, rax
jz short loc_1393
loc_133D:
mov r12d, [rdx+r13*4]
lea ebp, [r12+r13]
movsxd rbp, ebp
mov rdx, [rbx+8]
mov rcx, [rbx]
mov rax, rdx
sub rax, rcx
sar rax, 2
cmp rbp, rax
jnb short loc_1326
movsxd r12, r12d
sub r12, 1
jmp short loc_1302
endbr64
mov rbp, rax
mov rdi, rbx
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+arg_0]
sub rax, fs:28h
jz short loc_138B
call ___stack_chk_fail
loc_138B:
mov rdi, rbp; struct _Unwind_Exception *
call __Unwind_Resume
loc_1393:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_13B1
mov rax, rbx
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_13B1:
call ___stack_chk_fail | long long * func0(long long *a1, int a2)
{
int i; // ebp
int *v5; // rsi
long long v6; // rdx
long long v7; // r13
char *v8; // rdx
long long v9; // rcx
unsigned long long v10; // rbp
_DWORD *v11; // rdi
_BYTE *v12; // rsi
signed long long v13; // rdx
int v14; // r12d
long long v15; // r12
int v17; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v18; // [rsp+8h] [rbp-30h]
v18 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v17 = 1;
if ( a2 > 0 )
{
for ( i = 1; i <= a2; v17 = i )
{
v5 = (int *)a1[1];
if ( v5 == (int *)a1[2] )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v5, &v17);
}
else
{
*v5 = i;
a1[1] += 4LL;
}
++i;
}
}
v6 = *a1;
if ( a1[1] - *a1 != 4 )
{
v7 = 1LL;
do
{
v14 = *(_DWORD *)(v6 + 4 * v7);
v10 = v14 + (int)v7;
v8 = (char *)a1[1];
v9 = *a1;
if ( v10 < (long long)&v8[-*a1] >> 2 )
{
v15 = v14 - 1LL;
do
{
v11 = (_DWORD *)(v9 + 4 * v10);
v12 = v11 + 1;
if ( v11 + 1 != (_DWORD *)v8 )
{
v13 = v8 - v12;
if ( v13 <= 4 )
{
if ( v13 == 4 )
*v11 = v11[1];
}
else
{
memmove(v11, v12, v13);
}
}
a1[1] -= 4LL;
v8 = (char *)a1[1];
v9 = *a1;
v10 += v15;
}
while ( v10 < (long long)&v8[-*a1] >> 2 );
}
v6 = *a1;
++v7;
}
while ( v7 != (a1[1] - *a1) >> 2 );
}
return a1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x4],0x1
TEST ESI,ESI
JLE 0x001012c6
MOV R12D,ESI
MOV EBP,0x1
LEA R13,[RSP + 0x4]
JMP 0x001012b3
LAB_0010129c:
MOV RDX,R13
MOV RDI,RBX
LAB_001012a2:
CALL 0x001017e8
LAB_001012a7:
ADD EBP,0x1
MOV dword ptr [RSP + 0x4],EBP
CMP EBP,R12D
JG 0x001012c6
LAB_001012b3:
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JZ 0x0010129c
MOV dword ptr [RSI],EBP
ADD qword ptr [RBX + 0x8],0x4
JMP 0x001012a7
LAB_001012c6:
MOV RDX,qword ptr [RBX]
MOV RAX,qword ptr [RBX + 0x8]
SUB RAX,RDX
CMP RAX,0x4
JZ 0x00101393
MOV R13D,0x1
JMP 0x0010133d
LAB_001012e2:
JZ 0x0010131f
LAB_001012e4:
SUB qword ptr [RBX + 0x8],0x4
MOV RDX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RBX]
ADD RBP,R12
MOV RAX,RDX
SUB RAX,RCX
SAR RAX,0x2
CMP RBP,RAX
JNC 0x00101326
LAB_00101302:
LEA RDI,[RCX + RBP*0x4]
LEA RSI,[RDI + 0x4]
CMP RSI,RDX
JZ 0x001012e4
SUB RDX,RSI
CMP RDX,0x4
JLE 0x001012e2
CALL 0x00101140
JMP 0x001012e4
LAB_0010131f:
MOV EAX,dword ptr [RDI + 0x4]
MOV dword ptr [RDI],EAX
JMP 0x001012e4
LAB_00101326:
MOV RDX,qword ptr [RBX]
ADD R13,0x1
MOV RAX,qword ptr [RBX + 0x8]
SUB RAX,RDX
SAR RAX,0x2
CMP R13,RAX
JZ 0x00101393
LAB_0010133d:
MOV R12D,dword ptr [RDX + R13*0x4]
LEA EBP,[R12 + R13*0x1]
MOVSXD RBP,EBP
MOV RDX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RBX]
MOV RAX,RDX
SUB RAX,RCX
SAR RAX,0x2
CMP RBP,RAX
JNC 0x00101326
MOVSXD R12,R12D
SUB R12,0x1
JMP 0x00101302
LAB_00101393:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013b1
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001013b1:
CALL 0x00101130 | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int4 *__src;
int4 *__dest;
int iVar1;
int *piVar2;
long lVar3;
int4 *puVar4;
size_t __n;
ulong uVar5;
int in_ESI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long lVar6;
long in_FS_OFFSET;
int local_34;
long local_30;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
local_34 = 1;
if (0 < in_ESI) {
do {
iVar1 = local_34;
piVar2 = *(int **)(this + 8);
if (piVar2 == *(int **)(this + 0x10)) {
/* try { // try from 001012a2 to 001012a6 has its CatchHandler @ 00101367 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
(this,(__normal_iterator)piVar2,&local_34);
}
else {
*piVar2 = local_34;
*(long *)(this + 8) = *(long *)(this + 8) + 4;
}
local_34 = iVar1 + 1;
} while (local_34 <= in_ESI);
}
lVar3 = *(long *)this;
if (*(long *)(this + 8) - lVar3 != 4) {
lVar6 = 1;
do {
iVar1 = *(int *)(lVar3 + lVar6 * 4);
uVar5 = (ulong)(iVar1 + (int)lVar6);
puVar4 = *(int4 **)(this + 8);
lVar3 = *(long *)this;
if (uVar5 < (ulong)((long)puVar4 - lVar3 >> 2)) {
do {
__dest = (int4 *)(lVar3 + uVar5 * 4);
__src = __dest + 1;
if (__src != puVar4) {
__n = (long)puVar4 - (long)__src;
if ((long)__n < 5) {
if (__n == 4) {
*__dest = __dest[1];
}
}
else {
memmove(__dest,__src,__n);
}
}
*(long *)(this + 8) = *(long *)(this + 8) + -4;
puVar4 = *(int4 **)(this + 8);
lVar3 = *(long *)this;
uVar5 = uVar5 + (long)iVar1 + -1;
} while (uVar5 < (ulong)((long)puVar4 - lVar3 >> 2));
}
lVar3 = *(long *)this;
lVar6 = lVar6 + 1;
} while (lVar6 != *(long *)(this + 8) - lVar3 >> 2);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return this;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,410 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(int n) {
std::vector<int> ludics;
for (int i = 1; i <= n; i++) {
ludics.push_back(i);
}
int index = 1;
while (index != ludics.size()) {
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < ludics.size()) {
ludics.erase(ludics.begin() + remove_index);
remove_index = remove_index + first_ludic - 1;
}
index += 1;
}
return ludics;
}
| int main() {
std::vector<int> result;
result = func0(10);
assert((result == std::vector<int>{1, 2, 3, 5, 7}));
result = func0(25);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25}));
result = func0(45);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43}));
return 0;
}
| O2 | cpp | func0(int):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
movl $0x1,0x4(%rsp)
test %esi,%esi
jle 1806 <_Z5func0i+0x146>
mov %esi,%ebx
xor %edx,%edx
xor %esi,%esi
mov $0x1,%eax
lea 0x4(%rsp),%rbp
jmp 173f <_Z5func0i+0x7f>
nopw 0x0(%rax,%rax,1)
mov %eax,(%rsi)
mov 0x4(%rsp),%eax
add $0x4,%rsi
mov %rsi,0x8(%r12)
add $0x1,%eax
mov %eax,0x4(%rsp)
cmp %ebx,%eax
jg 1768 <_Z5func0i+0xa8>
mov 0x10(%r12),%rdx
cmp %rdx,%rsi
jne 1720 <_Z5func0i+0x60>
mov %rbp,%rdx
mov %r12,%rdi
callq 1930 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
mov 0x4(%rsp),%eax
mov 0x8(%r12),%rsi
add $0x1,%eax
mov %eax,0x4(%rsp)
cmp %ebx,%eax
jle 173a <_Z5func0i+0x7a>
nopl 0x0(%rax,%rax,1)
mov (%r12),%rdx
mov %rsi,%rax
sub %rdx,%rax
cmp $0x4,%rax
je 17e8 <_Z5func0i+0x128>
mov $0x1,%ebx
nopl (%rax)
movslq (%rdx,%rbx,4),%rbp
mov %rsi,%rax
sub %rdx,%rax
lea 0x0(%rbp,%rbx,1),%r13d
sar $0x2,%rax
movslq %r13d,%r13
cmp %r13,%rax
jbe 17df <_Z5func0i+0x11f>
sub $0x1,%rbp
lea (%rdx,%r13,4),%rdi
lea 0x4(%rdi),%r8
cmp %rsi,%r8
je 17bb <_Z5func0i+0xfb>
mov %rsi,%rdx
mov %r8,%rsi
sub %r8,%rdx
callq 1180 <memmove@plt>
mov 0x8(%r12),%rax
mov (%r12),%rdx
add %rbp,%r13
lea -0x4(%rax),%rsi
mov %rsi,%rax
mov %rsi,0x8(%r12)
sub %rdx,%rax
sar $0x2,%rax
cmp %r13,%rax
ja 17a0 <_Z5func0i+0xe0>
add $0x1,%rbx
cmp %rax,%rbx
jne 1780 <_Z5func0i+0xc0>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 180f <_Z5func0i+0x14f>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xor %esi,%esi
xor %edx,%edx
jmpq 1778 <_Z5func0i+0xb8>
callq 1160 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 11a0 <_Z5func0i.cold>
| _Z5func0i:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_34], 1
movups xmmword ptr [rdi], xmm0
test esi, esi
jle loc_1709
mov r12d, esi
mov ebp, 1
lea r13, [rsp+38h+var_34]
xor esi, esi
jmp short loc_1632
loc_1618:
mov [rsi], ebp
add rsi, 4
add ebp, 1
mov [rbx+8], rsi
mov [rsp+38h+var_34], ebp
cmp ebp, r12d
jg short loc_1658
loc_162E:
mov rax, [rbx+10h]
loc_1632:
cmp rsi, rax
jnz short loc_1618
mov rdx, r13
mov rdi, rbx
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int const&)
add ebp, 1
mov rsi, [rbx+8]
mov [rsp+38h+var_34], ebp
cmp ebp, r12d
jle short loc_162E
nop word ptr [rax+rax+00h]
loc_1658:
mov rdx, [rbx]
mov rax, rsi
sub rax, rdx
cmp rax, 4
jz short loc_16DB
loc_1667:
mov ebp, 1
nop dword ptr [rax+00h]
loc_1670:
movsxd r13, dword ptr [rdx+rbp*4]
mov rax, rsi
sub rax, rdx
lea r12d, [r13+rbp+0]
sar rax, 2
movsxd r12, r12d
cmp r12, rax
jnb short loc_16D2
sub r13, 1
nop
loc_1690:
lea rdi, [rdx+r12*4]; dest
lea rax, [rdi+4]
cmp rax, rsi
jz short loc_16B1
mov rdx, rsi
sub rdx, rax; n
cmp rdx, 4
jle short loc_1700
mov rsi, rax; src
call _memmove
loc_16B1:
mov rax, [rbx+8]
mov rdx, [rbx]
add r12, r13
lea rsi, [rax-4]
mov rax, rsi
mov [rbx+8], rsi
sub rax, rdx
sar rax, 2
cmp r12, rax
jb short loc_1690
loc_16D2:
add rbp, 1
cmp rbp, rax
jnz short loc_1670
loc_16DB:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1712
add rsp, 18h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1700:
jnz short loc_16B1
mov eax, [rdi+4]
mov [rdi], eax
jmp short loc_16B1
loc_1709:
xor edx, edx
xor esi, esi
jmp loc_1667
loc_1712:
call ___stack_chk_fail
endbr64
mov rbp, rax
jmp _Z5func0i_cold; func0(int) [clone] | long long * func0(long long *a1, int a2)
{
char *v3; // rax
int v5; // ebp
char *v6; // rsi
long long v7; // rdx
long long v8; // rbp
long long v9; // r13
unsigned long long v10; // rax
unsigned long long v11; // r12
long long v12; // r13
char *v13; // rdi
char *v14; // rax
int v16; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v17; // [rsp+4h] [rbp-30h]
v17 = __readfsqword(0x28u);
v3 = 0LL;
a1[2] = 0LL;
v16 = 1;
*(_OWORD *)a1 = 0LL;
if ( a2 <= 0 )
{
v7 = 0LL;
v6 = 0LL;
goto LABEL_8;
}
v5 = 1;
v6 = 0LL;
while ( v6 != v3 )
{
*(_DWORD *)v6 = v5;
v6 += 4;
++v5;
a1[1] = (long long)v6;
v16 = v5;
if ( v5 > a2 )
goto LABEL_7;
LABEL_4:
v3 = (char *)a1[2];
}
std::vector<int>::_M_realloc_insert<int const&>(a1, v6, &v16);
++v5;
v6 = (char *)a1[1];
v16 = v5;
if ( v5 <= a2 )
goto LABEL_4;
LABEL_7:
v7 = *a1;
if ( &v6[-*a1] != &byte_4 )
{
LABEL_8:
v8 = 1LL;
do
{
v9 = *(int *)(v7 + 4 * v8);
v10 = (long long)&v6[-v7] >> 2;
v11 = (int)v9 + (int)v8;
if ( v11 < v10 )
{
v12 = v9 - 1;
do
{
v13 = (char *)(v7 + 4 * v11);
v14 = v13 + 4;
if ( v13 + 4 != v6 )
{
if ( v6 - v14 <= 4 )
{
if ( v6 - v14 == 4 )
*(_DWORD *)v13 = *((_DWORD *)v13 + 1);
}
else
{
memmove(v13, v13 + 4, v6 - v14);
}
}
v7 = *a1;
v11 += v12;
v6 = (char *)(a1[1] - 4);
a1[1] = (long long)v6;
v10 = (long long)&v6[-v7] >> 2;
}
while ( v11 < v10 );
}
++v8;
}
while ( v8 != v10 );
}
return a1;
} | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x4],0x1
MOVUPS xmmword ptr [RDI],XMM0
TEST ESI,ESI
JLE 0x00101709
MOV R12D,ESI
MOV EBP,0x1
LEA R13,[RSP + 0x4]
XOR ESI,ESI
JMP 0x00101632
LAB_00101618:
MOV dword ptr [RSI],EBP
ADD RSI,0x4
ADD EBP,0x1
MOV qword ptr [RBX + 0x8],RSI
MOV dword ptr [RSP + 0x4],EBP
CMP EBP,R12D
JG 0x00101658
LAB_0010162e:
MOV RAX,qword ptr [RBX + 0x10]
LAB_00101632:
CMP RSI,RAX
JNZ 0x00101618
MOV RDX,R13
MOV RDI,RBX
LAB_0010163d:
CALL 0x00101840
ADD EBP,0x1
MOV RSI,qword ptr [RBX + 0x8]
MOV dword ptr [RSP + 0x4],EBP
CMP EBP,R12D
JLE 0x0010162e
NOP word ptr [RAX + RAX*0x1]
LAB_00101658:
MOV RDX,qword ptr [RBX]
MOV RAX,RSI
SUB RAX,RDX
CMP RAX,0x4
JZ 0x001016db
LAB_00101667:
MOV EBP,0x1
NOP dword ptr [RAX]
LAB_00101670:
MOVSXD R13,dword ptr [RDX + RBP*0x4]
MOV RAX,RSI
SUB RAX,RDX
LEA R12D,[R13 + RBP*0x1]
SAR RAX,0x2
MOVSXD R12,R12D
CMP R12,RAX
JNC 0x001016d2
SUB R13,0x1
NOP
LAB_00101690:
LEA RDI,[RDX + R12*0x4]
LEA RAX,[RDI + 0x4]
CMP RAX,RSI
JZ 0x001016b1
MOV RDX,RSI
SUB RDX,RAX
CMP RDX,0x4
JLE 0x00101700
MOV RSI,RAX
CALL 0x00101140
LAB_001016b1:
MOV RAX,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RBX]
ADD R12,R13
LEA RSI,[RAX + -0x4]
MOV RAX,RSI
MOV qword ptr [RBX + 0x8],RSI
SUB RAX,RDX
SAR RAX,0x2
CMP R12,RAX
JC 0x00101690
LAB_001016d2:
ADD RBP,0x1
CMP RBP,RAX
JNZ 0x00101670
LAB_001016db:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101712
ADD RSP,0x18
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101700:
JNZ 0x001016b1
MOV EAX,dword ptr [RDI + 0x4]
MOV dword ptr [RDI],EAX
JMP 0x001016b1
LAB_00101709:
XOR EDX,EDX
XOR ESI,ESI
JMP 0x00101667
LAB_00101712:
CALL 0x00101130 | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int4 *__dest;
int iVar1;
int *piVar2;
ulong uVar3;
size_t __n;
long lVar4;
ulong uVar5;
int in_ESI;
int *piVar6;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
ulong uVar7;
long in_FS_OFFSET;
int local_34;
long local_30;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local_30 = *(long *)(in_FS_OFFSET + 0x28);
piVar2 = (int *)0x0;
*(int8 *)(this + 0x10) = 0;
local_34 = 1;
*(int (*) [16])this = (int [16])0x0;
if (in_ESI < 1) {
lVar4 = 0;
piVar6 = (int *)0x0;
}
else {
piVar6 = (int *)0x0;
while( true ) {
iVar1 = local_34;
if (piVar6 == piVar2) {
/* try { // try from 0010163d to 00101641 has its CatchHandler @ 00101717 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
(this,(__normal_iterator)piVar6,&local_34);
piVar6 = *(int **)(this + 8);
}
else {
*piVar6 = local_34;
piVar6 = piVar6 + 1;
*(int **)(this + 8) = piVar6;
}
if (in_ESI < iVar1 + 1) break;
local_34 = iVar1 + 1;
piVar2 = *(int **)(this + 0x10);
}
local_34 = iVar1 + 1;
lVar4 = *(long *)this;
if ((long)piVar6 - lVar4 == 4) goto LAB_001016db;
}
uVar5 = 1;
do {
iVar1 = *(int *)(lVar4 + uVar5 * 4);
uVar3 = (long)piVar6 - lVar4 >> 2;
uVar7 = (ulong)(iVar1 + (int)uVar5);
if (uVar7 < uVar3) {
do {
__dest = (int4 *)(lVar4 + uVar7 * 4);
piVar2 = __dest + 1;
if (piVar2 != piVar6) {
__n = (long)piVar6 - (long)piVar2;
if ((long)__n < 5) {
if (__n == 4) {
*__dest = __dest[1];
}
}
else {
memmove(__dest,piVar2,__n);
}
}
lVar4 = *(long *)this;
uVar7 = uVar7 + (long)iVar1 + -1;
piVar6 = (int *)(*(long *)(this + 8) + -4);
*(int **)(this + 8) = piVar6;
uVar3 = (long)piVar6 - lVar4 >> 2;
} while (uVar7 < uVar3);
}
uVar5 = uVar5 + 1;
} while (uVar5 != uVar3);
LAB_001016db:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return this;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,411 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(int n) {
std::vector<int> ludics;
for (int i = 1; i <= n; i++) {
ludics.push_back(i);
}
int index = 1;
while (index != ludics.size()) {
int first_ludic = ludics[index];
int remove_index = index + first_ludic;
while (remove_index < ludics.size()) {
ludics.erase(ludics.begin() + remove_index);
remove_index = remove_index + first_ludic - 1;
}
index += 1;
}
return ludics;
}
| int main() {
std::vector<int> result;
result = func0(10);
assert((result == std::vector<int>{1, 2, 3, 5, 7}));
result = func0(25);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25}));
result = func0(45);
assert((result == std::vector<int>{1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43}));
return 0;
}
| O3 | cpp | func0(int):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movl $0x1,0x4(%rsp)
movups %xmm0,(%rdi)
test %esi,%esi
jle 179d <_Z5func0i+0x17d>
mov %esi,%ebx
xor %edx,%edx
xor %esi,%esi
mov $0x1,%eax
lea 0x4(%rsp),%rbp
jmp 1697 <_Z5func0i+0x77>
nopw 0x0(%rax,%rax,1)
mov %eax,(%rsi)
mov 0x4(%rsp),%eax
add $0x4,%rsi
mov %rsi,0x8(%r12)
add $0x1,%eax
mov %eax,0x4(%rsp)
cmp %ebx,%eax
jg 16c0 <_Z5func0i+0xa0>
mov 0x10(%r12),%rdx
cmp %rdx,%rsi
jne 1678 <_Z5func0i+0x58>
mov %rbp,%rdx
mov %r12,%rdi
callq 18c0 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
mov 0x4(%rsp),%eax
mov 0x8(%r12),%rsi
add $0x1,%eax
mov %eax,0x4(%rsp)
cmp %ebx,%eax
jle 1692 <_Z5func0i+0x72>
nopl 0x0(%rax,%rax,1)
mov (%r12),%rdx
mov %rsi,%rax
sub %rdx,%rax
cmp $0x4,%rax
je 1748 <_Z5func0i+0x128>
mov $0x1,%ebp
nopl (%rax)
movslq (%rdx,%rbp,4),%rbx
mov %rsi,%rax
sub %rdx,%rax
lea (%rbx,%rbp,1),%r13d
sar $0x2,%rax
movslq %r13d,%r13
cmp %r13,%rax
jbe 173f <_Z5func0i+0x11f>
sub $0x1,%rbx
nopw %cs:0x0(%rax,%rax,1)
lea (%rdx,%r13,4),%rdi
lea 0x4(%rdi),%r8
cmp %rsi,%r8
je 1770 <_Z5func0i+0x150>
mov %rsi,%rdx
mov %r8,%rsi
add %rbx,%r13
sub %r8,%rdx
callq 1180 <memmove@plt>
mov 0x8(%r12),%rax
mov (%r12),%rdx
lea -0x4(%rax),%rsi
mov %rsi,%rax
mov %rsi,0x8(%r12)
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%r13
jb 1700 <_Z5func0i+0xe0>
add $0x1,%rbp
cmp %rax,%rbp
jne 16d8 <_Z5func0i+0xb8>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 17a6 <_Z5func0i+0x186>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw %cs:0x0(%rax,%rax,1)
mov %rdi,%rax
add %rbx,%r13
mov %rdi,0x8(%r12)
mov %rdi,%rsi
sub %rdx,%rax
sar $0x2,%rax
cmp %r13,%rax
ja 1700 <_Z5func0i+0xe0>
add $0x1,%rbp
cmp %rax,%rbp
jne 16d8 <_Z5func0i+0xb8>
jmp 1748 <_Z5func0i+0x128>
xor %esi,%esi
xor %edx,%edx
jmpq 16d0 <_Z5func0i+0xb0>
callq 1160 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 11a0 <_Z5func0i.cold>
nopw 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
mov [rsp+38h+var_34], 1
movups xmmword ptr [rdi], xmm0
test esi, esi
jle loc_1709
mov r12d, esi
mov ebp, 1
lea r13, [rsp+38h+var_34]
xor esi, esi
jmp short loc_1632
loc_1618:
mov [rsi], ebp
add rsi, 4
add ebp, 1
mov [rbx+8], rsi
mov [rsp+38h+var_34], ebp
cmp ebp, r12d
jg short loc_1658
loc_162E:
mov rax, [rbx+10h]
loc_1632:
cmp rsi, rax
jnz short loc_1618
mov rdx, r13
mov rdi, rbx
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int const&)
add ebp, 1
mov rsi, [rbx+8]
mov [rsp+38h+var_34], ebp
cmp ebp, r12d
jle short loc_162E
nop word ptr [rax+rax+00h]
loc_1658:
mov rdx, [rbx]
mov rax, rsi
sub rax, rdx
cmp rax, 4
jz short loc_16DE
loc_1667:
mov ebp, 1
nop dword ptr [rax+00h]
loc_1670:
movsxd r13, dword ptr [rdx+rbp*4]
mov rax, rsi
sub rax, rdx
lea r12d, [r13+rbp+0]
sar rax, 2
movsxd r12, r12d
cmp r12, rax
jnb short loc_16D5
sub r13, 1
nop
loc_1690:
lea rdi, [rdx+r12*4]; dest
lea rax, [rdi+4]
cmp rsi, rax
jz short loc_16BB
mov rcx, rsi
sub rcx, rax
cmp rcx, 4
jle short loc_1700
mov rdx, rcx; n
mov rsi, rax; src
call _memmove
mov rdx, [rbx]
mov rsi, [rbx+8]
loc_16BB:
sub rsi, 4
add r12, r13
mov rax, rsi
mov [rbx+8], rsi
sub rax, rdx
sar rax, 2
cmp r12, rax
jb short loc_1690
loc_16D5:
add rbp, 1
cmp rbp, rax
jnz short loc_1670
loc_16DE:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1712
add rsp, 18h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1700:
jnz short loc_16BB
mov eax, [rdi+4]
mov [rdi], eax
jmp short loc_16BB
loc_1709:
xor edx, edx
xor esi, esi
jmp loc_1667
loc_1712:
call ___stack_chk_fail
endbr64
mov rbp, rax
jmp _Z5func0i_cold; func0(int) [clone] | long long * func0(long long *a1, int a2)
{
char *v3; // rax
int v5; // ebp
char *v6; // rsi
long long v7; // rdx
long long v8; // rbp
long long v9; // r13
unsigned long long v10; // rax
unsigned long long v11; // r12
long long v12; // r13
char *v13; // rdi
char *v14; // rax
int v16; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v17; // [rsp+4h] [rbp-30h]
v17 = __readfsqword(0x28u);
v3 = 0LL;
a1[2] = 0LL;
v16 = 1;
*(_OWORD *)a1 = 0LL;
if ( a2 <= 0 )
{
v7 = 0LL;
v6 = 0LL;
goto LABEL_8;
}
v5 = 1;
v6 = 0LL;
while ( v6 != v3 )
{
*(_DWORD *)v6 = v5;
v6 += 4;
++v5;
a1[1] = (long long)v6;
v16 = v5;
if ( v5 > a2 )
goto LABEL_7;
LABEL_4:
v3 = (char *)a1[2];
}
std::vector<int>::_M_realloc_insert<int const&>(a1, v6, &v16);
++v5;
v6 = (char *)a1[1];
v16 = v5;
if ( v5 <= a2 )
goto LABEL_4;
LABEL_7:
v7 = *a1;
if ( &v6[-*a1] != &byte_4 )
{
LABEL_8:
v8 = 1LL;
do
{
v9 = *(int *)(v7 + 4 * v8);
v10 = (long long)&v6[-v7] >> 2;
v11 = (int)v9 + (int)v8;
if ( v11 < v10 )
{
v12 = v9 - 1;
do
{
v13 = (char *)(v7 + 4 * v11);
v14 = v13 + 4;
if ( v6 != v13 + 4 )
{
if ( v6 - v14 <= 4 )
{
if ( v6 - v14 == 4 )
*(_DWORD *)v13 = *((_DWORD *)v13 + 1);
}
else
{
memmove(v13, v13 + 4, v6 - v14);
v7 = *a1;
v6 = (char *)a1[1];
}
}
v6 -= 4;
v11 += v12;
a1[1] = (long long)v6;
v10 = (long long)&v6[-v7] >> 2;
}
while ( v11 < v10 );
}
++v8;
}
while ( v8 != v10 );
}
return a1;
} | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x4],0x1
MOVUPS xmmword ptr [RDI],XMM0
TEST ESI,ESI
JLE 0x00101709
MOV R12D,ESI
MOV EBP,0x1
LEA R13,[RSP + 0x4]
XOR ESI,ESI
JMP 0x00101632
LAB_00101618:
MOV dword ptr [RSI],EBP
ADD RSI,0x4
ADD EBP,0x1
MOV qword ptr [RBX + 0x8],RSI
MOV dword ptr [RSP + 0x4],EBP
CMP EBP,R12D
JG 0x00101658
LAB_0010162e:
MOV RAX,qword ptr [RBX + 0x10]
LAB_00101632:
CMP RSI,RAX
JNZ 0x00101618
MOV RDX,R13
MOV RDI,RBX
LAB_0010163d:
CALL 0x00101840
ADD EBP,0x1
MOV RSI,qword ptr [RBX + 0x8]
MOV dword ptr [RSP + 0x4],EBP
CMP EBP,R12D
JLE 0x0010162e
NOP word ptr [RAX + RAX*0x1]
LAB_00101658:
MOV RDX,qword ptr [RBX]
MOV RAX,RSI
SUB RAX,RDX
CMP RAX,0x4
JZ 0x001016de
LAB_00101667:
MOV EBP,0x1
NOP dword ptr [RAX]
LAB_00101670:
MOVSXD R13,dword ptr [RDX + RBP*0x4]
MOV RAX,RSI
SUB RAX,RDX
LEA R12D,[R13 + RBP*0x1]
SAR RAX,0x2
MOVSXD R12,R12D
CMP R12,RAX
JNC 0x001016d5
SUB R13,0x1
NOP
LAB_00101690:
LEA RDI,[RDX + R12*0x4]
LEA RAX,[RDI + 0x4]
CMP RSI,RAX
JZ 0x001016bb
MOV RCX,RSI
SUB RCX,RAX
CMP RCX,0x4
JLE 0x00101700
MOV RDX,RCX
MOV RSI,RAX
CALL 0x00101140
MOV RDX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x8]
LAB_001016bb:
SUB RSI,0x4
ADD R12,R13
MOV RAX,RSI
MOV qword ptr [RBX + 0x8],RSI
SUB RAX,RDX
SAR RAX,0x2
CMP R12,RAX
JC 0x00101690
LAB_001016d5:
ADD RBP,0x1
CMP RBP,RAX
JNZ 0x00101670
LAB_001016de:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101712
ADD RSP,0x18
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101700:
JNZ 0x001016bb
MOV EAX,dword ptr [RDI + 0x4]
MOV dword ptr [RDI],EAX
JMP 0x001016bb
LAB_00101709:
XOR EDX,EDX
XOR ESI,ESI
JMP 0x00101667
LAB_00101712:
CALL 0x00101130 | /* func0(int) */
vector<int,std::allocator<int>> * func0(int param_1)
{
int4 *__dest;
int iVar1;
int *piVar2;
ulong uVar3;
size_t __n;
long lVar4;
ulong uVar5;
int in_ESI;
int *piVar6;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
ulong uVar7;
long in_FS_OFFSET;
int local_34;
long local_30;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local_30 = *(long *)(in_FS_OFFSET + 0x28);
piVar2 = (int *)0x0;
*(int8 *)(this + 0x10) = 0;
local_34 = 1;
*(int (*) [16])this = (int [16])0x0;
if (in_ESI < 1) {
lVar4 = 0;
piVar6 = (int *)0x0;
}
else {
piVar6 = (int *)0x0;
while( true ) {
iVar1 = local_34;
if (piVar6 == piVar2) {
/* try { // try from 0010163d to 00101641 has its CatchHandler @ 00101717 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
(this,(__normal_iterator)piVar6,&local_34);
piVar6 = *(int **)(this + 8);
}
else {
*piVar6 = local_34;
piVar6 = piVar6 + 1;
*(int **)(this + 8) = piVar6;
}
if (in_ESI < iVar1 + 1) break;
local_34 = iVar1 + 1;
piVar2 = *(int **)(this + 0x10);
}
local_34 = iVar1 + 1;
lVar4 = *(long *)this;
if ((long)piVar6 - lVar4 == 4) goto LAB_001016de;
}
uVar5 = 1;
do {
iVar1 = *(int *)(lVar4 + uVar5 * 4);
uVar3 = (long)piVar6 - lVar4 >> 2;
uVar7 = (ulong)(iVar1 + (int)uVar5);
if (uVar7 < uVar3) {
do {
__dest = (int4 *)(lVar4 + uVar7 * 4);
piVar2 = __dest + 1;
if (piVar6 != piVar2) {
__n = (long)piVar6 - (long)piVar2;
if ((long)__n < 5) {
if (__n == 4) {
*__dest = __dest[1];
}
}
else {
memmove(__dest,piVar2,__n);
lVar4 = *(long *)this;
piVar6 = *(int **)(this + 8);
}
}
piVar6 = piVar6 + -1;
uVar7 = uVar7 + (long)iVar1 + -1;
*(int **)(this + 8) = piVar6;
uVar3 = (long)piVar6 - lVar4 >> 2;
} while (uVar7 < uVar3);
}
uVar5 = uVar5 + 1;
} while (uVar5 != uVar3);
LAB_001016de:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return this;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,412 | func0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <cassert>
| std::string func0(const std::string& s) {
std::string temp = s;
std::reverse(temp.begin(), temp.end());
size_t start = 0;
size_t end = temp.find(" ");
while (end != std::string::npos) {
std::reverse(temp.begin() + start, temp.begin() + end);
start = end + 1;
end = temp.find(" ", start);
}
std::reverse(temp.begin() + start, temp.end());
return temp;
}
| int main() {
assert(func0("python program") == "program python");
assert(func0("java language") == "language java");
assert(func0("indian man") == "man indian");
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 %r12
push %rbx
sub $0x40,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x50(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2220 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_@plt>
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 2230 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv@plt>
mov %rax,%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 22a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv@plt>
mov %rbx,%rsi
mov %rax,%rdi
callq 2a0f <_ZSt7reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_>
movq $0x0,-0x28(%rbp)
mov -0x48(%rbp),%rax
mov $0x0,%edx
lea 0x1b0c(%rip),%rsi
mov %rax,%rdi
callq 2390 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcm@plt>
mov %rax,-0x20(%rbp)
cmpq $0xffffffffffffffff,-0x20(%rbp)
je 2597 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10e>
mov -0x20(%rbp),%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 22a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv@plt>
mov %rax,-0x30(%rbp)
lea -0x30(%rbp),%rax
mov %rbx,%rsi
mov %rax,%rdi
callq 2a46 <_ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEplEl>
mov %rax,%r12
mov -0x28(%rbp),%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 22a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv@plt>
mov %rax,-0x38(%rbp)
lea -0x38(%rbp),%rax
mov %rbx,%rsi
mov %rax,%rdi
callq 2a46 <_ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEplEl>
mov %r12,%rsi
mov %rax,%rdi
callq 2a0f <_ZSt7reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_>
mov -0x20(%rbp),%rax
add $0x1,%rax
mov %rax,-0x28(%rbp)
mov -0x28(%rbp),%rdx
mov -0x48(%rbp),%rax
lea 0x1a86(%rip),%rsi
mov %rax,%rdi
callq 2390 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcm@plt>
mov %rax,-0x20(%rbp)
jmpq 250c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x83>
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 2230 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv@plt>
mov %rax,%r12
mov -0x28(%rbp),%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 22a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv@plt>
mov %rax,-0x30(%rbp)
lea -0x30(%rbp),%rax
mov %rbx,%rsi
mov %rax,%rdi
callq 2a46 <_ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEplEl>
mov %r12,%rsi
mov %rax,%rdi
callq 2a0f <_ZSt7reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_>
jmp 25f4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x16b>
endbr64
mov %rax,%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 2240 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
mov %rbx,%rax
mov %rax,%rdi
callq 2350 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 2608 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x17f>
callq 2300 <__stack_chk_fail@plt>
mov -0x48(%rbp),%rax
add $0x40,%rsp
pop %rbx
pop %r12
pop %rbp
retq
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 40h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rdx, [rbp+var_50]
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_; std::string::basic_string(std::string const&)
mov rax, [rbp+var_48]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov rbx, rax
mov rax, [rbp+var_48]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov rsi, rbx
mov rdi, rax
call _ZSt7reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_; std::reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<char *,std::string>)
mov [rbp+var_28], 0
mov rax, [rbp+var_48]
mov edx, 0
lea rcx, unk_4008
mov rsi, rcx
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcm; std::string::find(char const*,ulong)
mov [rbp+var_20], rax
jmp short loc_24EF
loc_2471:
mov rbx, [rbp+var_20]
mov rax, [rbp+var_48]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rbp+var_30], rax
lea rax, [rbp+var_30]
mov rsi, rbx
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEplEl; __gnu_cxx::__normal_iterator<char *,std::string>::operator+(long)
mov r12, rax
mov rbx, [rbp+var_28]
mov rax, [rbp+var_48]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rbp+var_38], rax
lea rax, [rbp+var_38]
mov rsi, rbx
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEplEl; __gnu_cxx::__normal_iterator<char *,std::string>::operator+(long)
mov rsi, r12
mov rdi, rax
call _ZSt7reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_; std::reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<char *,std::string>)
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_28], rax
mov rdx, [rbp+var_28]
mov rax, [rbp+var_48]
lea rcx, unk_4008
mov rsi, rcx
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcm; std::string::find(char const*,ulong)
mov [rbp+var_20], rax
loc_24EF:
cmp [rbp+var_20], 0FFFFFFFFFFFFFFFFh
jnz loc_2471
mov rax, [rbp+var_48]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov r12, rax
mov rbx, [rbp+var_28]
mov rax, [rbp+var_48]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rbp+var_30], rax
lea rax, [rbp+var_30]
mov rsi, rbx
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEplEl; __gnu_cxx::__normal_iterator<char *,std::string>::operator+(long)
mov rsi, r12
mov rdi, rax
call _ZSt7reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_; std::reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<char *,std::string>)
jmp short loc_256B
endbr64
mov rbx, rax
mov rax, [rbp+var_48]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_2563
call ___stack_chk_fail
loc_2563:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_256B:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_257F
call ___stack_chk_fail
loc_257F:
mov rax, [rbp+var_48]
add rsp, 40h
pop rbx
pop r12
pop rbp
retn | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
long long v4; // rbx
long long v5; // r12
long long v6; // rbx
long long v7; // rax
long long v8; // r12
long long v9; // rbx
long long v10; // rax
long long v12; // [rsp+18h] [rbp-38h] BYREF
long long v13; // [rsp+20h] [rbp-30h] BYREF
long long v14; // [rsp+28h] [rbp-28h]
long long i; // [rsp+30h] [rbp-20h]
unsigned long long v16; // [rsp+38h] [rbp-18h]
v16 = __readfsqword(0x28u);
std::string::basic_string(a1, a2);
v2 = std::string::end(a1);
v3 = std::string::begin(a1);
std::reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(v3, v2);
v14 = 0LL;
for ( i = std::string::find(a1, &unk_4008, 0LL); i != -1; i = std::string::find(a1, &unk_4008, i + 1) )
{
v4 = i;
v13 = std::string::begin(a1);
v5 = __gnu_cxx::__normal_iterator<char *,std::string>::operator+(&v13, v4);
v6 = v14;
v12 = std::string::begin(a1);
v7 = __gnu_cxx::__normal_iterator<char *,std::string>::operator+(&v12, v6);
std::reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(v7, v5);
v14 = i + 1;
}
v8 = std::string::end(a1);
v9 = v14;
v13 = std::string::begin(a1);
v10 = __gnu_cxx::__normal_iterator<char *,std::string>::operator+(&v13, v9);
std::reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(v10, v8);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x40
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 RDX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
LAB_0010241d:
CALL 0x001021a0
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001021d0
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00102250
MOV RSI,RBX
MOV RDI,RAX
LAB_00102443:
CALL 0x00102a88
MOV qword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV EDX,0x0
LEA RCX,[0x104008]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001022f0
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001024ef
LAB_00102471:
MOV RBX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00102250
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RBP + -0x30]
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00102ab4
MOV R12,RAX
MOV RBX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00102250
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[RBP + -0x38]
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00102ab4
MOV RSI,R12
MOV RDI,RAX
CALL 0x00102a88
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x48]
LEA RCX,[0x104008]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001022f0
MOV qword ptr [RBP + -0x20],RAX
LAB_001024ef:
CMP qword ptr [RBP + -0x20],-0x1
JNZ 0x00102471
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001021d0
MOV R12,RAX
MOV RBX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00102250
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RBP + -0x30]
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00102ab4
MOV RSI,R12
MOV RDI,RAX
CALL 0x00102a88
JMP 0x0010256b
LAB_0010256b:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010257f
CALL 0x00102290
LAB_0010257f:
MOV RAX,qword ptr [RBP + -0x48]
ADD RSP,0x40
POP RBX
POP R12
POP RBP
RET | /* func0(std::string const&) */
string * func0(string *param_1)
{
long lVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
string *in_RSI;
long in_FS_OFFSET;
int8 local_40;
int8 local_38;
long local_30;
long local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::string::string(param_1,in_RSI);
_Var2 = std::string::end();
_Var3 = std::string::begin();
/* try { // try from 00102443 to 00102536 has its CatchHandler @ 00102539 */
std::reverse<__normal_iterator<char*,std::string>>(_Var3,_Var2);
local_30 = 0;
local_28 = std::string::find((char *)param_1,0x104008);
while (lVar1 = local_28, local_28 != -1) {
local_38 = std::string::begin();
_Var2 = __normal_iterator<char*,std::string>::operator+
((__normal_iterator<char*,std::string> *)&local_38,lVar1);
lVar1 = local_30;
local_40 = std::string::begin();
_Var3 = __normal_iterator<char*,std::string>::operator+
((__normal_iterator<char*,std::string> *)&local_40,lVar1);
std::reverse<__normal_iterator<char*,std::string>>(_Var3,_Var2);
local_30 = local_28 + 1;
local_28 = std::string::find((char *)param_1,0x104008);
}
_Var2 = std::string::end();
lVar1 = local_30;
local_38 = std::string::begin();
_Var3 = __normal_iterator<char*,std::string>::operator+
((__normal_iterator<char*,std::string> *)&local_38,lVar1);
std::reverse<__normal_iterator<char*,std::string>>(_Var3,_Var2);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,413 | func0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <cassert>
| std::string func0(const std::string& s) {
std::string temp = s;
std::reverse(temp.begin(), temp.end());
size_t start = 0;
size_t end = temp.find(" ");
while (end != std::string::npos) {
std::reverse(temp.begin() + start, temp.begin() + end);
start = end + 1;
end = temp.find(" ", start);
}
std::reverse(temp.begin() + start, temp.end());
return temp;
}
| int main() {
assert(func0("python program") == "program python");
assert(func0("java language") == "language java");
assert(func0("indian man") == "man indian");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r12
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
mov %rax,(%rdi)
mov (%rsi),%rbp
mov 0x8(%rsi),%rbx
test %rbp,%rbp
jne 12c6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3d>
test %rbx,%rbx
jne 139e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x115>
mov %rbx,(%rsp)
cmp $0xf,%rbx
ja 13aa <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x121>
mov (%r12),%rdi
cmp $0x1,%rbx
jne 13da <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x151>
movzbl 0x0(%rbp),%eax
mov %al,(%rdi)
mov (%rsp),%rax
mov %rax,0x8(%r12)
mov (%r12),%rdx
movb $0x0,(%rdx,%rax,1)
mov (%r12),%rdi
mov %rdi,%rsi
add 0x8(%r12),%rsi
callq 1720 <_ZSt9__reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_St26random_access_iterator_tag>
mov $0x1,%ecx
mov $0x0,%edx
lea 0xd17(%rip),%rsi
mov %r12,%rdi
callq 1170 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm@plt>
mov %rax,%rbx
cmp $0xffffffffffffffff,%rax
je 13e5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x15c>
mov $0x0,%ebp
lea 0xcf6(%rip),%r13
mov (%r12),%rsi
lea (%rsi,%rbp,1),%rdi
add %rbx,%rsi
callq 1720 <_ZSt9__reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_St26random_access_iterator_tag>
lea 0x1(%rbx),%rbp
mov $0x1,%ecx
mov %rbp,%rdx
mov %r13,%rsi
mov %r12,%rdi
callq 1170 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm@plt>
mov %rax,%rbx
cmp $0xffffffffffffffff,%rax
jne 133c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xb3>
mov (%r12),%rdi
mov %rdi,%rsi
add 0x8(%r12),%rsi
add %rbp,%rdi
callq 1720 <_ZSt9__reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_St26random_access_iterator_tag>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 13ec <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x163>
mov %r12,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
lea 0xc63(%rip),%rdi
callq 1110 <_ZSt19__throw_logic_errorPKc@plt>
mov %rsp,%rsi
mov $0x0,%edx
mov %r12,%rdi
callq 1190 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,%rdi
mov %rax,(%r12)
mov (%rsp),%rax
mov %rax,0x10(%r12)
mov %rbx,%rdx
mov %rbp,%rsi
callq 1120 <memcpy@plt>
jmpq 12e8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5f>
test %rbx,%rbx
je 12e8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5f>
jmp 13ca <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x141>
mov $0x0,%ebp
jmp 136c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xe3>
callq 1150 <__stack_chk_fail@plt>
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r12, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
lea rdi, [rdi+10h]
mov [r12], rdi
mov rbp, [rsi]
mov rbx, [rsi+8]
mov [rsp+38h+var_38], rbx
cmp rbx, 0Fh
ja loc_1370
cmp rbx, 1
jnz loc_13A0
movzx eax, byte ptr [rbp+0]
mov [r12+10h], al
loc_12BA:
mov rax, [rsp+38h+var_38]
mov [r12+8], rax
mov rdx, [r12]
mov byte ptr [rdx+rax], 0
mov rdi, [r12]
mov rsi, rdi
add rsi, [r12+8]
call _ZSt9__reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_St26random_access_iterator_tag; std::__reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<char *,std::string>,std::random_access_iterator_tag)
mov ecx, 1
mov edx, 0
lea rsi, asc_20E4; " "
mov rdi, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
mov rbx, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_13AB
mov ebp, 0
lea r13, asc_20E4; " "
loc_130E:
mov rsi, [r12]
lea rdi, [rsi+rbp]
add rsi, rbx
call _ZSt9__reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_St26random_access_iterator_tag; std::__reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<char *,std::string>,std::random_access_iterator_tag)
lea rbp, [rbx+1]
mov ecx, 1
mov rdx, rbp
mov rsi, r13
mov rdi, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
mov rbx, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_130E
loc_133E:
mov rdi, [r12]
mov rsi, rdi
add rsi, [r12+8]
add rdi, rbp
call _ZSt9__reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_St26random_access_iterator_tag; std::__reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<char *,std::string>,std::random_access_iterator_tag)
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_13B2
mov rax, r12
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1370:
mov rsi, rsp
mov edx, 0
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov rdi, rax; dest
mov [r12], rax
mov rax, [rsp+38h+var_38]
mov [r12+10h], rax
loc_1390:
mov rdx, rbx; n
mov rsi, rbp; src
call _memcpy
jmp loc_12BA
loc_13A0:
test rbx, rbx
jz loc_12BA
jmp short loc_1390
loc_13AB:
mov ebp, 0
jmp short loc_133E
loc_13B2:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, long long a2)
{
void *v3; // rdi
_BYTE *v4; // rbp
size_t v5; // rbx
long long v6; // rax
long long v7; // rbx
long long v8; // rbp
_QWORD v10[7]; // [rsp+0h] [rbp-38h] BYREF
v10[1] = __readfsqword(0x28u);
v3 = a1 + 2;
*a1 = v3;
v4 = *(_BYTE **)a2;
v5 = *(_QWORD *)(a2 + 8);
v10[0] = v5;
if ( v5 > 0xF )
{
v3 = (void *)std::string::_M_create(a1, v10, 0LL);
*a1 = v3;
a1[2] = v10[0];
LABEL_9:
memcpy(v3, v4, v5);
goto LABEL_4;
}
if ( v5 == 1 )
{
*((_BYTE *)a1 + 16) = *v4;
goto LABEL_4;
}
if ( v5 )
goto LABEL_9;
LABEL_4:
v6 = v10[0];
a1[1] = v10[0];
*(_BYTE *)(*a1 + v6) = 0;
std::__reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(*a1, a1[1] + *a1);
v7 = std::string::find(a1, " ", 0LL, 1LL);
if ( v7 == -1 )
{
v8 = 0LL;
}
else
{
v8 = 0LL;
do
{
std::__reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(*a1 + v8, v7 + *a1);
v8 = v7 + 1;
v7 = std::string::find(a1, " ", v7 + 1, 1LL);
}
while ( v7 != -1 );
}
std::__reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(v8 + *a1, a1[1] + *a1);
return a1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
LEA RDI,[RDI + 0x10]
MOV qword ptr [R12],RDI
MOV RBP,qword ptr [RSI]
MOV RBX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP],RBX
CMP RBX,0xf
JA 0x00101370
CMP RBX,0x1
JNZ 0x001013a0
MOVZX EAX,byte ptr [RBP]
MOV byte ptr [R12 + 0x10],AL
LAB_001012ba:
MOV RAX,qword ptr [RSP]
MOV qword ptr [R12 + 0x8],RAX
MOV RDX,qword ptr [R12]
MOV byte ptr [RDX + RAX*0x1],0x0
MOV RDI,qword ptr [R12]
MOV RSI,RDI
ADD RSI,qword ptr [R12 + 0x8]
CALL 0x001016f0
MOV ECX,0x1
MOV EDX,0x0
LEA RSI,[0x1020e4]
MOV RDI,R12
CALL 0x00101150
MOV RBX,RAX
CMP RAX,-0x1
JZ 0x001013ab
MOV EBP,0x0
LEA R13,[0x1020e4]
LAB_0010130e:
MOV RSI,qword ptr [R12]
LEA RDI,[RSI + RBP*0x1]
ADD RSI,RBX
CALL 0x001016f0
LEA RBP,[RBX + 0x1]
MOV ECX,0x1
MOV RDX,RBP
MOV RSI,R13
MOV RDI,R12
CALL 0x00101150
MOV RBX,RAX
CMP RAX,-0x1
JNZ 0x0010130e
LAB_0010133e:
MOV RDI,qword ptr [R12]
MOV RSI,RDI
ADD RSI,qword ptr [R12 + 0x8]
ADD RDI,RBP
CALL 0x001016f0
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013b2
MOV RAX,R12
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101370:
MOV RSI,RSP
MOV EDX,0x0
MOV RDI,R12
CALL 0x00101170
MOV RDI,RAX
MOV qword ptr [R12],RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [R12 + 0x10],RAX
LAB_00101390:
MOV RDX,RBX
MOV RSI,RBP
CALL 0x00101120
JMP 0x001012ba
LAB_001013a0:
TEST RBX,RBX
JZ 0x001012ba
JMP 0x00101390
LAB_001013ab:
MOV EBP,0x0
JMP 0x0010133e
LAB_001013b2:
CALL 0x00101130 | /* func0(std::string const&) */
string * func0(string *param_1)
{
string *__src;
long lVar1;
string *__dest;
random_access_iterator_tag rVar2;
ulong uVar3;
int8 *in_RSI;
long in_FS_OFFSET;
int auVar4 [16];
ulong local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
__dest = param_1 + 0x10;
*(string **)param_1 = __dest;
__src = (string *)*in_RSI;
uVar3 = in_RSI[1];
local_38 = uVar3;
if (uVar3 < 0x10) {
if (uVar3 == 1) {
param_1[0x10] = *__src;
goto LAB_001012ba;
}
if (uVar3 == 0) goto LAB_001012ba;
}
else {
__dest = (string *)std::string::_M_create((ulong *)param_1,(ulong)&local_38);
*(string **)param_1 = __dest;
*(ulong *)(param_1 + 0x10) = local_38;
}
memcpy(__dest,__src,uVar3);
LAB_001012ba:
*(ulong *)(param_1 + 8) = local_38;
lVar1 = *(long *)param_1;
*(int *)(lVar1 + local_38) = 0;
std::__reverse<__normal_iterator<char*,std::string>>
((__normal_iterator)*(int8 *)param_1,
(__normal_iterator)*(int8 *)param_1 + (int)*(int8 *)(param_1 + 8),
(random_access_iterator_tag)lVar1);
auVar4 = std::string::find((char *)param_1,0x1020e4,0);
rVar2 = auVar4._8_4_;
if (auVar4._0_8_ == -1) {
uVar3 = 0;
}
else {
uVar3 = 0;
do {
std::__reverse<__normal_iterator<char*,std::string>>
((int)*(int8 *)param_1 + (int)uVar3,(int)*(int8 *)param_1 + auVar4._0_4_
,auVar4._8_4_);
uVar3 = auVar4._0_8_ + 1;
auVar4 = std::string::find((char *)param_1,0x1020e4,uVar3);
rVar2 = auVar4._8_4_;
} while (auVar4._0_8_ != -1);
}
std::__reverse<__normal_iterator<char*,std::string>>
((int)*(int8 *)param_1 + (int)uVar3,
(int)*(int8 *)param_1 + (int)*(int8 *)(param_1 + 8),rVar2);
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,414 | func0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <cassert>
| std::string func0(const std::string& s) {
std::string temp = s;
std::reverse(temp.begin(), temp.end());
size_t start = 0;
size_t end = temp.find(" ");
while (end != std::string::npos) {
std::reverse(temp.begin() + start, temp.begin() + end);
start = end + 1;
end = temp.find(" ", start);
}
std::reverse(temp.begin() + start, temp.end());
return temp;
}
| int main() {
assert(func0("python program") == "program python");
assert(func0("java language") == "language java");
assert(func0("indian man") == "man indian");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
mov %rdi,%r12
add $0x10,%rdi
push %rbp
push %rbx
sub $0x18,%rsp
mov 0x8(%rsi),%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov %rdi,(%r12)
mov (%rsi),%rbp
mov %rbp,%rax
add %r13,%rax
je 1531 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x41>
test %rbp,%rbp
je 16c2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1d2>
mov %r13,(%rsp)
cmp $0xf,%r13
ja 1688 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x198>
cmp $0x1,%r13
jne 1678 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x188>
movzbl 0x0(%rbp),%eax
mov %al,0x10(%r12)
mov %r13,0x8(%r12)
movb $0x0,(%rdi,%r13,1)
mov (%r12),%rdx
mov 0x8(%r12),%rax
add %rdx,%rax
cmp %rax,%rdx
je 159a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xaa>
sub $0x1,%rax
cmp %rdx,%rax
jbe 159a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xaa>
nopw %cs:0x0(%rax,%rax,1)
movzbl (%rdx),%ecx
movzbl (%rax),%esi
add $0x1,%rdx
sub $0x1,%rax
mov %sil,-0x1(%rdx)
mov %cl,0x1(%rax)
cmp %rax,%rdx
jb 1580 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x90>
mov $0x1,%ecx
xor %edx,%edx
lea 0xb5c(%rip),%rsi
xor %ebp,%ebp
mov %r12,%rdi
lea 0xb50(%rip),%rbx
callq 1190 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm@plt>
cmp $0xffffffffffffffff,%rax
je 1618 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x128>
mov (%r12),%rdx
lea (%rdx,%rax,1),%rcx
add %rbp,%rdx
cmp %rcx,%rdx
je 15fb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10b>
sub $0x1,%rcx
cmp %rdx,%rcx
jbe 15fb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10b>
nopl 0x0(%rax)
movzbl (%rdx),%esi
movzbl (%rcx),%edi
add $0x1,%rdx
sub $0x1,%rcx
mov %dil,-0x1(%rdx)
mov %sil,0x1(%rcx)
cmp %rdx,%rcx
ja 15e0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf0>
lea 0x1(%rax),%rbp
mov $0x1,%ecx
mov %rbx,%rsi
mov %r12,%rdi
mov %rbp,%rdx
callq 1190 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm@plt>
cmp $0xffffffffffffffff,%rax
jne 15c0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd0>
mov (%r12),%rax
mov 0x8(%r12),%rcx
lea (%rax,%rbp,1),%rdx
add %rax,%rcx
cmp %rcx,%rdx
je 165a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x16a>
lea -0x1(%rcx),%rax
cmp %rdx,%rax
jbe 165a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x16a>
nopw %cs:0x0(%rax,%rax,1)
movzbl (%rdx),%ecx
movzbl (%rax),%esi
add $0x1,%rdx
sub $0x1,%rax
mov %sil,-0x1(%rdx)
mov %cl,0x1(%rax)
cmp %rax,%rdx
jb 1640 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x150>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 16bd <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1cd>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
test %r13,%r13
je 1552 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x62>
jmp 16a5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1b5>
nopl 0x0(%rax,%rax,1)
mov %r12,%rdi
mov %rsp,%rsi
xor %edx,%edx
callq 11b0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,(%r12)
mov %rax,%rdi
mov (%rsp),%rax
mov %rax,0x10(%r12)
mov %r13,%rdx
mov %rbp,%rsi
callq 1140 <memcpy@plt>
mov (%rsp),%r13
mov (%r12),%rdi
jmpq 1552 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x62>
callq 1170 <__stack_chk_fail@plt>
lea 0x93f(%rip),%rdi
callq 1130 <_ZSt19__throw_logic_errorPKc@plt>
xchg %ax,%ax
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r12
push rbp
mov rbp, rdi
add rdi, 10h
push rbx
sub rsp, 10h
mov rbx, [rsi+8]
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
mov [rbp+0], rdi
mov r12, [rsi]
mov [rsp+28h+var_28], rbx
cmp rbx, 0Fh
ja loc_15A0
cmp rbx, 1
jnz loc_1595
movzx eax, byte ptr [r12]
mov [rbp+10h], al
loc_148E:
mov [rbp+8], rbx
mov byte ptr [rdi+rbx], 0
mov rdx, [rbp+0]
mov rax, [rbp+8]
add rax, rdx
cmp rdx, rax
jz short loc_14CA
sub rax, 1
cmp rdx, rax
jnb short loc_14CA
nop
loc_14B0:
movzx ecx, byte ptr [rdx]
movzx esi, byte ptr [rax]
add rdx, 1
sub rax, 1
mov [rdx-1], sil
mov [rax+1], cl
cmp rdx, rax
jb short loc_14B0
loc_14CA:
lea rbx, unk_2004
xor edx, edx
mov rdi, rbp
xor r12d, r12d
mov ecx, 1
mov rsi, rbx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_1548
nop dword ptr [rax+00h]
loc_14F0:
mov rdx, [rbp+0]
lea rcx, [rdx+rax]
add rdx, r12
cmp rdx, rcx
jz short loc_152B
sub rcx, 1
cmp rdx, rcx
jnb short loc_152B
nop dword ptr [rax+00000000h]
loc_1510:
movzx esi, byte ptr [rdx]
movzx edi, byte ptr [rcx]
add rdx, 1
sub rcx, 1
mov [rdx-1], dil
mov [rcx+1], sil
cmp rdx, rcx
jb short loc_1510
loc_152B:
lea r12, [rax+1]
mov ecx, 1
mov rsi, rbx
mov rdi, rbp
mov rdx, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_14F0
loc_1548:
mov rax, [rbp+0]
mov rdx, [rbp+8]
add rdx, rax
add rax, r12
cmp rax, rdx
jnz short loc_1570
jmp short loc_1579
loc_1560:
movzx ecx, byte ptr [rax]
movzx esi, byte ptr [rdx]
add rax, 1
mov [rax-1], sil
mov [rdx], cl
loc_1570:
sub rdx, 1
cmp rax, rdx
jb short loc_1560
loc_1579:
mov rax, [rsp+28h+var_20]
sub rax, fs:28h
jnz short loc_15D4
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
retn
loc_1595:
test rbx, rbx
jz loc_148E
jmp short loc_15BC
loc_15A0:
mov rdi, rbp
mov rsi, rsp
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rbp+0], rax
mov rdi, rax; dest
mov rax, [rsp+28h+var_28]
mov [rbp+10h], rax
loc_15BC:
mov rdx, rbx; n
mov rsi, r12; src
call _memcpy
mov rbx, [rsp+28h+var_28]
mov rdi, [rbp+0]
jmp loc_148E
loc_15D4:
call ___stack_chk_fail | long long * func0(long long *a1, long long a2)
{
void *v3; // rdi
size_t v4; // rbx
_BYTE *v5; // r12
char *v6; // rdx
long long v7; // rax
char *i; // rax
char v9; // cl
char v10; // si
long long v11; // r12
long long j; // rax
char *v13; // rcx
char *v14; // rdx
char *k; // rcx
char v16; // si
char v17; // di
char *v18; // rdx
char *v19; // rax
char v20; // cl
long long v22; // rax
_QWORD v23[5]; // [rsp+0h] [rbp-28h] BYREF
v3 = a1 + 2;
v4 = *(_QWORD *)(a2 + 8);
v23[1] = __readfsqword(0x28u);
*a1 = (long long)v3;
v5 = *(_BYTE **)a2;
v23[0] = v4;
if ( v4 > 0xF )
{
v22 = std::string::_M_create(a1, v23, 0LL);
*a1 = v22;
v3 = (void *)v22;
a1[2] = v23[0];
goto LABEL_20;
}
if ( v4 != 1 )
{
if ( !v4 )
goto LABEL_4;
LABEL_20:
memcpy(v3, v5, v4);
v4 = v23[0];
v3 = (void *)*a1;
goto LABEL_4;
}
*((_BYTE *)a1 + 16) = *v5;
LABEL_4:
a1[1] = v4;
*((_BYTE *)v3 + v4) = 0;
v6 = (char *)*a1;
v7 = *a1 + a1[1];
if ( *a1 != v7 )
{
for ( i = (char *)(v7 - 1); v6 < i; i[1] = v9 )
{
v9 = *v6;
v10 = *i;
++v6;
--i;
*(v6 - 1) = v10;
}
}
v11 = 0LL;
for ( j = std::string::find(a1, &unk_2004, 0LL, 1LL); j != -1; j = std::string::find(a1, &unk_2004, j + 1, 1LL) )
{
v13 = (char *)(*a1 + j);
v14 = (char *)(v11 + *a1);
if ( v14 != v13 )
{
for ( k = v13 - 1; v14 < k; k[1] = v16 )
{
v16 = *v14;
v17 = *k;
++v14;
--k;
*(v14 - 1) = v17;
}
}
v11 = j + 1;
}
v18 = (char *)(*a1 + a1[1]);
v19 = (char *)(v11 + *a1);
if ( v19 != v18 )
{
while ( v19 < --v18 )
{
v20 = *v19++;
*(v19 - 1) = *v18;
*v18 = v20;
}
}
return a1;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDI
ADD RDI,0x10
PUSH RBX
SUB RSP,0x10
MOV RBX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RBP],RDI
MOV R12,qword ptr [RSI]
MOV qword ptr [RSP],RBX
CMP RBX,0xf
JA 0x001015a0
CMP RBX,0x1
JNZ 0x00101595
MOVZX EAX,byte ptr [R12]
MOV byte ptr [RBP + 0x10],AL
LAB_0010148e:
MOV qword ptr [RBP + 0x8],RBX
MOV byte ptr [RDI + RBX*0x1],0x0
MOV RDX,qword ptr [RBP]
MOV RAX,qword ptr [RBP + 0x8]
ADD RAX,RDX
CMP RDX,RAX
JZ 0x001014ca
SUB RAX,0x1
CMP RDX,RAX
JNC 0x001014ca
NOP
LAB_001014b0:
MOVZX ECX,byte ptr [RDX]
MOVZX ESI,byte ptr [RAX]
ADD RDX,0x1
SUB RAX,0x1
MOV byte ptr [RDX + -0x1],SIL
MOV byte ptr [RAX + 0x1],CL
CMP RDX,RAX
JC 0x001014b0
LAB_001014ca:
LEA RBX,[0x102004]
XOR EDX,EDX
MOV RDI,RBP
XOR R12D,R12D
MOV ECX,0x1
MOV RSI,RBX
CALL 0x00101150
CMP RAX,-0x1
JZ 0x00101548
NOP dword ptr [RAX]
LAB_001014f0:
MOV RDX,qword ptr [RBP]
LEA RCX,[RDX + RAX*0x1]
ADD RDX,R12
CMP RDX,RCX
JZ 0x0010152b
SUB RCX,0x1
CMP RDX,RCX
JNC 0x0010152b
NOP dword ptr [RAX]
LAB_00101510:
MOVZX ESI,byte ptr [RDX]
MOVZX EDI,byte ptr [RCX]
ADD RDX,0x1
SUB RCX,0x1
MOV byte ptr [RDX + -0x1],DIL
MOV byte ptr [RCX + 0x1],SIL
CMP RDX,RCX
JC 0x00101510
LAB_0010152b:
LEA R12,[RAX + 0x1]
MOV ECX,0x1
MOV RSI,RBX
MOV RDI,RBP
MOV RDX,R12
CALL 0x00101150
CMP RAX,-0x1
JNZ 0x001014f0
LAB_00101548:
MOV RAX,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
ADD RDX,RAX
ADD RAX,R12
CMP RAX,RDX
JNZ 0x00101570
JMP 0x00101579
LAB_00101560:
MOVZX ECX,byte ptr [RAX]
MOVZX ESI,byte ptr [RDX]
ADD RAX,0x1
MOV byte ptr [RAX + -0x1],SIL
MOV byte ptr [RDX],CL
LAB_00101570:
SUB RDX,0x1
CMP RAX,RDX
JC 0x00101560
LAB_00101579:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001015d4
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
RET
LAB_00101595:
TEST RBX,RBX
JZ 0x0010148e
JMP 0x001015bc
LAB_001015a0:
MOV RDI,RBP
MOV RSI,RSP
XOR EDX,EDX
CALL 0x00101170
MOV qword ptr [RBP],RAX
MOV RDI,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RBP + 0x10],RAX
LAB_001015bc:
MOV RDX,RBX
MOV RSI,R12
CALL 0x00101120
MOV RBX,qword ptr [RSP]
MOV RDI,qword ptr [RBP]
JMP 0x0010148e
LAB_001015d4:
CALL 0x00101130 | /* func0(std::string const&) */
string * func0(string *param_1)
{
int uVar1;
string *__src;
int *puVar2;
long lVar3;
int *puVar4;
int *puVar5;
int *puVar6;
int8 *in_RSI;
string *__dest;
ulong uVar7;
long in_FS_OFFSET;
ulong local_28;
long local_20;
__dest = param_1 + 0x10;
uVar7 = in_RSI[1];
local_20 = *(long *)(in_FS_OFFSET + 0x28);
*(string **)param_1 = __dest;
__src = (string *)*in_RSI;
local_28 = uVar7;
if (uVar7 < 0x10) {
if (uVar7 == 1) {
param_1[0x10] = *__src;
goto LAB_0010148e;
}
if (uVar7 == 0) goto LAB_0010148e;
}
else {
__dest = (string *)std::string::_M_create((ulong *)param_1,(ulong)&local_28);
*(string **)param_1 = __dest;
*(ulong *)(param_1 + 0x10) = local_28;
}
memcpy(__dest,__src,uVar7);
__dest = *(string **)param_1;
LAB_0010148e:
*(ulong *)(param_1 + 8) = local_28;
__dest[local_28] = (string)0x0;
puVar4 = *(int **)param_1;
puVar2 = puVar4 + *(long *)(param_1 + 8);
if ((puVar4 != puVar2) && (puVar5 = puVar2 + -1, puVar4 < puVar2 + -1)) {
do {
uVar1 = *puVar4;
puVar6 = puVar4 + 1;
puVar2 = puVar5 + -1;
*puVar4 = *puVar5;
*puVar5 = uVar1;
puVar5 = puVar2;
puVar4 = puVar6;
} while (puVar6 < puVar2);
}
uVar7 = 0;
lVar3 = std::string::find((char *)param_1,0x102004,0);
while (lVar3 != -1) {
puVar4 = (int *)(*(long *)param_1 + lVar3);
puVar2 = (int *)(*(long *)param_1 + uVar7);
if ((puVar2 != puVar4) && (puVar4 = puVar4 + -1, puVar2 < puVar4)) {
do {
uVar1 = *puVar2;
puVar6 = puVar2 + 1;
puVar5 = puVar4 + -1;
*puVar2 = *puVar4;
*puVar4 = uVar1;
puVar4 = puVar5;
puVar2 = puVar6;
} while (puVar6 < puVar5);
}
uVar7 = lVar3 + 1;
lVar3 = std::string::find((char *)param_1,0x102004,uVar7);
}
puVar2 = (int *)(*(long *)(param_1 + 8) + *(long *)param_1);
puVar4 = (int *)(*(long *)param_1 + uVar7);
if (puVar4 != puVar2) {
for (; puVar2 = puVar2 + -1, puVar4 < puVar2; puVar4 = puVar4 + 1) {
uVar1 = *puVar4;
*puVar4 = *puVar2;
*puVar2 = uVar1;
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,415 | func0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <cassert>
| std::string func0(const std::string& s) {
std::string temp = s;
std::reverse(temp.begin(), temp.end());
size_t start = 0;
size_t end = temp.find(" ");
while (end != std::string::npos) {
std::reverse(temp.begin() + start, temp.begin() + end);
start = end + 1;
end = temp.find(" ", start);
}
std::reverse(temp.begin() + start, temp.end());
return temp;
}
| int main() {
assert(func0("python program") == "program python");
assert(func0("java language") == "language java");
assert(func0("indian man") == "man indian");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
mov %rdi,%r12
add $0x10,%rdi
push %rbp
push %rbx
sub $0x18,%rsp
mov 0x8(%rsi),%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov %rdi,(%r12)
mov (%rsi),%rbp
mov %rbp,%rax
add %r13,%rax
je 1531 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x41>
test %rbp,%rbp
je 16c2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1d2>
mov %r13,(%rsp)
cmp $0xf,%r13
ja 1688 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x198>
cmp $0x1,%r13
jne 1678 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x188>
movzbl 0x0(%rbp),%eax
mov %al,0x10(%r12)
mov %r13,0x8(%r12)
movb $0x0,(%rdi,%r13,1)
mov (%r12),%rdx
mov 0x8(%r12),%rax
add %rdx,%rax
cmp %rax,%rdx
je 159a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xaa>
sub $0x1,%rax
cmp %rdx,%rax
jbe 159a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xaa>
nopw %cs:0x0(%rax,%rax,1)
movzbl (%rdx),%ecx
movzbl (%rax),%esi
add $0x1,%rdx
sub $0x1,%rax
mov %sil,-0x1(%rdx)
mov %cl,0x1(%rax)
cmp %rax,%rdx
jb 1580 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x90>
mov $0x1,%ecx
xor %edx,%edx
lea 0xb5c(%rip),%rsi
xor %ebp,%ebp
mov %r12,%rdi
lea 0xb50(%rip),%rbx
callq 1190 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm@plt>
cmp $0xffffffffffffffff,%rax
je 1618 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x128>
mov (%r12),%rdx
lea (%rdx,%rax,1),%rcx
add %rbp,%rdx
cmp %rcx,%rdx
je 15fb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10b>
sub $0x1,%rcx
cmp %rdx,%rcx
jbe 15fb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10b>
nopl 0x0(%rax)
movzbl (%rdx),%esi
movzbl (%rcx),%edi
add $0x1,%rdx
sub $0x1,%rcx
mov %dil,-0x1(%rdx)
mov %sil,0x1(%rcx)
cmp %rdx,%rcx
ja 15e0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf0>
lea 0x1(%rax),%rbp
mov $0x1,%ecx
mov %rbx,%rsi
mov %r12,%rdi
mov %rbp,%rdx
callq 1190 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm@plt>
cmp $0xffffffffffffffff,%rax
jne 15c0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd0>
mov (%r12),%rax
mov 0x8(%r12),%rcx
lea (%rax,%rbp,1),%rdx
add %rax,%rcx
cmp %rcx,%rdx
je 165a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x16a>
lea -0x1(%rcx),%rax
cmp %rdx,%rax
jbe 165a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x16a>
nopw %cs:0x0(%rax,%rax,1)
movzbl (%rdx),%ecx
movzbl (%rax),%esi
add $0x1,%rdx
sub $0x1,%rax
mov %sil,-0x1(%rdx)
mov %cl,0x1(%rax)
cmp %rdx,%rax
ja 1640 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x150>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 16bd <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1cd>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
test %r13,%r13
je 1552 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x62>
jmp 16a5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1b5>
nopl 0x0(%rax,%rax,1)
mov %r12,%rdi
mov %rsp,%rsi
xor %edx,%edx
callq 11b0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,(%r12)
mov %rax,%rdi
mov (%rsp),%rax
mov %rax,0x10(%r12)
mov %r13,%rdx
mov %rbp,%rsi
callq 1140 <memcpy@plt>
mov (%rsp),%r13
mov (%r12),%rdi
jmpq 1552 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x62>
callq 1170 <__stack_chk_fail@plt>
lea 0x93f(%rip),%rdi
callq 1130 <_ZSt19__throw_logic_errorPKc@plt>
xchg %ax,%ax
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r12
push rbp
mov rbp, rdi
add rdi, 10h
push rbx
sub rsp, 10h
mov rbx, [rsi+8]
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
mov [rbp+0], rdi
mov r12, [rsi]
mov [rsp+28h+var_28], rbx
cmp rbx, 0Fh
ja loc_15A0
cmp rbx, 1
jnz loc_1595
movzx eax, byte ptr [r12]
mov [rbp+10h], al
loc_148E:
mov [rbp+8], rbx
mov byte ptr [rdi+rbx], 0
mov rdx, [rbp+0]
mov rax, [rbp+8]
add rax, rdx
cmp rdx, rax
jz short loc_14CA
sub rax, 1
cmp rdx, rax
jnb short loc_14CA
nop
loc_14B0:
movzx ecx, byte ptr [rdx]
movzx esi, byte ptr [rax]
add rdx, 1
sub rax, 1
mov [rdx-1], sil
mov [rax+1], cl
cmp rdx, rax
jb short loc_14B0
loc_14CA:
lea rbx, unk_2004
xor edx, edx
mov rdi, rbp
xor r12d, r12d
mov ecx, 1
mov rsi, rbx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_1548
nop dword ptr [rax+00h]
loc_14F0:
mov rdx, [rbp+0]
lea rcx, [rdx+rax]
add rdx, r12
cmp rdx, rcx
jz short loc_152B
sub rcx, 1
cmp rdx, rcx
jnb short loc_152B
nop dword ptr [rax+00000000h]
loc_1510:
movzx esi, byte ptr [rdx]
movzx edi, byte ptr [rcx]
add rdx, 1
sub rcx, 1
mov [rdx-1], dil
mov [rcx+1], sil
cmp rdx, rcx
jb short loc_1510
loc_152B:
lea r12, [rax+1]
mov ecx, 1
mov rsi, rbx
mov rdi, rbp
mov rdx, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_14F0
loc_1548:
mov rax, [rbp+0]
mov rdx, [rbp+8]
add rdx, rax
add rax, r12
cmp rax, rdx
jnz short loc_1570
jmp short loc_1579
loc_1560:
movzx ecx, byte ptr [rax]
movzx esi, byte ptr [rdx]
add rax, 1
mov [rax-1], sil
mov [rdx], cl
loc_1570:
sub rdx, 1
cmp rax, rdx
jb short loc_1560
loc_1579:
mov rax, [rsp+28h+var_20]
sub rax, fs:28h
jnz short loc_15D4
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
retn
loc_1595:
test rbx, rbx
jz loc_148E
jmp short loc_15BC
loc_15A0:
mov rdi, rbp
mov rsi, rsp
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rbp+0], rax
mov rdi, rax; dest
mov rax, [rsp+28h+var_28]
mov [rbp+10h], rax
loc_15BC:
mov rdx, rbx; n
mov rsi, r12; src
call _memcpy
mov rbx, [rsp+28h+var_28]
mov rdi, [rbp+0]
jmp loc_148E
loc_15D4:
call ___stack_chk_fail | long long * func0(long long *a1, long long a2)
{
void *v3; // rdi
size_t v4; // rbx
_BYTE *v5; // r12
char *v6; // rdx
long long v7; // rax
char *i; // rax
char v9; // cl
char v10; // si
long long v11; // r12
long long j; // rax
char *v13; // rcx
char *v14; // rdx
char *k; // rcx
char v16; // si
char v17; // di
char *v18; // rdx
char *v19; // rax
char v20; // cl
long long v22; // rax
_QWORD v23[5]; // [rsp+0h] [rbp-28h] BYREF
v3 = a1 + 2;
v4 = *(_QWORD *)(a2 + 8);
v23[1] = __readfsqword(0x28u);
*a1 = (long long)v3;
v5 = *(_BYTE **)a2;
v23[0] = v4;
if ( v4 > 0xF )
{
v22 = std::string::_M_create(a1, v23, 0LL);
*a1 = v22;
v3 = (void *)v22;
a1[2] = v23[0];
goto LABEL_20;
}
if ( v4 != 1 )
{
if ( !v4 )
goto LABEL_4;
LABEL_20:
memcpy(v3, v5, v4);
v4 = v23[0];
v3 = (void *)*a1;
goto LABEL_4;
}
*((_BYTE *)a1 + 16) = *v5;
LABEL_4:
a1[1] = v4;
*((_BYTE *)v3 + v4) = 0;
v6 = (char *)*a1;
v7 = *a1 + a1[1];
if ( *a1 != v7 )
{
for ( i = (char *)(v7 - 1); v6 < i; i[1] = v9 )
{
v9 = *v6;
v10 = *i;
++v6;
--i;
*(v6 - 1) = v10;
}
}
v11 = 0LL;
for ( j = std::string::find(a1, &unk_2004, 0LL, 1LL); j != -1; j = std::string::find(a1, &unk_2004, j + 1, 1LL) )
{
v13 = (char *)(*a1 + j);
v14 = (char *)(v11 + *a1);
if ( v14 != v13 )
{
for ( k = v13 - 1; v14 < k; k[1] = v16 )
{
v16 = *v14;
v17 = *k;
++v14;
--k;
*(v14 - 1) = v17;
}
}
v11 = j + 1;
}
v18 = (char *)(*a1 + a1[1]);
v19 = (char *)(v11 + *a1);
if ( v19 != v18 )
{
while ( v19 < --v18 )
{
v20 = *v19++;
*(v19 - 1) = *v18;
*v18 = v20;
}
}
return a1;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDI
ADD RDI,0x10
PUSH RBX
SUB RSP,0x10
MOV RBX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RBP],RDI
MOV R12,qword ptr [RSI]
MOV qword ptr [RSP],RBX
CMP RBX,0xf
JA 0x001015a0
CMP RBX,0x1
JNZ 0x00101595
MOVZX EAX,byte ptr [R12]
MOV byte ptr [RBP + 0x10],AL
LAB_0010148e:
MOV qword ptr [RBP + 0x8],RBX
MOV byte ptr [RDI + RBX*0x1],0x0
MOV RDX,qword ptr [RBP]
MOV RAX,qword ptr [RBP + 0x8]
ADD RAX,RDX
CMP RDX,RAX
JZ 0x001014ca
SUB RAX,0x1
CMP RDX,RAX
JNC 0x001014ca
NOP
LAB_001014b0:
MOVZX ECX,byte ptr [RDX]
MOVZX ESI,byte ptr [RAX]
ADD RDX,0x1
SUB RAX,0x1
MOV byte ptr [RDX + -0x1],SIL
MOV byte ptr [RAX + 0x1],CL
CMP RDX,RAX
JC 0x001014b0
LAB_001014ca:
LEA RBX,[0x102004]
XOR EDX,EDX
MOV RDI,RBP
XOR R12D,R12D
MOV ECX,0x1
MOV RSI,RBX
CALL 0x00101150
CMP RAX,-0x1
JZ 0x00101548
NOP dword ptr [RAX]
LAB_001014f0:
MOV RDX,qword ptr [RBP]
LEA RCX,[RDX + RAX*0x1]
ADD RDX,R12
CMP RDX,RCX
JZ 0x0010152b
SUB RCX,0x1
CMP RDX,RCX
JNC 0x0010152b
NOP dword ptr [RAX]
LAB_00101510:
MOVZX ESI,byte ptr [RDX]
MOVZX EDI,byte ptr [RCX]
ADD RDX,0x1
SUB RCX,0x1
MOV byte ptr [RDX + -0x1],DIL
MOV byte ptr [RCX + 0x1],SIL
CMP RDX,RCX
JC 0x00101510
LAB_0010152b:
LEA R12,[RAX + 0x1]
MOV ECX,0x1
MOV RSI,RBX
MOV RDI,RBP
MOV RDX,R12
CALL 0x00101150
CMP RAX,-0x1
JNZ 0x001014f0
LAB_00101548:
MOV RAX,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
ADD RDX,RAX
ADD RAX,R12
CMP RAX,RDX
JNZ 0x00101570
JMP 0x00101579
LAB_00101560:
MOVZX ECX,byte ptr [RAX]
MOVZX ESI,byte ptr [RDX]
ADD RAX,0x1
MOV byte ptr [RAX + -0x1],SIL
MOV byte ptr [RDX],CL
LAB_00101570:
SUB RDX,0x1
CMP RAX,RDX
JC 0x00101560
LAB_00101579:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001015d4
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
RET
LAB_00101595:
TEST RBX,RBX
JZ 0x0010148e
JMP 0x001015bc
LAB_001015a0:
MOV RDI,RBP
MOV RSI,RSP
XOR EDX,EDX
CALL 0x00101170
MOV qword ptr [RBP],RAX
MOV RDI,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RBP + 0x10],RAX
LAB_001015bc:
MOV RDX,RBX
MOV RSI,R12
CALL 0x00101120
MOV RBX,qword ptr [RSP]
MOV RDI,qword ptr [RBP]
JMP 0x0010148e
LAB_001015d4:
CALL 0x00101130 | /* func0(std::string const&) */
string * func0(string *param_1)
{
int uVar1;
string *__src;
int *puVar2;
long lVar3;
int *puVar4;
int *puVar5;
int *puVar6;
int8 *in_RSI;
string *__dest;
ulong uVar7;
long in_FS_OFFSET;
ulong local_28;
long local_20;
__dest = param_1 + 0x10;
uVar7 = in_RSI[1];
local_20 = *(long *)(in_FS_OFFSET + 0x28);
*(string **)param_1 = __dest;
__src = (string *)*in_RSI;
local_28 = uVar7;
if (uVar7 < 0x10) {
if (uVar7 == 1) {
param_1[0x10] = *__src;
goto LAB_0010148e;
}
if (uVar7 == 0) goto LAB_0010148e;
}
else {
__dest = (string *)std::string::_M_create((ulong *)param_1,(ulong)&local_28);
*(string **)param_1 = __dest;
*(ulong *)(param_1 + 0x10) = local_28;
}
memcpy(__dest,__src,uVar7);
__dest = *(string **)param_1;
LAB_0010148e:
*(ulong *)(param_1 + 8) = local_28;
__dest[local_28] = (string)0x0;
puVar4 = *(int **)param_1;
puVar2 = puVar4 + *(long *)(param_1 + 8);
if ((puVar4 != puVar2) && (puVar5 = puVar2 + -1, puVar4 < puVar2 + -1)) {
do {
uVar1 = *puVar4;
puVar6 = puVar4 + 1;
puVar2 = puVar5 + -1;
*puVar4 = *puVar5;
*puVar5 = uVar1;
puVar5 = puVar2;
puVar4 = puVar6;
} while (puVar6 < puVar2);
}
uVar7 = 0;
lVar3 = std::string::find((char *)param_1,0x102004,0);
while (lVar3 != -1) {
puVar4 = (int *)(*(long *)param_1 + lVar3);
puVar2 = (int *)(*(long *)param_1 + uVar7);
if ((puVar2 != puVar4) && (puVar4 = puVar4 + -1, puVar2 < puVar4)) {
do {
uVar1 = *puVar2;
puVar6 = puVar2 + 1;
puVar5 = puVar4 + -1;
*puVar2 = *puVar4;
*puVar4 = uVar1;
puVar4 = puVar5;
puVar2 = puVar6;
} while (puVar6 < puVar5);
}
uVar7 = lVar3 + 1;
lVar3 = std::string::find((char *)param_1,0x102004,uVar7);
}
puVar2 = (int *)(*(long *)(param_1 + 8) + *(long *)param_1);
puVar4 = (int *)(*(long *)param_1 + uVar7);
if (puVar4 != puVar2) {
for (; puVar2 = puVar2 + -1, puVar4 < puVar2; puVar4 = puVar4 + 1) {
uVar1 = *puVar4;
*puVar4 = *puVar2;
*puVar2 = uVar1;
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,416 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
} else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jle 11d3 <_Z5func0i+0x4a>
movl $0x2,-0x4(%rbp)
mov -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x4(%rbp)
jg 11cc <_Z5func0i+0x43>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 11c6 <_Z5func0i+0x3d>
mov $0x0,%eax
jmp 11d8 <_Z5func0i+0x4f>
addl $0x1,-0x4(%rbp)
jmp 11a1 <_Z5func0i+0x18>
mov $0x1,%eax
jmp 11d8 <_Z5func0i+0x4f>
mov $0x0,%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jle short loc_1193
mov [rbp+var_4], 2
jmp short loc_117B
loc_1163:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1177
mov eax, 0
jmp short loc_1198
loc_1177:
add [rbp+var_4], 1
loc_117B:
mov eax, [rbp+var_14]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_4], eax
jle short loc_1163
mov eax, 1
jmp short loc_1198
loc_1193:
mov eax, 0
loc_1198:
pop rbp
retn | long long func0(int a1)
{
int i; // [rsp+10h] [rbp-4h]
if ( a1 <= 0 )
return 0LL;
for ( i = 2; i <= a1 / 2; ++i )
{
if ( !(a1 % i) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JLE 0x00101193
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0010117b
LAB_00101163:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101177
MOV EAX,0x0
JMP 0x00101198
LAB_00101177:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010117b:
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x4],EAX
JLE 0x00101163
MOV EAX,0x1
JMP 0x00101198
LAB_00101193:
MOV EAX,0x0
LAB_00101198:
POP RBP
RET | /* func0(int) */
int8 func0(int param_1)
{
int8 uVar1;
int local_c;
if (param_1 < 1) {
uVar1 = 0;
}
else {
for (local_c = 2; local_c <= param_1 / 2; local_c = local_c + 1) {
if (param_1 % local_c == 0) {
return 0;
}
}
uVar1 = 1;
}
return uVar1;
} |
2,417 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
} else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov $0x0,%eax
test %edi,%edi
jle 11c4 <_Z5func0i+0x3b>
mov %edi,%esi
shr $0x1f,%esi
add %edi,%esi
sar %esi
cmp $0x3,%edi
jle 11cb <_Z5func0i+0x42>
test $0x1,%dil
je 11d1 <_Z5func0i+0x48>
mov $0x2,%ecx
add $0x1,%ecx
cmp %esi,%ecx
jg 11c5 <_Z5func0i+0x3c>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 11af <_Z5func0i+0x26>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| _Z5func0i:
endbr64
mov eax, 0
test edi, edi
jle short locret_1184
mov esi, edi
shr esi, 1Fh
add esi, edi
sar esi, 1
cmp edi, 3
jle short loc_118B
test dil, 1
jz short loc_1191
mov ecx, 2
loc_116F:
add ecx, 1
cmp ecx, esi
jg short loc_1185
mov eax, edi
cdq
idiv ecx
test edx, edx
jnz short loc_116F
mov eax, 0
locret_1184:
retn
loc_1185:
mov eax, 1
retn
loc_118B:
mov eax, 1
retn
loc_1191:
mov eax, 0
retn | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 <= 3 )
{
return 1LL;
}
else if ( (a1 & 1) != 0 )
{
v2 = 2;
while ( ++v2 <= a1 / 2 )
{
if ( !(a1 % v2) )
return 0LL;
}
return 1LL;
}
else
{
return 0LL;
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x0
TEST EDI,EDI
JLE 0x00101184
MOV ESI,EDI
SHR ESI,0x1f
ADD ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x0010118b
TEST DIL,0x1
JZ 0x00101191
MOV ECX,0x2
LAB_0010116f:
ADD ECX,0x1
CMP ECX,ESI
JG 0x00101185
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010116f
MOV EAX,0x0
LAB_00101184:
RET
LAB_00101185:
MOV EAX,0x1
RET
LAB_0010118b:
MOV EAX,0x1
RET
LAB_00101191:
MOV EAX,0x0
RET | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
if (0 < param_1) {
if (param_1 < 4) {
return 1;
}
if ((param_1 & 1U) == 0) {
return 0;
}
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if (param_1 / 2 < iVar1) {
return 1;
}
} while (param_1 % iVar1 != 0);
}
return 0;
} |
2,418 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
} else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O2 | cpp | func0(int):
endbr64
xor %eax,%eax
test %edi,%edi
jle 1202 <_Z5func0i+0x42>
mov %edi,%esi
sar %esi
cmp $0x3,%edi
jle 11f8 <_Z5func0i+0x38>
test $0x1,%dil
je 1202 <_Z5func0i+0x42>
add $0x1,%esi
mov $0x2,%ecx
jmp 11f1 <_Z5func0i+0x31>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1200 <_Z5func0i+0x40>
add $0x1,%ecx
cmp %esi,%ecx
jne 11e8 <_Z5func0i+0x28>
mov $0x1,%eax
retq
xchg %ax,%ax
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0i:
endbr64
xor eax, eax
test edi, edi
jle short locret_1182
mov esi, edi
sar esi, 1
cmp edi, 3
jle short loc_1178
test dil, 1
jz short locret_1182
add esi, 1
mov ecx, 2
jmp short loc_1171
loc_1168:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1180
loc_1171:
add ecx, 1
cmp ecx, esi
jnz short loc_1168
loc_1178:
mov eax, 1
retn
loc_1180:
xor eax, eax
locret_1182:
retn | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 > 3 )
{
if ( (a1 & 1) == 0 )
return result;
v2 = 2;
while ( ++v2 != (a1 >> 1) + 1 )
{
if ( !(a1 % v2) )
return 0LL;
}
}
return 1LL;
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x00101182
MOV ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x00101178
TEST DIL,0x1
JZ 0x00101182
ADD ESI,0x1
MOV ECX,0x2
JMP 0x00101171
LAB_00101168:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101171:
ADD ECX,0x1
CMP ECX,ESI
JNZ 0x00101168
LAB_00101178:
MOV EAX,0x1
RET
LAB_00101180:
XOR EAX,EAX
LAB_00101182:
RET | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
if (0 < param_1) {
if (param_1 < 4) {
return 1;
}
if ((param_1 & 1U) != 0) {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if (iVar1 == (param_1 >> 1) + 1) {
return 1;
}
} while (param_1 % iVar1 != 0);
}
}
return 0;
} |
2,419 | func0 |
#include <iostream>
#include <assert.h>
| bool func0(int num) {
if (num >= 1) {
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
return false;
}
}
return true;
} else {
return false;
}
}
| int main() {
assert(func0(13) == true);
assert(func0(7) == true);
assert(func0(-1010) == false);
return 0;
}
| O3 | cpp | func0(int):
endbr64
xor %eax,%eax
test %edi,%edi
jle 1202 <_Z5func0i+0x42>
mov %edi,%esi
sar %esi
cmp $0x3,%edi
jle 11f8 <_Z5func0i+0x38>
test $0x1,%dil
je 1202 <_Z5func0i+0x42>
add $0x1,%esi
mov $0x2,%ecx
jmp 11f1 <_Z5func0i+0x31>
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1200 <_Z5func0i+0x40>
add $0x1,%ecx
cmp %esi,%ecx
jne 11e8 <_Z5func0i+0x28>
mov $0x1,%eax
retq
xchg %ax,%ax
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0i:
endbr64
xor eax, eax
test edi, edi
jle short locret_1182
mov esi, edi
sar esi, 1
cmp edi, 3
jle short loc_1178
test dil, 1
jz short locret_1182
add esi, 1
mov ecx, 2
jmp short loc_1171
loc_1168:
mov eax, edi
cdq
idiv ecx
test edx, edx
jz short loc_1180
loc_1171:
add ecx, 1
cmp ecx, esi
jnz short loc_1168
loc_1178:
mov eax, 1
retn
loc_1180:
xor eax, eax
locret_1182:
retn | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = 0LL;
if ( a1 > 0 )
{
if ( a1 > 3 )
{
if ( (a1 & 1) == 0 )
return result;
v2 = 2;
while ( ++v2 != (a1 >> 1) + 1 )
{
if ( !(a1 % v2) )
return 0LL;
}
}
return 1LL;
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JLE 0x00101182
MOV ESI,EDI
SAR ESI,0x1
CMP EDI,0x3
JLE 0x00101178
TEST DIL,0x1
JZ 0x00101182
ADD ESI,0x1
MOV ECX,0x2
JMP 0x00101171
LAB_00101168:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101180
LAB_00101171:
ADD ECX,0x1
CMP ECX,ESI
JNZ 0x00101168
LAB_00101178:
MOV EAX,0x1
RET
LAB_00101180:
XOR EAX,EAX
LAB_00101182:
RET | /* func0(int) */
int8 func0(int param_1)
{
int iVar1;
if (0 < param_1) {
if (param_1 < 4) {
return 1;
}
if ((param_1 & 1U) != 0) {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if (iVar1 == (param_1 >> 1) + 1) {
return 1;
}
} while (param_1 % iVar1 != 0);
}
}
return 0;
} |
2,420 | func0 |
#include <cmath>
#include <cassert>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O0 | cpp | func0(double):
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf65(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| _Z5func0d:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_20A8
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 0.0174532925199433 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x001020a8]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
POP RBP
RET | /* func0(double) */
double func0(double param_1)
{
return DAT_001020a8 * param_1;
} |
2,421 | func0 |
#include <cmath>
#include <cassert>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O1 | cpp | func0(double):
endbr64
mulsd 0xed3(%rip),%xmm0
retq
| _Z5func0d:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 0.0174532925199433;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double) */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
2,422 | func0 |
#include <cmath>
#include <cassert>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O2 | cpp | func0(double):
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| _Z5func0d:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 0.0174532925199433;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double) */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
2,423 | func0 |
#include <cmath>
#include <cassert>
| double func0(double degree) {
double radian = degree * (M_PI / 180);
return radian;
}
| int main() {
assert(func0(90) == 1.5707963267948966);
assert(func0(60) == 1.0471975511965976);
assert(func0(120) == 2.0943951023931953);
return 0;
}
| O3 | cpp | func0(double):
endbr64
mulsd 0xebc(%rip),%xmm0
retq
nopl (%rax)
| _Z5func0d:
endbr64
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * 0.0174532925199433;
} | func0:
ENDBR64
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double) */
double func0(double param_1)
{
return param_1 * _DAT_00102008;
} |
2,424 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::tuple<std::string, int, int> func0(const std::string& text, const std::string& pattern) {
std::smatch match;
std::regex re(pattern);
if (std::regex_search(text, match, re)) {
return {match.str(), match.position(), match.position() + match.length()};
}
throw std::runtime_error("Pattern not found");
}
| int main() {
assert((func0("The quick brown fox jumps over the lazy dog.", "fox") == std::make_tuple("fox", 16, 19)));
assert((func0("Its been a very crazy procedure right", "crazy") == std::make_tuple("crazy", 16, 21)));
assert((func0("Hardest choices required strongest will", "will") == std::make_tuple("will", 35, 39)));
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0xa0,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %rdx,-0xa8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x80(%rbp),%rax
mov %rax,%rdi
callq 7572 <_ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEEC1Ev>
mov -0xa8(%rbp),%rcx
lea -0x60(%rbp),%rax
mov $0x10,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 761c <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC1ISt11char_traitsIcESaIcEEERKNS_12basic_stringIcT_T0_EENSt15regex_constants18syntax_option_typeE>
lea -0x60(%rbp),%rdx
lea -0x80(%rbp),%rsi
mov -0xa0(%rbp),%rax
mov $0x0,%ecx
mov %rax,%rdi
callq 76f5 <_ZSt12regex_searchISt11char_traitsIcESaIcESaINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS3_12basic_stringIcS1_S2_EEEEEEEcNS3_12regex_traitsIcEEEbRKNS9_IT2_T_T0_EERNS3_13match_resultsINSJ_14const_iteratorET1_EERKNS3_11basic_regexISG_T3_EENSt15regex_constants15match_flag_typeE>
test %al,%al
je 5de8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x13f>
lea -0x40(%rbp),%rax
lea -0x80(%rbp),%rcx
mov $0x0,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 7752 <_ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE3strEm>
lea -0x80(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 77b8 <_ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE8positionEm>
mov %rax,-0x90(%rbp)
lea -0x80(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 77b8 <_ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE8positionEm>
mov %rax,%rbx
lea -0x80(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 77f8 <_ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE6lengthEm>
add %rbx,%rax
mov %rax,-0x88(%rbp)
lea -0x88(%rbp),%rcx
lea -0x90(%rbp),%rdx
lea -0x40(%rbp),%rsi
mov -0x98(%rbp),%rax
mov %rax,%rdi
callq 782a <_ZNSt5tupleIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiiEEC1IJS5_llELb1EEEDpOT_>
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 57c0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 76c2 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
lea -0x80(%rbp),%rax
mov %rax,%rdi
callq 72e8 <_ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED1Ev>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 5e7e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1d5>
jmpq 5e79 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1d0>
mov $0x10,%edi
callq 5740 <__cxa_allocate_exception@plt>
mov %rax,%rbx
lea 0x2d28d(%rip),%rsi
mov %rbx,%rdi
callq 56e0 <_ZNSt13runtime_errorC1EPKc@plt>
mov 0x451b5(%rip),%rax
mov %rax,%rdx
lea 0x44aeb(%rip),%rsi
mov %rbx,%rdi
callq 5af0 <__cxa_throw@plt>
endbr64
mov %rax,%rbx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 57c0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
jmp 5e4d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1a4>
endbr64
mov %rax,%r12
mov %rbx,%rdi
callq 5860 <__cxa_free_exception@plt>
mov %r12,%rbx
jmp 5e4d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1a4>
endbr64
mov %rax,%rbx
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 76c2 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
jmp 5e62 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1b9>
endbr64
mov %rax,%rbx
lea -0x80(%rbp),%rax
mov %rax,%rdi
callq 72e8 <_ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 5b20 <_Unwind_Resume@plt>
callq 5980 <__stack_chk_fail@plt>
mov -0x98(%rbp),%rax
add $0xa0,%rsp
pop %rbx
pop %r12
pop %rbp
retq
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 0A0h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov [rbp+var_A8], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_80]
mov rdi, rax
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEEC2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::match_results(void)
mov rcx, [rbp+var_A8]
lea rax, [rbp+var_60]
mov edx, 10h
mov rsi, rcx
mov rdi, rax
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2ISt11char_traitsIcESaIcEEERKNS_12basic_stringIcT_T0_EENSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex<std::char_traits<char>,std::allocator<char>>(std::string const&,std::regex_constants::syntax_option_type)
lea rdx, [rbp+var_60]
lea rsi, [rbp+var_80]
mov rax, [rbp+var_A0]
mov ecx, 0
mov rdi, rax
call _ZSt12regex_searchISt11char_traitsIcESaIcESaINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS3_12basic_stringIcS1_S2_EEEEEEEcNS3_12regex_traitsIcEEEbRKNS9_IT2_T_T0_EERNS3_13match_resultsINSJ_14const_iteratorET1_EERKNS3_11basic_regexISG_T3_EENSt15regex_constants15match_flag_typeE; std::regex_search<std::char_traits<char>,std::allocator<char>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(std::string const&,std::match_results<std::string::const_iterator> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
test al, al
jz loc_4C87
lea rax, [rbp+var_40]
lea rcx, [rbp+var_80]
mov edx, 0
mov rsi, rcx
mov rdi, rax
call _ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE3strEm; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::str(ulong)
lea rax, [rbp+var_80]
mov esi, 0
mov rdi, rax
call _ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE8positionEm; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::position(ulong)
mov [rbp+var_90], rax
lea rax, [rbp+var_80]
mov esi, 0
mov rdi, rax
call _ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE8positionEm; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::position(ulong)
mov rbx, rax
lea rax, [rbp+var_80]
mov esi, 0
mov rdi, rax
call _ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE6lengthEm; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::length(ulong)
add rax, rbx
mov [rbp+var_88], rax
lea rcx, [rbp+var_88]
lea rdx, [rbp+var_90]
lea rsi, [rbp+var_40]
mov rax, [rbp+var_98]
mov rdi, rax
call _ZNSt5tupleIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiiEEC2IJS5_llELb1ELb1EEEDpOT_; std::tuple<std::string,int,int>::tuple<std::string,long,long,true,true>(std::string,long,long &&)
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rax, [rbp+var_60]
mov rdi, rax
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
lea rax, [rbp+var_80]
mov rdi, rax
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results()
nop
mov rax, [rbp+var_18]
sub rax, fs:28h
jz loc_4D4B
jmp loc_4D46
loc_4C87:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rax, aPatternNotFoun; "Pattern not found"
mov rsi, rax; char *
mov rdi, rbx; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_4CBA
call ___stack_chk_fail
loc_4CBA:
mov rax, cs:_ZNSt13runtime_errorD1Ev_ptr
mov rdx, rax; void (*)(void *)
lea rax, _ZTISt13runtime_error@GLIBCXX_3_4
mov rsi, rax; lptinfo
mov rdi, rbx; void *
call ___cxa_throw
endbr64
mov rbx, rax
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_4D06
endbr64
mov r12, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rbx, r12
jmp short loc_4D06
endbr64
mov rbx, rax
loc_4D06:
lea rax, [rbp+var_60]
mov rdi, rax
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
jmp short loc_4D1B
endbr64
mov rbx, rax
loc_4D1B:
lea rax, [rbp+var_80]
mov rdi, rax
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_4D3E
call ___stack_chk_fail
loc_4D3E:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_4D46:
call ___stack_chk_fail
loc_4D4B:
mov rax, [rbp+var_98]
add rsp, 0A0h
pop rbx
pop r12
pop rbp
retn | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rbx
std::runtime_error *exception; // rbx
long long v7; // [rsp+20h] [rbp-90h] BYREF
long long v8; // [rsp+28h] [rbp-88h] BYREF
_BYTE v9[32]; // [rsp+30h] [rbp-80h] BYREF
_BYTE v10[32]; // [rsp+50h] [rbp-60h] BYREF
_BYTE v11[40]; // [rsp+70h] [rbp-40h] BYREF
unsigned long long v12; // [rsp+98h] [rbp-18h]
v12 = __readfsqword(0x28u);
std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::match_results(v9);
std::basic_regex<char,std::regex_traits<char>>::basic_regex<std::char_traits<char>,std::allocator<char>>(
v10,
a3,
16LL);
if ( !(unsigned __int8)std::regex_search<std::char_traits<char>,std::allocator<char>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
a2,
v9,
v10,
0LL) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Pattern not found");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::str(v11, v9, 0LL);
v7 = std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::position(v9, 0LL);
v3 = std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::position(v9, 0LL);
v8 = v3 + std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::length(v9, 0LL);
std::tuple<std::string,int,int>::tuple<std::string,long,long,true,true>(a1, v11, &v7, &v8);
std::string::~string(v11);
std::basic_regex<char,std::regex_traits<char>>::~basic_regex(v10);
std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results(v9);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV qword ptr [RBP + -0xa8],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x80]
MOV RDI,RAX
CALL 0x00106534
MOV RCX,qword ptr [RBP + -0xa8]
LEA RAX,[RBP + -0x60]
MOV EDX,0x10
MOV RSI,RCX
MOV RDI,RAX
LAB_00104ba1:
CALL 0x00106632
LEA RDX,[RBP + -0x60]
LEA RSI,[RBP + -0x80]
MOV RAX,qword ptr [RBP + -0xa0]
MOV ECX,0x0
MOV RDI,RAX
LAB_00104bbd:
CALL 0x00106719
TEST AL,AL
JZ 0x00104c87
LEA RAX,[RBP + -0x40]
LEA RCX,[RBP + -0x80]
MOV EDX,0x0
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00106776
LEA RAX,[RBP + -0x80]
MOV ESI,0x0
MOV RDI,RAX
LAB_00104bee:
CALL 0x001067dc
MOV qword ptr [RBP + -0x90],RAX
LEA RAX,[RBP + -0x80]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x001067dc
MOV RBX,RAX
LEA RAX,[RBP + -0x80]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00106862
ADD RAX,RBX
MOV qword ptr [RBP + -0x88],RAX
LEA RCX,[RBP + -0x88]
LEA RDX,[RBP + -0x90]
LEA RSI,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x98]
MOV RDI,RAX
CALL 0x00106894
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x001046e0
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x001066e6
LEA RAX,[RBP + -0x80]
MOV RDI,RAX
CALL 0x0010626a
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00104d4b
JMP 0x00104d46
LAB_00104c87:
MOV EDI,0x10
CALL 0x00104670
MOV RBX,RAX
LEA RAX,[0x133051]
MOV RSI,RAX
MOV RDI,RBX
LAB_00104ca1:
CALL 0x00104600
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00104cba
CALL 0x00104880
LAB_00104cba:
MOV RAX,qword ptr [0x00148fd0]
MOV RDX,RAX
LEA RAX,[0x148970]
MOV RSI,RAX
MOV RDI,RBX
LAB_00104cd1:
CALL 0x001049b0
LAB_00104d46:
CALL 0x00104880
LAB_00104d4b:
MOV RAX,qword ptr [RBP + -0x98]
ADD RSP,0xa0
POP RBX
POP R12
POP RBP
RET | /* func0(std::string const&, std::string const&) */
string * func0(string *param_1,string *param_2)
{
bool bVar1;
long lVar2;
runtime_error *this;
string *in_RDX;
long in_FS_OFFSET;
long local_98;
long local_90;
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
local_88 [32];
regex local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::match_results(local_88);
/* try { // try from 00104ba1 to 00104ba5 has its CatchHandler @ 00104d14 */
std::regex::basic_regex<std::char_traits<char>,std::allocator<char>>(local_68,in_RDX,0x10);
/* try { // try from 00104bbd to 00104be1 has its CatchHandler @ 00104cff */
bVar1 = std::
regex_search<std::char_traits<char>,std::allocator<char>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
(param_2,(match_results *)local_88,local_68,0);
if (!bVar1) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00104ca1 to 00104ca5 has its CatchHandler @ 00104ceb */
std::runtime_error::runtime_error(this,"Pattern not found");
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
/* WARNING: Subroutine does not return */
/* try { // try from 00104cd1 to 00104cd5 has its CatchHandler @ 00104cff */
__cxa_throw(this,std::runtime_error::typeinfo,PTR__runtime_error_00148fd0);
}
std::
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::str((ulong)local_48);
/* try { // try from 00104bee to 00104c1e has its CatchHandler @ 00104cd6 */
local_98 = std::
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::position(local_88,0);
lVar2 = std::
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::position(local_88,0);
local_90 = std::
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::length(local_88,0);
local_90 = local_90 + lVar2;
std::tuple<std::string,int,int>::tuple<std::string,long,long,true,true>
((tuple<std::string,int,int> *)param_1,local_48,&local_98,&local_90);
std::string::~string(local_48);
std::regex::~basic_regex(local_68);
std::
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::~match_results(local_88);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,425 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::tuple<std::string, int, int> func0(const std::string& text, const std::string& pattern) {
std::smatch match;
std::regex re(pattern);
if (std::regex_search(text, match, re)) {
return {match.str(), match.position(), match.position() + match.length()};
}
throw std::runtime_error("Pattern not found");
}
| int main() {
assert((func0("The quick brown fox jumps over the lazy dog.", "fox") == std::make_tuple("fox", 16, 19)));
assert((func0("Its been a very crazy procedure right", "crazy") == std::make_tuple("crazy", 16, 21)));
assert((func0("Hardest choices required strongest will", "will") == std::make_tuple("will", 35, 39)));
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, 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 $0x1f0,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x1e8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
mov (%rdx),%r12
mov 0x8(%rdx),%r13
lea 0x8(%rsp),%r14
mov %r14,%rdi
callq 4750 <_ZNSt6localeC1Ev@plt>
movl $0x10,0x30(%rsp)
lea 0x38(%rsp),%rdi
mov %r14,%rsi
callq 44f0 <_ZNSt6localeC1ERKS_@plt>
test %r13,%r13
mov $0x0,%eax
cmove %rax,%r12
lea 0x38(%rsp),%rcx
lea (%r12,%r13,1),%rdx
lea 0x50(%rsp),%rdi
mov 0x30(%rsp),%r8d
mov %r12,%rsi
callq 17dfe <_ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC1EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE>
mov 0x150(%rsp),%rax
mov %rax,0x40(%rsp)
mov 0x158(%rsp),%rax
movq $0x0,0x158(%rsp)
mov %rax,0x48(%rsp)
movq $0x0,0x150(%rsp)
lea 0x180(%rsp),%rdi
callq 5f36 <_ZNSt11_Deque_baseINSt8__detail9_StateSeqINSt7__cxx1112regex_traitsIcEEEESaIS5_EED1Ev>
mov 0x160(%rsp),%rdi
lea 0x170(%rsp),%rax
cmp %rax,%rdi
je 4942 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0xf9>
callq 4590 <_ZdlPv@plt>
mov 0x158(%rsp),%r12
test %r12,%r12
je 496a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x121>
cmpq $0x0,0x1b659(%rip)
je 49b0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x167>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%r12)
cmp $0x1,%eax
je 49bf <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x176>
mov 0x120(%rsp),%rdi
lea 0x130(%rsp),%rax
cmp %rax,%rdi
je 4984 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x13b>
callq 4590 <_ZdlPv@plt>
lea 0x8(%rsp),%rdi
callq 4680 <_ZNSt6localeD1Ev@plt>
mov 0x0(%rbp),%rdi
mov %rdi,%rsi
add 0x8(%rbp),%rsi
lea 0x30(%rsp),%rcx
lea 0x10(%rsp),%rdx
mov $0x0,%r8d
callq 9b66 <_ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE>
jmp 4a02 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1b9>
mov 0x8(%r12),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%r12)
jmp 4965 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x11c>
mov (%r12),%rax
mov %r12,%rdi
callq *0x10(%rax)
cmpq $0x0,0x1b5df(%rip)
je 49f3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1aa>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%r12)
cmp $0x1,%eax
jne 496a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x121>
mov (%r12),%rax
mov %r12,%rdi
callq *0x18(%rax)
jmpq 496a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x121>
mov 0xc(%r12),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%r12)
jmp 49df <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x196>
test %al,%al
je 4c74 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x42b>
mov 0x18(%rsp),%rdx
mov 0x10(%rsp),%rax
cmp %rax,%rdx
je 4a25 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1dc>
mov %rdx,%rcx
sub %rax,%rcx
cmp $0x48,%rcx
jne 4a29 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1e0>
lea -0x48(%rdx),%rax
cmpb $0x0,0x10(%rax)
jne 4b91 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x348>
lea 0x60(%rsp),%rax
mov %rax,0x50(%rsp)
movq $0x0,0x58(%rsp)
movb $0x0,0x60(%rsp)
mov 0x18(%rsp),%rcx
mov 0x10(%rsp),%rax
cmp %rax,%rcx
je 4ce3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x49a>
mov %rcx,%rdx
sub %rax,%rdx
cmp $0x48,%rdx
jne 4ccd <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x484>
mov 0x28(%rsp),%rdx
mov %rcx,%rdi
sub %rax,%rdi
mov -0x48(%rcx),%rsi
sub %rdx,%rsi
cmp $0x48,%rdi
jne 4cd8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x48f>
mov -0x48(%rcx),%rdi
sub %rdx,%rdi
cmp %rax,%rcx
je 4aa2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x259>
mov %rcx,%rdx
sub %rax,%rdx
cmp $0x48,%rdx
jne 4aa6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x25d>
lea -0x48(%rcx),%rax
mov $0x0,%edx
cmpb $0x0,0x10(%rax)
je 4ab8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x26f>
mov 0x8(%rax),%rdx
sub (%rax),%rdx
add %rdi,%rdx
mov %edx,(%rbx)
mov %esi,0x4(%rbx)
lea 0x18(%rbx),%rax
mov %rax,0x8(%rbx)
mov 0x50(%rsp),%rax
lea 0x60(%rsp),%rdx
cmp %rdx,%rax
je 4c16 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3cd>
mov %rax,0x8(%rbx)
mov 0x60(%rsp),%rax
mov %rax,0x18(%rbx)
mov 0x58(%rsp),%rax
mov %rax,0x10(%rbx)
mov 0x48(%rsp),%rbp
test %rbp,%rbp
je 4b1c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2d3>
cmpq $0x0,0x1b4ad(%rip)
je 4c25 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3dc>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 4c33 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3ea>
lea 0x38(%rsp),%rdi
callq 4680 <_ZNSt6localeD1Ev@plt>
mov 0x10(%rsp),%rdi
test %rdi,%rdi
je 4b35 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2ec>
callq 4590 <_ZdlPv@plt>
mov 0x1e8(%rsp),%rax
xor %fs:0x28,%rax
jne 4cf4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x4ab>
mov %rbx,%rax
add $0x1f0,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
endbr64
mov %rax,%rbx
lea 0x38(%rsp),%rdi
callq 4680 <_ZNSt6localeD1Ev@plt>
lea 0x8(%rsp),%rdi
callq 4680 <_ZNSt6localeD1Ev@plt>
mov 0x10(%rsp),%rdi
test %rdi,%rdi
je 4b89 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x340>
callq 4590 <_ZdlPv@plt>
mov %rbx,%rdi
callq 46e0 <_Unwind_Resume@plt>
mov (%rax),%r12
mov 0x8(%rax),%rbp
lea 0x60(%rsp),%rax
mov %rax,0x50(%rsp)
sub %r12,%rbp
mov %rbp,0x8(%rsp)
cmp $0xf,%rbp
ja 4bd7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x38e>
cmp $0x1,%rbp
jne 4c0a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3c1>
movzbl (%r12),%eax
mov %al,0x60(%rsp)
mov 0x8(%rsp),%rax
mov %rax,0x58(%rsp)
mov 0x50(%rsp),%rdx
movb $0x0,(%rdx,%rax,1)
jmpq 4a4b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x202>
lea 0x8(%rsp),%rsi
lea 0x50(%rsp),%rdi
mov $0x0,%edx
callq 46f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,%rdi
mov %rax,0x50(%rsp)
mov 0x8(%rsp),%rax
mov %rax,0x60(%rsp)
mov %rbp,%rdx
mov %r12,%rsi
callq 4560 <memcpy@plt>
jmp 4bbf <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x376>
test %rbp,%rbp
je 4bbf <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x376>
lea 0x60(%rsp),%rdi
jmp 4bfd <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3b4>
movdqa 0x60(%rsp),%xmm0
movups %xmm0,0x18(%rbx)
jmpq 4ae8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x29f>
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
jmpq 4b13 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2ca>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
cmpq $0x0,0x1b36b(%rip)
je 4c69 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x420>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 4b1c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2d3>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 4b1c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2d3>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 4c51 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x408>
mov $0x10,%edi
callq 44b0 <__cxa_allocate_exception@plt>
mov %rax,%rbp
lea 0x14a27(%rip),%rsi
mov %rax,%rdi
callq 4460 <_ZNSt13runtime_errorC1EPKc@plt>
mov 0x1b321(%rip),%rdx
lea 0x1ad42(%rip),%rsi
mov %rbp,%rdi
callq 46d0 <__cxa_throw@plt>
endbr64
mov %rax,%rbx
jmp 4cbe <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x475>
endbr64
mov %rax,%rbx
mov %rbp,%rdi
callq 4550 <__cxa_free_exception@plt>
lea 0x30(%rsp),%rdi
callq 5be0 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
jmpq 4b7a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x331>
mov 0x28(%rsp),%rdx
mov (%rax),%rsi
sub %rdx,%rsi
mov (%rax),%rdi
sub %rdx,%rdi
jmpq 4aa6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x25d>
mov -0x48(%rcx),%rsi
sub 0x28(%rsp),%rsi
mov %rsi,%rdi
jmpq 4aa2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x259>
callq 45f0 <__stack_chk_fail@plt>
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
endbr64
push rbp
mov rbp, rsp
push r14
push r13
push r12
push rbx
sub rsp, 1F0h
mov rbx, rdi
mov r14, rsi
mov r12, rdx
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov [rbp+var_200], 0
mov [rbp+var_1F8], 0
mov [rbp+var_1F0], 0
mov [rbp+var_1E8], 0
lea r13, [rbp+var_1D8]
mov rdi, r13; this
call __ZNSt6localeC1Ev; std::locale::locale(void)
mov [rbp+var_1D0], 0
mov [rbp+var_1C8], 0
mov rsi, [r12]
mov rdx, rsi
add rdx, [r12+8]
lea rdi, [rbp+var_1C0]
mov r8d, 10h
mov rcx, r13
call _ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC2EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE; std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(char const*,char const*,std::locale const&,std::regex_constants::syntax_option_type)
mov rdx, [rbp+var_C0]
mov rax, [rbp+var_B8]
mov [rbp+var_B8], 0
mov [rbp+var_C0], 0
mov [rbp+var_1D0], rdx
mov r12, [rbp+var_1C8]
mov [rbp+var_1C8], rax
test r12, r12
jz short loc_4927
lea rcx, [r12+8]
mov rdx, [r12+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_4A03
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_4A2E
mov eax, [r12+8]
lea edx, [rax-1]
mov [r12+8], edx
loc_491E:
cmp eax, 1
jz loc_4A3C
loc_4927:
mov [rbp+var_1E0], 10h
lea rdi, [rbp+var_90]
call _ZNSt11_Deque_baseINSt8__detail9_StateSeqINSt7__cxx1112regex_traitsIcEEEESaIS5_EED2Ev; std::_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>>::~_Deque_base()
mov rdi, [rbp+var_B0]; void *
lea rax, [rbp+var_A0]
cmp rdi, rax
jz short loc_4960
mov rax, [rbp+var_A0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4960:
mov r12, [rbp+var_B8]
test r12, r12
jz short loc_49AC
lea rcx, [r12+8]
mov rdx, [r12+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_4A49
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_4A74
mov eax, [r12+8]
lea edx, [rax-1]
mov [r12+8], edx
loc_49A3:
cmp eax, 1
jz loc_4A82
loc_49AC:
mov rdi, [rbp+var_F0]; void *
lea rax, [rbp+var_E0]
cmp rdi, rax
jz short loc_49CF
mov rax, [rbp+var_E0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_49CF:
mov rdi, [r14]
mov rsi, rdi
add rsi, [r14+8]
lea rcx, [rbp+var_1E0]
lea rdx, [rbp+var_200]
sub rsp, 8
push 0
mov r9d, 0
mov r8d, 0
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
jmp loc_4A8F
loc_4A03:
mov dword ptr [r12+8], 0
mov dword ptr [r12+0Ch], 0
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+10h]
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+18h]
jmp loc_4927
loc_4A2E:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_491E
loc_4A3C:
mov rdi, r12
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE24_M_release_last_use_coldEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(void)
jmp loc_4927
loc_4A49:
mov dword ptr [r12+8], 0
mov dword ptr [r12+0Ch], 0
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+10h]
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+18h]
jmp loc_49AC
loc_4A74:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_49A3
loc_4A82:
mov rdi, r12
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE24_M_release_last_use_coldEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(void)
jmp loc_49AC
loc_4A8F:
add rsp, 10h
test al, al
jz loc_4D6F
mov rdx, [rbp+var_1F8]
mov rax, [rbp+var_200]
cmp rdx, rax
jz short loc_4ABA
mov rcx, rdx
sub rcx, rax
cmp rcx, 48h ; 'H'
jnz short loc_4ABE
loc_4ABA:
lea rax, [rdx-48h]
loc_4ABE:
cmp byte ptr [rax+10h], 0
jnz loc_4C15
lea rax, [rbp+var_1B0]
mov [rbp+var_1C0], rax
mov [rbp+var_1B8], 0
mov byte ptr [rbp+var_1B0], 0
loc_4AE8:
mov rcx, [rbp+var_1F8]
mov rax, [rbp+var_200]
cmp rcx, rax
jz loc_4E45
mov rdx, rcx
sub rdx, rax
cmp rdx, 48h ; 'H'
jnz loc_4E36
mov rsi, rcx
sub rsi, rax
mov rdx, [rcx-48h]
sub rdx, [rbp+var_1E8]
cmp rsi, 48h ; 'H'
jnz short loc_4B2A
loc_4B26:
lea rax, [rcx-48h]
loc_4B2A:
cmp byte ptr [rax+10h], 0
jnz loc_4CC8
mov [rbx], edx
mov [rbx+4], edx
lea rdx, [rbx+18h]
mov [rbx+8], rdx
mov rax, [rbp+var_1C0]
lea rcx, [rbp+var_1B0]
cmp rax, rcx
jz loc_4DE6
loc_4B58:
mov [rbx+8], rax
mov rax, [rbp+var_1B0]
mov [rbx+18h], rax
loc_4B67:
mov rax, [rbp+var_1B8]
mov [rbx+10h], rax
mov rdi, [rbp+var_1C8]
test rdi, rdi
jz short loc_4B83
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4B83:
lea rdi, [rbp+var_1D8]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rdi, [rbp+var_200]; void *
test rdi, rdi
jz short loc_4BAA
mov rsi, [rbp+var_1F0]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4BAA:
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz loc_4E55
mov rax, rbx
lea rsp, [rbp-20h]
pop rbx
pop r12
pop r13
pop r14
pop rbp
retn
endbr64
mov rbx, rax
mov rdi, [rbp+var_1C8]
test rdi, rdi
jz short loc_4BE5
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4BE5:
lea rdi, [rbp+var_1D8]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
loc_4BF1:
lea rdi, [rbp+var_200]
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector()
mov rax, [rbp+var_28]
sub rax, fs:28h
jz loc_4DDE
call ___stack_chk_fail
loc_4C15:
mov r12, [rax]
mov rax, [rax+8]
mov rcx, rax
lea rax, [rbp+var_1B0]
mov [rbp+var_1C0], rax
mov [rbp+var_1B8], 0
mov rax, rcx
sub rax, r12
mov r14, rax
mov [rbp+var_208], rax
cmp rax, 0Fh
ja short loc_4C7D
cmp rax, 1
jnz short loc_4CBA
movzx eax, byte ptr [r12]
mov byte ptr [rbp+var_1B0], al
loc_4C5F:
mov rax, [rbp+var_208]
mov [rbp+var_1B8], rax
mov rdx, [rbp+var_1C0]
mov byte ptr [rdx+rax], 0
jmp loc_4AE8
loc_4C7D:
lea rsi, [rbp+var_208]
lea rdi, [rbp+var_1C0]
mov edx, 0
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov rdi, rax; dest
mov [rbp+var_1C0], rax
mov rax, [rbp+var_208]
mov [rbp+var_1B0], rax
loc_4CAD:
mov rdx, r14; n
mov rsi, r12; src
call _memcpy
jmp short loc_4C5F
loc_4CBA:
test rax, rax
jz short loc_4C5F
lea rdi, [rbp+var_1B0]
jmp short loc_4CAD
loc_4CC8:
mov rcx, [rax+8]
sub rcx, [rax]
mov rax, rcx
add rax, rdx
mov [rbx], eax
mov [rbx+4], edx
lea rdx, [rbx+18h]
mov [rbx+8], rdx
mov rax, [rbp+var_1C0]
lea rcx, [rbp+var_1B0]
cmp rax, rcx
jnz loc_4B58
mov rax, [rbp+var_1B8]
jmp loc_4DED
loc_4D05:
mov edx, dword ptr [rbp+var_1B0]
mov [rsi], edx
mov eax, eax
mov edx, [rcx+rax-4]
mov [rsi+rax-4], edx
jmp loc_4B67
loc_4D1C:
mov rsi, [rbp+var_1B0]
mov [rdx], rsi
mov esi, eax
mov rdi, [rcx+rsi-8]
mov [rdx+rsi-8], rdi
lea rdi, [rdx+8]
and rdi, 0FFFFFFFFFFFFFFF8h
mov rsi, rdx
sub rsi, rdi
sub rcx, rsi
add eax, esi
and eax, 0FFFFFFF8h
cmp eax, 8
jb loc_4B67
and eax, 0FFFFFFF8h
mov edx, 0
loc_4D59:
mov esi, edx
mov r8, [rcx+rsi]
mov [rdi+rsi], r8
add edx, 8
cmp edx, eax
jb short loc_4D59
jmp loc_4B67
loc_4D6F:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aPatternNotFoun; "Pattern not found"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rax, [rbp+var_28]
sub rax, fs:28h
jz short loc_4D9F
call ___stack_chk_fail
loc_4D9F:
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
lea rsi, _ZTISt13runtime_error@GLIBCXX_3_4; lptinfo
mov rdi, r14; void *
call ___cxa_throw
endbr64
mov rbx, rax
jmp short loc_4DCD
endbr64
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
loc_4DCD:
lea rdi, [rbp+var_1E0]
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
jmp loc_4BF1
loc_4DDE:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_4DE6:
mov rax, [rbp+var_1B8]
loc_4DED:
add rax, 1
lea rcx, [rbp+var_1B0]
mov rsi, rdx
cmp eax, 8
jnb loc_4D1C
test al, 4
jnz loc_4D05
test eax, eax
jz loc_4B67
movzx edx, byte ptr [rbp+var_1B0]
mov [rsi], dl
test al, 2
jz loc_4B67
mov eax, eax
movzx edx, word ptr [rcx+rax-2]
mov [rsi+rax-2], dx
jmp loc_4B67
loc_4E36:
mov rdx, [rax]
sub rdx, [rbp+var_1E8]
jmp loc_4B2A
loc_4E45:
mov rdx, [rcx-48h]
sub rdx, [rbp+var_1E8]
jmp loc_4B26
loc_4E55:
call ___stack_chk_fail | long long func0(long long a1, long long a2, _QWORD *a3)
{
long long v6; // rsi
long long v7; // rdx
long long v8; // rax
long long v9; // r12
volatile signed __int32 *v10; // rcx
long long v11; // rdx
signed __int32 v12; // eax
_DWORD *v13; // r12
volatile signed __int32 *v14; // rcx
long long v15; // rdx
signed __int32 v16; // eax
_BYTE *v18; // rax
_DWORD *v19; // rax
long long v20; // rdx
_QWORD *v21; // rdx
_QWORD *v22; // rax
_BYTE *v24; // r12
long long v25; // rcx
long long v26; // rax
size_t v27; // r14
_QWORD *v28; // rdi
int v29; // eax
unsigned long long v30; // rdi
char *v31; // rcx
unsigned int v32; // eax
unsigned int v33; // eax
unsigned int v34; // edx
std::runtime_error *exception; // r14
unsigned int v36; // eax
long long v37; // [rsp+8h] [rbp-208h] BYREF
void *v38; // [rsp+10h] [rbp-200h] BYREF
_BYTE *v39; // [rsp+18h] [rbp-1F8h]
long long v40; // [rsp+20h] [rbp-1F0h]
long long v41; // [rsp+28h] [rbp-1E8h]
int v42; // [rsp+30h] [rbp-1E0h] BYREF
_BYTE v43[8]; // [rsp+38h] [rbp-1D8h] BYREF
long long v44; // [rsp+40h] [rbp-1D0h]
long long v45; // [rsp+48h] [rbp-1C8h]
_QWORD *v46; // [rsp+50h] [rbp-1C0h] BYREF
long long v47; // [rsp+58h] [rbp-1B8h]
_QWORD v48[24]; // [rsp+60h] [rbp-1B0h] BYREF
void *v49; // [rsp+120h] [rbp-F0h]
long long v50; // [rsp+130h] [rbp-E0h] BYREF
long long v51; // [rsp+150h] [rbp-C0h]
long long v52; // [rsp+158h] [rbp-B8h]
void *v53; // [rsp+160h] [rbp-B0h]
long long v54; // [rsp+170h] [rbp-A0h] BYREF
_BYTE v55[104]; // [rsp+180h] [rbp-90h] BYREF
unsigned long long v56; // [rsp+1E8h] [rbp-28h]
v56 = __readfsqword(0x28u);
v38 = 0LL;
v39 = 0LL;
v40 = 0LL;
v41 = 0LL;
std::locale::locale((std::locale *)v43);
v44 = 0LL;
v45 = 0LL;
v6 = *a3;
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(&v46, *a3, a3[1] + *a3, v43, 16LL);
v7 = v51;
v8 = v52;
v52 = 0LL;
v51 = 0LL;
v44 = v7;
v9 = v45;
v45 = v8;
if ( v9 )
{
v10 = (volatile signed __int32 *)(v9 + 8);
v11 = *(_QWORD *)(v9 + 8);
if ( v11 == 0x100000001LL )
{
*(_DWORD *)(v9 + 8) = 0;
*(_DWORD *)(v9 + 12) = 0;
(*(void ( **)(long long, long long, long long, volatile signed __int32 *))(*(_QWORD *)v9 + 16LL))(
v9,
v6,
0x100000001LL,
v10);
(*(void ( **)(long long))(*(_QWORD *)v9 + 24LL))(v9);
}
else
{
if ( _libc_single_threaded )
{
v12 = *(_DWORD *)(v9 + 8);
v11 = (unsigned int)(v12 - 1);
*(_DWORD *)(v9 + 8) = v11;
}
else
{
v12 = _InterlockedExchangeAdd(v10, 0xFFFFFFFF);
}
if ( v12 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v9, v6, v11, v10);
}
}
v42 = 16;
std::_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>>::~_Deque_base(v55);
if ( v53 != &v54 )
{
v6 = v54 + 1;
operator delete(v53, v54 + 1);
}
v13 = (_DWORD *)v52;
if ( v52 )
{
v14 = (volatile signed __int32 *)(v52 + 8);
v15 = *(_QWORD *)(v52 + 8);
if ( v15 == 0x100000001LL )
{
*(_DWORD *)(v52 + 8) = 0;
v13[3] = 0;
(*(void ( **)(_DWORD *, long long, long long, volatile signed __int32 *))(*(_QWORD *)v13 + 16LL))(
v13,
v6,
0x100000001LL,
v14);
(*(void ( **)(_DWORD *))(*(_QWORD *)v13 + 24LL))(v13);
}
else
{
if ( _libc_single_threaded )
{
v16 = *(_DWORD *)(v52 + 8);
v15 = (unsigned int)(v16 - 1);
*(_DWORD *)(v52 + 8) = v15;
}
else
{
v16 = _InterlockedExchangeAdd(v14, 0xFFFFFFFF);
}
if ( v16 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v13, v6, v15, v14);
}
}
if ( v49 != &v50 )
operator delete(v49, v50 + 1);
if ( !(unsigned __int8)std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
*(_QWORD *)a2,
*(_DWORD *)(a2 + 8) + *(_DWORD *)a2,
(unsigned int)&v38,
(unsigned int)&v42,
0,
0,
0) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Pattern not found");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v18 = v38;
if ( v39 == v38 || v39 - (_BYTE *)v38 == 72 )
v18 = v39 - 72;
if ( !v18[16] )
{
v46 = v48;
v47 = 0LL;
LOBYTE(v48[0]) = 0;
goto LABEL_28;
}
v24 = *(_BYTE **)v18;
v25 = *((_QWORD *)v18 + 1);
v46 = v48;
v47 = 0LL;
v26 = v25 - (_QWORD)v24;
v27 = v25 - (_QWORD)v24;
v37 = v25 - (_QWORD)v24;
if ( (unsigned long long)(v25 - (_QWORD)v24) > 0xF )
{
v28 = (_QWORD *)std::string::_M_create(&v46, &v37, 0LL);
v46 = v28;
v48[0] = v37;
LABEL_45:
memcpy(v28, v24, v27);
goto LABEL_43;
}
if ( v26 != 1 )
{
if ( !v26 )
goto LABEL_43;
v28 = v48;
goto LABEL_45;
}
LOBYTE(v48[0]) = *v24;
LABEL_43:
v47 = v37;
*((_BYTE *)v46 + v37) = 0;
LABEL_28:
v19 = v38;
if ( v39 == v38 )
{
LODWORD(v20) = *((_QWORD *)v39 - 9) - v41;
goto LABEL_31;
}
if ( v39 - (_BYTE *)v38 == 72 )
{
v20 = *((_QWORD *)v39 - 9) - v41;
LABEL_31:
v19 = v39 - 72;
goto LABEL_32;
}
v20 = *(_QWORD *)v38 - v41;
LABEL_32:
if ( *((_BYTE *)v19 + 16) )
{
*(_DWORD *)a1 = v20 + v19[2] - *v19;
*(_DWORD *)(a1 + 4) = v20;
v21 = (_QWORD *)(a1 + 24);
*(_QWORD *)(a1 + 8) = a1 + 24;
v22 = v46;
if ( v46 != v48 )
goto LABEL_34;
v29 = v47;
}
else
{
*(_DWORD *)a1 = v20;
*(_DWORD *)(a1 + 4) = v20;
v21 = (_QWORD *)(a1 + 24);
*(_QWORD *)(a1 + 8) = a1 + 24;
v22 = v46;
if ( v46 != v48 )
{
LABEL_34:
*(_QWORD *)(a1 + 8) = v22;
*(_QWORD *)(a1 + 24) = v48[0];
goto LABEL_35;
}
v29 = v47;
}
v36 = v29 + 1;
if ( v36 >= 8 )
{
*v21 = v48[0];
*(_QWORD *)((char *)v21 + v36 - 8) = *(_QWORD *)((char *)&v48[-1] + v36);
v30 = (unsigned long long)(v21 + 1) & 0xFFFFFFFFFFFFFFF8LL;
v31 = (char *)((char *)v48 - ((char *)v21 - v30));
v32 = ((_DWORD)v21 - v30 + v36) & 0xFFFFFFF8;
if ( v32 >= 8 )
{
v33 = v32 & 0xFFFFFFF8;
v34 = 0;
do
{
*(_QWORD *)(v30 + v34) = *(_QWORD *)&v31[v34];
v34 += 8;
}
while ( v34 < v33 );
}
}
else if ( (v36 & 4) != 0 )
{
*(_DWORD *)v21 = v48[0];
*(_DWORD *)((char *)v21 + v36 - 4) = *(_DWORD *)((char *)&v47 + v36 + 4);
}
else if ( v36 )
{
*(_BYTE *)v21 = v48[0];
if ( (v36 & 2) != 0 )
*(_WORD *)((char *)v21 + v36 - 2) = *(_WORD *)((char *)&v47 + v36 + 6);
}
LABEL_35:
*(_QWORD *)(a1 + 16) = v47;
if ( v45 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
std::locale::~locale((std::locale *)v43);
if ( v38 )
operator delete(v38, v40 - (_QWORD)v38);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1f0
MOV RBX,RDI
MOV R14,RSI
MOV R12,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV qword ptr [RBP + -0x200],0x0
MOV qword ptr [RBP + -0x1f8],0x0
MOV qword ptr [RBP + -0x1f0],0x0
MOV qword ptr [RBP + -0x1e8],0x0
LEA R13,[RBP + -0x1d8]
MOV RDI,R13
CALL 0x00104710
MOV qword ptr [RBP + -0x1d0],0x0
MOV qword ptr [RBP + -0x1c8],0x0
MOV RSI,qword ptr [R12]
MOV RDX,RSI
ADD RDX,qword ptr [R12 + 0x8]
LEA RDI,[RBP + -0x1c0]
MOV R8D,0x10
MOV RCX,R13
LAB_001048a4:
CALL 0x0011659a
MOV RDX,qword ptr [RBP + -0xc0]
MOV RAX,qword ptr [RBP + -0xb8]
MOV qword ptr [RBP + -0xb8],0x0
MOV qword ptr [RBP + -0xc0],0x0
MOV qword ptr [RBP + -0x1d0],RDX
MOV R12,qword ptr [RBP + -0x1c8]
MOV qword ptr [RBP + -0x1c8],RAX
TEST R12,R12
JZ 0x00104927
LEA RCX,[R12 + 0x8]
MOV RDX,qword ptr [R12 + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x00104a03
CMP byte ptr [0x0011f460],0x0
JZ 0x00104a2e
MOV EAX,dword ptr [R12 + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [R12 + 0x8],EDX
LAB_0010491e:
CMP EAX,0x1
JZ 0x00104a3c
LAB_00104927:
MOV dword ptr [RBP + -0x1e0],0x10
LEA RDI,[RBP + -0x90]
CALL 0x00106260
MOV RDI,qword ptr [RBP + -0xb0]
LEA RAX,[RBP + -0xa0]
CMP RDI,RAX
JZ 0x00104960
MOV RAX,qword ptr [RBP + -0xa0]
LEA RSI,[RAX + 0x1]
CALL 0x00104560
LAB_00104960:
MOV R12,qword ptr [RBP + -0xb8]
TEST R12,R12
JZ 0x001049ac
LEA RCX,[R12 + 0x8]
MOV RDX,qword ptr [R12 + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x00104a49
CMP byte ptr [0x0011f460],0x0
JZ 0x00104a74
MOV EAX,dword ptr [R12 + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [R12 + 0x8],EDX
LAB_001049a3:
CMP EAX,0x1
JZ 0x00104a82
LAB_001049ac:
MOV RDI,qword ptr [RBP + -0xf0]
LEA RAX,[RBP + -0xe0]
CMP RDI,RAX
JZ 0x001049cf
MOV RAX,qword ptr [RBP + -0xe0]
LEA RSI,[RAX + 0x1]
CALL 0x00104560
LAB_001049cf:
MOV RDI,qword ptr [R14]
MOV RSI,RDI
ADD RSI,qword ptr [R14 + 0x8]
LEA RCX,[RBP + -0x1e0]
LEA RDX,[RBP + -0x200]
SUB RSP,0x8
PUSH 0x0
MOV R9D,0x0
MOV R8D,0x0
LAB_001049f9:
CALL 0x0010d77b
JMP 0x00104a8f
LAB_00104a03:
MOV dword ptr [R12 + 0x8],0x0
MOV dword ptr [R12 + 0xc],0x0
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x18]
JMP 0x00104927
LAB_00104a2e:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x0010491e
LAB_00104a3c:
MOV RDI,R12
CALL 0x00105e88
JMP 0x00104927
LAB_00104a49:
MOV dword ptr [R12 + 0x8],0x0
MOV dword ptr [R12 + 0xc],0x0
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x18]
JMP 0x001049ac
LAB_00104a74:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x001049a3
LAB_00104a82:
MOV RDI,R12
CALL 0x00105e88
JMP 0x001049ac
LAB_00104a8f:
ADD RSP,0x10
TEST AL,AL
JZ 0x00104d6f
MOV RDX,qword ptr [RBP + -0x1f8]
MOV RAX,qword ptr [RBP + -0x200]
CMP RDX,RAX
JZ 0x00104aba
MOV RCX,RDX
SUB RCX,RAX
CMP RCX,0x48
JNZ 0x00104abe
LAB_00104aba:
LEA RAX,[RDX + -0x48]
LAB_00104abe:
CMP byte ptr [RAX + 0x10],0x0
JNZ 0x00104c15
LEA RAX,[RBP + -0x1b0]
MOV qword ptr [RBP + -0x1c0],RAX
MOV qword ptr [RBP + -0x1b8],0x0
MOV byte ptr [RBP + -0x1b0],0x0
LAB_00104ae8:
MOV RCX,qword ptr [RBP + -0x1f8]
MOV RAX,qword ptr [RBP + -0x200]
CMP RCX,RAX
JZ 0x00104e45
MOV RDX,RCX
SUB RDX,RAX
CMP RDX,0x48
JNZ 0x00104e36
MOV RSI,RCX
SUB RSI,RAX
MOV RDX,qword ptr [RCX + -0x48]
SUB RDX,qword ptr [RBP + -0x1e8]
CMP RSI,0x48
JNZ 0x00104b2a
LAB_00104b26:
LEA RAX,[RCX + -0x48]
LAB_00104b2a:
CMP byte ptr [RAX + 0x10],0x0
JNZ 0x00104cc8
MOV dword ptr [RBX],EDX
MOV dword ptr [RBX + 0x4],EDX
LEA RDX,[RBX + 0x18]
MOV qword ptr [RBX + 0x8],RDX
MOV RAX,qword ptr [RBP + -0x1c0]
LEA RCX,[RBP + -0x1b0]
CMP RAX,RCX
JZ 0x00104de6
LAB_00104b58:
MOV qword ptr [RBX + 0x8],RAX
MOV RAX,qword ptr [RBP + -0x1b0]
MOV qword ptr [RBX + 0x18],RAX
LAB_00104b67:
MOV RAX,qword ptr [RBP + -0x1b8]
MOV qword ptr [RBX + 0x10],RAX
MOV RDI,qword ptr [RBP + -0x1c8]
TEST RDI,RDI
JZ 0x00104b83
CALL 0x00105ec6
LAB_00104b83:
LEA RDI,[RBP + -0x1d8]
CALL 0x00104650
MOV RDI,qword ptr [RBP + -0x200]
TEST RDI,RDI
JZ 0x00104baa
MOV RSI,qword ptr [RBP + -0x1f0]
SUB RSI,RDI
CALL 0x00104560
LAB_00104baa:
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00104e55
MOV RAX,RBX
LEA RSP,[RBP + -0x20]
POP RBX
POP R12
POP R13
POP R14
POP RBP
RET
LAB_00104c15:
MOV R12,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,RAX
LEA RAX,[RBP + -0x1b0]
MOV qword ptr [RBP + -0x1c0],RAX
MOV qword ptr [RBP + -0x1b8],0x0
MOV RAX,RCX
SUB RAX,R12
MOV R14,RAX
MOV qword ptr [RBP + -0x208],RAX
CMP RAX,0xf
JA 0x00104c7d
CMP RAX,0x1
JNZ 0x00104cba
MOVZX EAX,byte ptr [R12]
MOV byte ptr [RBP + -0x1b0],AL
LAB_00104c5f:
MOV RAX,qword ptr [RBP + -0x208]
MOV qword ptr [RBP + -0x1b8],RAX
MOV RDX,qword ptr [RBP + -0x1c0]
MOV byte ptr [RDX + RAX*0x1],0x0
JMP 0x00104ae8
LAB_00104c7d:
LEA RSI,[RBP + -0x208]
LEA RDI,[RBP + -0x1c0]
MOV EDX,0x0
CALL 0x001046c0
MOV RDI,RAX
MOV qword ptr [RBP + -0x1c0],RAX
MOV RAX,qword ptr [RBP + -0x208]
MOV qword ptr [RBP + -0x1b0],RAX
LAB_00104cad:
MOV RDX,R14
MOV RSI,R12
CALL 0x00104540
JMP 0x00104c5f
LAB_00104cba:
TEST RAX,RAX
JZ 0x00104c5f
LEA RDI,[RBP + -0x1b0]
JMP 0x00104cad
LAB_00104cc8:
MOV RCX,qword ptr [RAX + 0x8]
SUB RCX,qword ptr [RAX]
MOV RAX,RCX
ADD RAX,RDX
MOV dword ptr [RBX],EAX
MOV dword ptr [RBX + 0x4],EDX
LEA RDX,[RBX + 0x18]
MOV qword ptr [RBX + 0x8],RDX
MOV RAX,qword ptr [RBP + -0x1c0]
LEA RCX,[RBP + -0x1b0]
CMP RAX,RCX
JNZ 0x00104b58
MOV RAX,qword ptr [RBP + -0x1b8]
JMP 0x00104ded
LAB_00104d05:
MOV EDX,dword ptr [RBP + -0x1b0]
MOV dword ptr [RSI],EDX
MOV EAX,EAX
MOV EDX,dword ptr [RCX + RAX*0x1 + -0x4]
MOV dword ptr [RSI + RAX*0x1 + -0x4],EDX
JMP 0x00104b67
LAB_00104d1c:
MOV RSI,qword ptr [RBP + -0x1b0]
MOV qword ptr [RDX],RSI
MOV ESI,EAX
MOV RDI,qword ptr [RCX + RSI*0x1 + -0x8]
MOV qword ptr [RDX + RSI*0x1 + -0x8],RDI
LEA RDI,[RDX + 0x8]
AND RDI,-0x8
MOV RSI,RDX
SUB RSI,RDI
SUB RCX,RSI
ADD EAX,ESI
AND EAX,0xfffffff8
CMP EAX,0x8
JC 0x00104b67
AND EAX,0xfffffff8
MOV EDX,0x0
LAB_00104d59:
MOV ESI,EDX
MOV R8,qword ptr [RCX + RSI*0x1]
MOV qword ptr [RDI + RSI*0x1],R8
ADD EDX,0x8
CMP EDX,EAX
JC 0x00104d59
JMP 0x00104b67
LAB_00104d6f:
MOV EDI,0x10
CALL 0x00104480
MOV R14,RAX
LEA RSI,[0x119787]
MOV RDI,RAX
LAB_00104d86:
CALL 0x00104430
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00104d9f
CALL 0x001045a0
LAB_00104d9f:
MOV RDX,qword ptr [0x0011efd8]
LEA RSI,[0x11ea10]
MOV RDI,R14
LAB_00104db0:
CALL 0x00104690
LAB_00104de6:
MOV RAX,qword ptr [RBP + -0x1b8]
LAB_00104ded:
ADD RAX,0x1
LEA RCX,[RBP + -0x1b0]
MOV RSI,RDX
CMP EAX,0x8
JNC 0x00104d1c
TEST AL,0x4
JNZ 0x00104d05
TEST EAX,EAX
JZ 0x00104b67
MOVZX EDX,byte ptr [RBP + -0x1b0]
MOV byte ptr [RSI],DL
TEST AL,0x2
JZ 0x00104b67
MOV EAX,EAX
MOVZX EDX,word ptr [RCX + RAX*0x1 + -0x2]
MOV word ptr [RSI + RAX*0x1 + -0x2],DX
JMP 0x00104b67
LAB_00104e36:
MOV RDX,qword ptr [RAX]
SUB RDX,qword ptr [RBP + -0x1e8]
JMP 0x00104b2a
LAB_00104e45:
MOV RDX,qword ptr [RCX + -0x48]
SUB RDX,qword ptr [RBP + -0x1e8]
JMP 0x00104b26
LAB_00104e55:
CALL 0x001045a0 | /* func0(std::string const&, std::string const&) */
string * func0(string *param_1,string *param_2)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int *__src;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
bool bVar3;
uint uVar4;
int8 *puVar5;
runtime_error *this;
ulong uVar6;
int iVar7;
uint uVar8;
int8 *in_RDX;
string *psVar9;
long lVar10;
long in_FS_OFFSET;
ulong local_210;
int8 *local_208;
int8 *local_200;
long local_1f8;
int8 local_1f0;
int4 local_1e8 [2];
locale local_1e0 [2];
int8 local_1d8;
_Sp_counted_base<(_Lock_policy)2> *local_1d0;
ulong *local_1c8;
int8 local_1c0;
ulong local_1b8 [24];
long *local_f8;
long local_e8 [4];
int8 local_c8;
_Sp_counted_base<(_Lock_policy)2> *local_c0;
long *local_b8;
long local_a8 [2];
_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>,std::allocator<std::__detail::_StateSeq<std::regex_traits<char>>>>
local_98 [104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_208 = (int8 *)0x0;
local_200 = (int8 *)0x0;
local_1f8 = 0;
local_1f0 = 0;
std::locale::locale(local_1e0);
local_1d8 = 0;
local_1d0 = (_Sp_counted_base<(_Lock_policy)2> *)0x0;
/* try { // try from 001048a4 to 001048a8 has its CatchHandler @ 00104bcd */
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler
((_Compiler<std::regex_traits<char>> *)&local_1c8,(char *)*in_RDX,
(char *)*in_RDX + in_RDX[1],local_1e0,0x10);
p_Var1 = local_c0;
local_1d8 = local_c8;
p_Var2 = local_1d0;
local_c0 = (_Sp_counted_base<(_Lock_policy)2> *)0x0;
local_c8 = 0;
local_1d0 = p_Var1;
if (p_Var2 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = p_Var2 + 8;
if (*(long *)(p_Var2 + 8) == 0x100000001) {
*(int4 *)(p_Var2 + 8) = 0;
*(int4 *)(p_Var2 + 0xc) = 0;
(**(code **)(*(long *)p_Var2 + 0x10))(p_Var2);
(**(code **)(*(long *)p_Var2 + 0x18))(p_Var2);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar7 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar7 = *(int *)(p_Var2 + 8);
*(int *)(p_Var2 + 8) = iVar7 + -1;
}
if (iVar7 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold(p_Var2);
}
}
}
local_1e8[0] = 0x10;
std::
_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>,std::allocator<std::__detail::_StateSeq<std::regex_traits<char>>>>
::~_Deque_base(local_98);
if (local_b8 != local_a8) {
operator_delete(local_b8,local_a8[0] + 1);
}
p_Var2 = local_c0;
if (local_c0 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = local_c0 + 8;
if (*(long *)(local_c0 + 8) == 0x100000001) {
*(int4 *)(local_c0 + 8) = 0;
*(int4 *)(local_c0 + 0xc) = 0;
(**(code **)(*(long *)local_c0 + 0x10))(local_c0);
(**(code **)(*(long *)p_Var2 + 0x18))(p_Var2);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar7 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar7 = *(int *)(local_c0 + 8);
*(int *)(local_c0 + 8) = iVar7 + -1;
}
if (iVar7 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold(local_c0);
}
}
}
if (local_f8 != local_e8) {
operator_delete(local_f8,local_e8[0] + 1);
}
/* try { // try from 001049f9 to 00104c94 has its CatchHandler @ 00104db5 */
bVar3 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)*(int8 *)param_2,
(__normal_iterator)*(int8 *)param_2 + (int)*(int8 *)(param_2 + 8),
(match_results *)&local_208,(regex *)local_1e8,0,0,false);
if (!bVar3) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00104d86 to 00104d8a has its CatchHandler @ 00104dbe */
std::runtime_error::runtime_error(this,"Pattern not found");
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
/* WARNING: Subroutine does not return */
/* try { // try from 00104db0 to 00104db4 has its CatchHandler @ 00104db5 */
__cxa_throw(this,std::runtime_error::typeinfo,PTR__runtime_error_0011efd8);
}
if ((local_200 == local_208) || (puVar5 = local_208, (long)local_200 - (long)local_208 == 0x48)) {
puVar5 = local_200 + -9;
}
if (*(char *)(puVar5 + 2) == '\0') {
local_1c8 = local_1b8;
local_1c0 = 0;
local_1b8[0] = (ulong)local_1b8[0]._1_7_ << 8;
}
else {
__src = (int *)*puVar5;
local_1c8 = local_1b8;
local_1c0 = 0;
uVar6 = puVar5[1] - (long)__src;
local_210 = uVar6;
if (uVar6 < 0x10) {
if (uVar6 == 1) {
local_1b8[0] = CONCAT71(local_1b8[0]._1_7_,*__src);
}
else if (uVar6 != 0) goto LAB_00104cad;
}
else {
local_1c8 = (ulong *)std::string::_M_create((ulong *)&local_1c8,(ulong)&local_210);
local_1b8[0] = local_210;
LAB_00104cad:
memcpy(local_1c8,__src,uVar6);
}
local_1c0 = local_210;
*(int *)((long)local_1c8 + local_210) = 0;
}
iVar7 = (int)local_1f0;
if (local_200 == local_208) {
iVar7 = (int)local_200[-9] - iVar7;
}
else {
puVar5 = local_208;
if ((long)local_200 - (long)local_208 != 0x48) {
iVar7 = (int)*local_208 - iVar7;
goto LAB_00104b2a;
}
iVar7 = (int)local_200[-9] - iVar7;
if ((long)local_200 - (long)local_208 != 0x48) goto LAB_00104b2a;
}
puVar5 = local_200 + -9;
LAB_00104b2a:
if (*(char *)(puVar5 + 2) == '\0') {
*(int *)param_1 = iVar7;
*(int *)(param_1 + 4) = iVar7;
*(string **)(param_1 + 8) = param_1 + 0x18;
}
else {
*(int *)param_1 = ((int)puVar5[1] - (int)*puVar5) + iVar7;
*(int *)(param_1 + 4) = iVar7;
*(string **)(param_1 + 8) = param_1 + 0x18;
}
if (local_1c8 == local_1b8) {
psVar9 = param_1 + 0x18;
uVar6 = local_1c0 + 1;
uVar4 = (uint)uVar6;
if (uVar4 < 8) {
if ((uVar6 & 4) == 0) {
if (uVar4 != 0) {
*psVar9 = local_1b8[0]._0_1_;
if ((uVar6 & 2) != 0) {
*(int2 *)(param_1 + (uVar6 & 0xffffffff) + 0x16) =
*(int2 *)((long)local_1b8 + ((uVar6 & 0xffffffff) - 2));
}
}
}
else {
*(int4 *)psVar9 = (int4)local_1b8[0];
*(int4 *)(param_1 + (uVar6 & 0xffffffff) + 0x14) =
*(int4 *)((long)local_1b8 + ((uVar6 & 0xffffffff) - 4));
}
}
else {
*(ulong *)psVar9 = local_1b8[0];
*(int8 *)(param_1 + (uVar6 & 0xffffffff) + 0x10) =
*(int8 *)((long)local_1b8 + ((uVar6 & 0xffffffff) - 8));
lVar10 = (long)psVar9 - ((ulong)(param_1 + 0x20) & 0xfffffffffffffff8);
uVar4 = uVar4 + (int)lVar10 & 0xfffffff8;
if (7 < uVar4) {
uVar8 = 0;
do {
*(int8 *)(((ulong)(param_1 + 0x20) & 0xfffffffffffffff8) + (ulong)uVar8) =
*(int8 *)((long)local_1b8 + ((ulong)uVar8 - lVar10));
uVar8 = uVar8 + 8;
} while (uVar8 < uVar4);
}
}
}
else {
*(ulong **)(param_1 + 8) = local_1c8;
*(ulong *)(param_1 + 0x18) = local_1b8[0];
}
*(ulong *)(param_1 + 0x10) = local_1c0;
if (local_1d0 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release(local_1d0);
}
std::locale::~locale(local_1e0);
if (local_208 != (int8 *)0x0) {
operator_delete(local_208,local_1f8 - (long)local_208);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,426 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::tuple<std::string, int, int> func0(const std::string& text, const std::string& pattern) {
std::smatch match;
std::regex re(pattern);
if (std::regex_search(text, match, re)) {
return {match.str(), match.position(), match.position() + match.length()};
}
throw std::runtime_error("Pattern not found");
}
| int main() {
assert((func0("The quick brown fox jumps over the lazy dog.", "fox") == std::make_tuple("fox", 16, 19)));
assert((func0("Its been a very crazy procedure right", "crazy") == std::make_tuple("crazy", 16, 21)));
assert((func0("Hardest choices required strongest will", "will") == std::make_tuple("will", 35, 39)));
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, 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 $0x208,%rsp
mov 0x8(%rdx),%r14
mov (%rdx),%r15
mov %fs:0x28,%rax
mov %rax,0x1f8(%rsp)
xor %eax,%eax
lea 0x18(%rsp),%rbp
lea 0x48(%rsp),%r13
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
mov %rbp,%rdi
movq $0x0,0x30(%rsp)
movq $0x0,0x38(%rsp)
callq 4770 <_ZNSt6localeC1Ev@plt>
mov %rbp,%rsi
mov %r13,%rdi
movl $0x10,0x40(%rsp)
callq 4510 <_ZNSt6localeC1ERKS_@plt>
test %r14,%r14
mov $0x0,%eax
mov %r13,%rcx
cmove %rax,%r15
mov 0x40(%rsp),%r8d
lea (%r15,%r14,1),%rdx
lea 0x60(%rsp),%r14
mov %r15,%rsi
mov %r14,%rdi
callq 19370 <_ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC1EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE>
mov 0x160(%rsp),%rax
lea 0x190(%rsp),%rdi
movq $0x0,0x160(%rsp)
mov %rax,0x50(%rsp)
mov 0x168(%rsp),%rax
movq $0x0,0x168(%rsp)
mov %rax,0x58(%rsp)
callq 6260 <_ZNSt11_Deque_baseINSt8__detail9_StateSeqINSt7__cxx1112regex_traitsIcEEEESaIS5_EED1Ev>
mov 0x170(%rsp),%rdi
lea 0x180(%rsp),%rax
cmp %rax,%rdi
je 4e1f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0xff>
callq 45b0 <_ZdlPv@plt>
mov 0x168(%rsp),%r15
test %r15,%r15
je 4e50 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x130>
mov 0x1d185(%rip),%rax
test %rax,%rax
je 4fc0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2a0>
mov $0xffffffff,%edx
lock xadd %edx,0x8(%r15)
cmp $0x1,%edx
je 4fd4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2b4>
mov 0x130(%rsp),%rdi
lea 0x140(%rsp),%rax
cmp %rax,%rdi
je 4e6a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x14a>
callq 45b0 <_ZdlPv@plt>
mov %rbp,%rdi
lea 0x40(%rsp),%r15
callq 46a0 <_ZNSt6localeD1Ev@plt>
mov (%rbx),%rdi
mov 0x8(%rbx),%rsi
xor %r8d,%r8d
lea 0x20(%rsp),%rdx
mov %r15,%rcx
add %rdi,%rsi
callq a7d0 <_ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE>
test %al,%al
je 5191 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x471>
mov 0x28(%rsp),%rdx
mov 0x20(%rsp),%rax
mov %rdx,%rcx
sub %rax,%rcx
cmp %rax,%rdx
je 5060 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x340>
mov %rax,%rsi
cmp $0x48,%rcx
je 5060 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x340>
cmpb $0x0,0x10(%rsi)
jne 506f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x34f>
lea 0x70(%rsp),%rbx
movb $0x0,0x70(%rsp)
mov 0x38(%rsp),%rdi
xor %r8d,%r8d
mov %rbx,0x60(%rsp)
mov %rbx,%rsi
movq $0x0,0x68(%rsp)
cmp %rdx,%rax
je 50e6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3c6>
mov (%rax),%rdx
sub %rdi,%rdx
cmpb $0x0,0x10(%rax)
mov %rdx,%rcx
jne 4fb0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x290>
lea 0x18(%r12),%rax
mov %ecx,(%r12)
mov %edx,0x4(%r12)
mov %rax,0x8(%r12)
cmp %rbx,%rsi
je 50f0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3d0>
mov 0x70(%rsp),%rax
mov %rsi,0x8(%r12)
mov %rax,0x18(%r12)
mov 0x58(%rsp),%rbp
mov %r8,0x10(%r12)
test %rbp,%rbp
je 4f68 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x248>
mov 0x1d06f(%rip),%rax
test %rax,%rax
je 5010 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2f0>
mov $0xffffffff,%edx
lock xadd %edx,0x8(%rbp)
cmp $0x1,%edx
je 5022 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x302>
nopl (%rax)
mov %r13,%rdi
callq 46a0 <_ZNSt6localeD1Ev@plt>
mov 0x20(%rsp),%rdi
test %rdi,%rdi
je 4f7f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x25f>
callq 45b0 <_ZdlPv@plt>
mov 0x1f8(%rsp),%rax
xor %fs:0x28,%rax
jne 517e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x45e>
add $0x208,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov 0x8(%rax),%rcx
sub (%rax),%rcx
add %rdx,%rcx
jmpq 4f08 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1e8>
mov 0x8(%r15),%edx
lea -0x1(%rdx),%ecx
mov %ecx,0x8(%r15)
cmp $0x1,%edx
jne 4e50 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x130>
mov (%r15),%rdx
mov %rax,(%rsp)
mov %r15,%rdi
callq *0x10(%rdx)
mov (%rsp),%rax
test %rax,%rax
je 5160 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x440>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%r15)
cmp $0x1,%eax
jne 4e50 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x130>
mov (%r15),%rax
mov %r15,%rdi
callq *0x18(%rax)
jmpq 4e50 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x130>
mov 0x8(%rbp),%edx
lea -0x1(%rdx),%ecx
mov %ecx,0x8(%rbp)
cmp $0x1,%edx
jne 4f68 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x248>
mov 0x0(%rbp),%rdx
mov %rax,(%rsp)
mov %rbp,%rdi
callq *0x10(%rdx)
mov (%rsp),%rax
test %rax,%rax
je 5170 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x450>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 4f68 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x248>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 4f68 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x248>
lea -0x48(%rax,%rcx,1),%rsi
cmpb $0x0,0x10(%rsi)
je 4ec9 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1a9>
mov (%rsi),%rcx
mov 0x8(%rsi),%rax
lea 0x70(%rsp),%rbx
mov %rbx,0x60(%rsp)
sub %rcx,%rax
mov %rcx,0x8(%rsp)
mov %rax,(%rsp)
mov %rax,0x18(%rsp)
cmp $0xf,%rax
ja 5118 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3f8>
cmpq $0x1,(%rsp)
jne 5108 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3e8>
mov 0x8(%rsp),%rax
movzbl (%rax),%eax
mov %al,0x70(%rsp)
mov %rbx,%rax
mov (%rsp),%rcx
mov %rcx,0x68(%rsp)
movb $0x0,(%rax,%rcx,1)
mov 0x28(%rsp),%rdx
mov 0x20(%rsp),%rax
mov 0x60(%rsp),%rsi
mov %rdx,%rcx
mov 0x68(%rsp),%r8
mov 0x38(%rsp),%rdi
sub %rax,%rcx
cmp %rdx,%rax
jne 4ef5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1d5>
lea -0x48(%rax,%rcx,1),%rax
jmpq 4ef5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1d5>
movdqa 0x70(%rsp),%xmm0
movups %xmm0,0x18(%r12)
jmpq 4f33 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x213>
nopl 0x0(%rax)
cmpq $0x0,(%rsp)
jne 5183 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x463>
mov %rbx,%rax
jmp 50b1 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x391>
nopl 0x0(%rax)
xor %edx,%edx
mov %rbp,%rsi
mov %r14,%rdi
callq 4710 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,0x60(%rsp)
mov %rax,%rdi
mov 0x18(%rsp),%rax
mov %rax,0x70(%rsp)
mov (%rsp),%rdx
mov 0x8(%rsp),%rsi
callq 4580 <memcpy@plt>
mov 0x18(%rsp),%rax
mov %rax,(%rsp)
mov 0x60(%rsp),%rax
jmpq 50b1 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x391>
nopl 0x0(%rax,%rax,1)
mov 0xc(%r15),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%r15)
jmpq 4ff9 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2d9>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmpq 5047 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x327>
callq 4610 <__stack_chk_fail@plt>
mov %rbx,%rdi
jmp 5137 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x417>
endbr64
jmpq 47e8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_.cold+0x5>
jmpq 480a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_.cold+0x27>
endbr64
mov %rax,%rbx
jmpq 483c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_.cold+0x59>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
endbr64
push rbp
pxor xmm0, xmm0
mov rbp, rsp
push r15
mov r15, rsi
push r14
lea r14, [rbp+var_1D0]
push r13
mov r13, rdx
push r12
lea r12, [rbp+var_1E8]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 218h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movaps xmmword ptr [rbp+var_210], xmm0
movaps [rbp+var_200], xmm0
call __ZNSt6localeC1Ev; std::locale::locale(void)
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rcx, r12
pxor xmm0, xmm0
mov r8d, 10h
mov rdi, r14
add rdx, rsi
movaps [rbp+var_1E0], xmm0
call _ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC2EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE; std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(char const*,char const*,std::locale const&,std::regex_constants::syntax_option_type)
movdqa xmm0, [rbp+var_D0]
mov r13, qword ptr [rbp+var_1E0+8]
pxor xmm1, xmm1
movaps [rbp+var_D0], xmm1
movaps [rbp+var_1E0], xmm0
test r13, r13
jz short loc_5DA1
mov rdx, [r13+8]
lea rcx, [r13+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_6100
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_61A0
mov eax, [r13+8]
lea edx, [rax-1]
mov [r13+8], edx
loc_5D98:
cmp eax, 1
jz loc_6270
loc_5DA1:
lea rdi, [rbp+var_A0]
mov [rbp+var_1F0], 10h
call _ZNSt11_Deque_baseINSt8__detail9_StateSeqINSt7__cxx1112regex_traitsIcEEEESaIS5_EED2Ev; std::_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>>::~_Deque_base()
mov rdi, [rbp+var_C0]; void *
lea rax, [rbp+var_B0]
cmp rdi, rax
jz short loc_5DDA
mov rax, [rbp+var_B0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5DDA:
mov r13, qword ptr [rbp+var_D0+8]
test r13, r13
jz short loc_5E22
mov rdx, [r13+8]
lea rcx, [r13+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_60B0
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_61B0
mov eax, [r13+8]
lea edx, [rax-1]
mov [r13+8], edx
loc_5E19:
cmp eax, 1
jz loc_6290
loc_5E22:
mov rdi, [rbp+var_100]; void *
lea rax, [rbp+var_F0]
cmp rdi, rax
jz short loc_5E45
mov rax, [rbp+var_F0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5E45:
lea rax, [rbp+var_1F0]
mov rdi, [r15]
xor r9d, r9d
xor r8d, r8d
sub rsp, 8
mov rsi, [r15+8]
mov [rbp+var_230], rax
mov rcx, rax
push 0
lea r15, [rbp+var_210]
add rsi, rdi
mov rdx, r15
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
pop rdx
pop rcx
test al, al
jz loc_62D8
mov rdx, [rbp+var_210+8]
mov rax, [rbp+var_210]
mov rsi, rdx
sub rsi, rax
cmp rdx, rax
jz loc_5FE0
mov rcx, rax
cmp rsi, 48h ; 'H'
jz loc_5FE0
cmp byte ptr [rcx+10h], 0
jnz loc_5FEF
loc_5EB9:
lea rcx, [rbp+var_1C0]
mov byte ptr [rbp+var_1C0], 0
xor edi, edi
mov [rbp+var_1D0], rcx
mov [rbp+var_1C8], 0
mov [rbp+var_228], rcx
loc_5EE2:
mov rsi, rdx
mov r8, qword ptr [rbp+var_200+8]
sub rsi, rax
cmp rdx, rax
jz loc_6080
mov rdx, [rax]
sub rdx, r8
cmp rsi, 48h ; 'H'
jz loc_6087
cmp byte ptr [rax+10h], 0
jnz loc_6096
loc_5F12:
movd xmm2, edx
pshufd xmm0, xmm2, 0E0h
movq qword ptr [rbx], xmm0
loc_5F1F:
mov rdx, [rbp+var_228]
lea rax, [rbx+18h]
mov [rbx+8], rax
cmp rcx, rdx
jz loc_6140
mov rax, [rbp+var_1C0]
mov [rbx+8], rcx
mov [rbx+18h], rax
loc_5F46:
mov rax, qword ptr [rbp+var_1E0+8]
mov [rbx+10h], rdi
mov rdi, rax
test rax, rax
jz short loc_5F93
mov rdx, [rax+8]
lea rcx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_60D8
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_6190
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_5F8A:
cmp eax, 1
jz loc_6280
loc_5F93:
mov rdi, r12; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rdi, [rbp+var_210]; void *
test rdi, rdi
jz short loc_5FB6
mov rsi, qword ptr [rbp+var_200]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5FB6:
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_62BB
lea rsp, [rbp-28h]
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5FE0:
lea rcx, [rax+rsi-48h]
cmp byte ptr [rcx+10h], 0
jz loc_5EB9
loc_5FEF:
mov rax, [rcx]
mov r13, [rcx+8]
lea rcx, [rbp+var_1C0]
mov [rbp+var_1C8], 0
mov [rbp+var_228], rcx
sub r13, rax
mov [rbp+src], rax
mov [rbp+var_1D0], rcx
mov [rbp+var_218], r13
cmp r13, 0Fh
ja loc_61C0
cmp r13, 1
jnz loc_6128
mov rax, [rbp+src]
movzx eax, byte ptr [rax]
mov byte ptr [rbp+var_1C0], al
mov rax, [rbp+var_228]
loc_6052:
mov [rbp+var_1C8], r13
mov byte ptr [rax+r13], 0
mov rdx, [rbp+var_210+8]
mov rax, [rbp+var_210]
mov rcx, [rbp+var_1D0]
mov rdi, [rbp+var_1C8]
jmp loc_5EE2
loc_6080:
mov rdx, [rax-48h]
sub rdx, r8
loc_6087:
lea rax, [rax+rsi-48h]
cmp byte ptr [rax+10h], 0
jz loc_5F12
loc_6096:
mov rsi, [rax+8]
sub rsi, [rax]
mov [rbx+4], edx
mov rax, rsi
add rax, rdx
mov [rbx], eax
jmp loc_5F1F
loc_60B0:
mov rax, [r13+0]
mov rdi, r13
mov qword ptr [r13+8], 0
call qword ptr [rax+10h]
mov rax, [r13+0]
mov rdi, r13
call qword ptr [rax+18h]
jmp loc_5E22
loc_60D8:
mov rax, [rdi]
mov r15, rdi
mov qword ptr [rdi+8], 0
call qword ptr [rax+10h]
mov rax, [r15]
mov rdi, r15
call qword ptr [rax+18h]
jmp loc_5F93
loc_6100:
mov rax, [r13+0]
mov rdi, r13
mov qword ptr [r13+8], 0
call qword ptr [rax+10h]
mov rax, [r13+0]
mov rdi, r13
call qword ptr [rax+18h]
jmp loc_5DA1
loc_6128:
test r13, r13
jnz loc_62C0
mov rax, [rbp+var_228]
jmp loc_6052
loc_6140:
lea rdx, [rdi+1]
cmp edx, 8
jnb loc_6210
test dl, 4
jnz loc_629D
test edx, edx
jz loc_5F46
movzx ecx, byte ptr [rbp+var_1C0]
mov [rax], cl
test dl, 2
jz loc_5F46
mov rcx, [rbp+var_228]
mov edx, edx
movzx ecx, word ptr [rcx+rdx-2]
mov [rax+rdx-2], cx
jmp loc_5F46
loc_6190:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_5F8A
loc_61A0:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_5D98
loc_61B0:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_5E19
loc_61C0:
lea rsi, [rbp+var_218]
xor edx, edx
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rbp+var_1D0], rax
mov rdi, rax; dest
mov rax, [rbp+var_218]
mov [rbp+var_1C0], rax
loc_61E9:
mov rsi, [rbp+src]; src
mov rdx, r13; n
call _memcpy
mov r13, [rbp+var_218]
mov rax, [rbp+var_1D0]
jmp loc_6052
loc_6210:
mov rcx, [rbp+var_1C0]
mov [rax], rcx
mov r11, [rbp+var_228]
mov ecx, edx
mov rsi, [r11+rcx-8]
mov [rax+rcx-8], rsi
lea rsi, [rax+8]
and rsi, 0FFFFFFFFFFFFFFF8h
sub rax, rsi
add edx, eax
sub r11, rax
and edx, 0FFFFFFF8h
mov r10, r11
cmp edx, 8
jb loc_5F46
and edx, 0FFFFFFF8h
xor eax, eax
loc_6251:
mov ecx, eax
add eax, 8
mov r8, [r10+rcx]
mov [rsi+rcx], r8
cmp eax, edx
jb short loc_6251
jmp loc_5F46
loc_6270:
mov rdi, r13
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE24_M_release_last_use_coldEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(void)
jmp loc_5DA1
loc_6280:
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE24_M_release_last_use_coldEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(void)
jmp loc_5F93
loc_6290:
mov rdi, r13
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE24_M_release_last_use_coldEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(void)
jmp loc_5E22
loc_629D:
mov ecx, dword ptr [rbp+var_1C0]
mov edx, edx
mov [rax], ecx
mov rcx, [rbp+var_228]
mov ecx, [rcx+rdx-4]
mov [rax+rdx-4], ecx
jmp loc_5F46
loc_62BB:
call ___stack_chk_fail
loc_62C0:
mov rdi, [rbp+var_228]
jmp loc_61E9
endbr64
mov rbx, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6__cold; func0(std::string const&,std::string const&) [clone]
loc_62D8:
jmp loc_47A9
endbr64
jmp loc_47EE | long long func0(long long a1, _QWORD *a2, long long *a3)
{
long long v6; // rsi
long long v7; // rdx
__m128i v8; // xmm0
volatile signed __int32 *v9; // r13
long long v10; // rdx
volatile signed __int32 *v11; // rcx
signed __int32 v12; // eax
long long v13; // r13
long long v14; // rdx
volatile signed __int32 *v15; // rcx
signed __int32 v16; // eax
_BYTE *v17; // rdx
_BYTE *v18; // rax
char *v19; // rcx
_QWORD *v20; // rcx
size_t v21; // rdi
long long v22; // r8
unsigned long long v23; // rsi
long long v24; // rdx
_QWORD *v25; // rax
long long v26; // rax
_QWORD *v27; // rax
_QWORD *v28; // rdi
long long v29; // rdx
volatile signed __int32 *v30; // rcx
signed __int32 v31; // eax
_BYTE *v33; // rax
long long v34; // r13
size_t v35; // r13
_QWORD *v36; // rax
long long v37; // rax
long long v38; // rdi
long long v39; // rax
long long v40; // rax
unsigned int v41; // edx
_QWORD *v42; // rdi
char *v43; // rax
char *v44; // r11
unsigned int v45; // edx
unsigned int v46; // edx
unsigned int v47; // eax
long long v48; // rcx
void *src; // [rsp+8h] [rbp-238h]
size_t v50; // [rsp+28h] [rbp-218h] BYREF
void *v51[2]; // [rsp+30h] [rbp-210h] BYREF
__int128 v52; // [rsp+40h] [rbp-200h]
int v53; // [rsp+50h] [rbp-1F0h] BYREF
char v54[8]; // [rsp+58h] [rbp-1E8h] BYREF
__m128i v55; // [rsp+60h] [rbp-1E0h]
_QWORD *v56; // [rsp+70h] [rbp-1D0h] BYREF
size_t v57; // [rsp+78h] [rbp-1C8h]
_QWORD v58[24]; // [rsp+80h] [rbp-1C0h] BYREF
void *v59; // [rsp+140h] [rbp-100h]
long long v60; // [rsp+150h] [rbp-F0h] BYREF
__m128i v61; // [rsp+170h] [rbp-D0h] BYREF
void *v62; // [rsp+180h] [rbp-C0h]
long long v63; // [rsp+190h] [rbp-B0h] BYREF
char v64[104]; // [rsp+1A0h] [rbp-A0h] BYREF
unsigned long long v65; // [rsp+208h] [rbp-38h]
v65 = __readfsqword(0x28u);
*(_OWORD *)v51 = 0LL;
v52 = 0LL;
std::locale::locale((std::locale *)v54);
v6 = *a3;
v7 = *a3 + a3[1];
v55 = 0LL;
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(&v56, v6, v7, v54, 16LL);
v8 = _mm_load_si128(&v61);
v9 = (volatile signed __int32 *)v55.m128i_i64[1];
v61 = 0LL;
v55 = v8;
if ( v9 )
{
v10 = *((_QWORD *)v9 + 1);
v11 = v9 + 2;
if ( v10 == 0x100000001LL )
{
v40 = *(_QWORD *)v9;
*((_QWORD *)v9 + 1) = 0LL;
(*(void ( **)(volatile signed __int32 *, long long, long long, volatile signed __int32 *))(v40 + 16))(
v9,
v6,
0x100000001LL,
v11);
(*(void ( **)(volatile signed __int32 *))(*(_QWORD *)v9 + 24LL))(v9);
}
else
{
if ( _libc_single_threaded )
{
v12 = *((_DWORD *)v9 + 2);
v10 = (unsigned int)(v12 - 1);
*((_DWORD *)v9 + 2) = v10;
}
else
{
v12 = _InterlockedExchangeAdd(v11, 0xFFFFFFFF);
}
if ( v12 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v9, v6, v10, v11);
}
}
v53 = 16;
std::_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>>::~_Deque_base(v64);
if ( v62 != &v63 )
{
v6 = v63 + 1;
operator delete(v62, v63 + 1);
}
v13 = v61.m128i_i64[1];
if ( v61.m128i_i64[1] )
{
v14 = *(_QWORD *)(v61.m128i_i64[1] + 8);
v15 = (volatile signed __int32 *)(v61.m128i_i64[1] + 8);
if ( v14 == 0x100000001LL )
{
v37 = *(_QWORD *)v61.m128i_i64[1];
v38 = v61.m128i_i64[1];
*(_QWORD *)(v61.m128i_i64[1] + 8) = 0LL;
(*(void ( **)(long long, long long, long long, volatile signed __int32 *))(v37 + 16))(
v38,
v6,
0x100000001LL,
v15);
(*(void ( **)(long long))(*(_QWORD *)v13 + 24LL))(v13);
}
else
{
if ( _libc_single_threaded )
{
v16 = *(_DWORD *)(v61.m128i_i64[1] + 8);
v14 = (unsigned int)(v16 - 1);
*(_DWORD *)(v61.m128i_i64[1] + 8) = v14;
}
else
{
v16 = _InterlockedExchangeAdd(v15, 0xFFFFFFFF);
}
if ( v16 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v13, v6, v14, v15);
}
}
if ( v59 != &v60 )
operator delete(v59, v60 + 1);
if ( !(unsigned __int8)std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
*a2,
(unsigned int)*a2 + (unsigned int)a2[1],
(unsigned int)v51,
(unsigned int)&v53,
0,
0,
0) )
JUMPOUT(0x47A9LL);
v17 = v51[1];
v18 = v51[0];
if ( v51[1] == v51[0] || (v19 = (char *)v51[0], (long long *)((char *)v51[1] - (char *)v51[0]) == &qword_48) )
{
v19 = (char *)v51[1] - 72;
if ( !*((_BYTE *)v51[1] - 56) )
goto LABEL_21;
}
else if ( !*((_BYTE *)v51[0] + 16) )
{
LABEL_21:
v20 = v58;
LOBYTE(v58[0]) = 0;
v21 = 0LL;
v56 = v58;
v57 = 0LL;
goto LABEL_22;
}
v33 = *(_BYTE **)v19;
v34 = *((_QWORD *)v19 + 1);
v57 = 0LL;
v35 = v34 - (_QWORD)v33;
src = v33;
v56 = v58;
v50 = v35;
if ( v35 > 0xF )
{
v56 = (_QWORD *)std::string::_M_create(&v56, &v50, 0LL);
v42 = v56;
v58[0] = v50;
goto LABEL_59;
}
if ( v35 != 1 )
{
if ( !v35 )
{
v36 = v58;
goto LABEL_41;
}
v42 = v58;
LABEL_59:
memcpy(v42, src, v35);
v35 = v50;
v36 = v56;
goto LABEL_41;
}
LOBYTE(v58[0]) = *v33;
v36 = v58;
LABEL_41:
v57 = v35;
*((_BYTE *)v36 + v35) = 0;
v17 = v51[1];
v18 = v51[0];
v20 = v56;
v21 = v57;
LABEL_22:
v22 = *((_QWORD *)&v52 + 1);
v23 = v17 - v18;
if ( v17 == v18 )
{
v24 = *((_QWORD *)v18 - 9) - *((_QWORD *)&v52 + 1);
LABEL_43:
v18 = &v18[v23 - 72];
if ( !v18[16] )
goto LABEL_25;
goto LABEL_44;
}
v24 = *(_QWORD *)v18 - *((_QWORD *)&v52 + 1);
if ( v23 == 72 )
goto LABEL_43;
if ( !v18[16] )
{
LABEL_25:
*(_QWORD *)a1 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v24), 224).m128i_u64[0];
goto LABEL_26;
}
LABEL_44:
v23 = *((_QWORD *)v18 + 1) - *(_QWORD *)v18;
*(_DWORD *)(a1 + 4) = v24;
*(_DWORD *)a1 = v24 + v23;
LABEL_26:
v25 = (_QWORD *)(a1 + 24);
*(_QWORD *)(a1 + 8) = a1 + 24;
if ( v20 == v58 )
{
v41 = v21 + 1;
if ( (unsigned int)(v21 + 1) >= 8 )
{
*v25 = v58[0];
*(_QWORD *)((char *)v25 + v41 - 8) = *(_QWORD *)((char *)&v58[-1] + v41);
v23 = (a1 + 32) & 0xFFFFFFFFFFFFFFF8LL;
v43 = (char *)v25 - v23;
v44 = (char *)((char *)v58 - v43);
v45 = ((_DWORD)v43 + v41) & 0xFFFFFFF8;
if ( v45 >= 8 )
{
v46 = v45 & 0xFFFFFFF8;
v47 = 0;
do
{
v48 = v47;
v47 += 8;
v22 = *(_QWORD *)&v44[v48];
*(_QWORD *)(v23 + v48) = v22;
}
while ( v47 < v46 );
}
}
else if ( (v41 & 4) != 0 )
{
*(_DWORD *)v25 = v58[0];
*(_DWORD *)((char *)v25 + v41 - 4) = *(_DWORD *)((char *)&v57 + v41 + 4);
}
else if ( (_DWORD)v21 != -1 )
{
*(_BYTE *)v25 = v58[0];
if ( (v41 & 2) != 0 )
*(_WORD *)((char *)v25 + v41 - 2) = *(_WORD *)((char *)&v57 + v41 + 6);
}
}
else
{
v26 = v58[0];
*(_QWORD *)(a1 + 8) = v20;
*(_QWORD *)(a1 + 24) = v26;
}
v27 = (_QWORD *)v55.m128i_i64[1];
*(_QWORD *)(a1 + 16) = v21;
v28 = v27;
if ( v27 )
{
v29 = v27[1];
v30 = (volatile signed __int32 *)(v27 + 1);
if ( v29 == 0x100000001LL )
{
v39 = *v27;
v28[1] = 0LL;
(*(void ( **)(_QWORD *, unsigned long long, long long, volatile signed __int32 *, long long))(v39 + 16))(
v28,
v23,
0x100000001LL,
v30,
v22);
(*(void ( **)(_QWORD *))(*v28 + 24LL))(v28);
}
else
{
if ( _libc_single_threaded )
{
v31 = *((_DWORD *)v27 + 2);
v29 = (unsigned int)(v31 - 1);
*((_DWORD *)v28 + 2) = v29;
}
else
{
v31 = _InterlockedExchangeAdd(v30, 0xFFFFFFFF);
}
if ( v31 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v28, v23, v29, v30);
}
}
std::locale::~locale((std::locale *)v54);
if ( v51[0] )
operator delete(v51[0], v52 - (unsigned long long)v51[0]);
return a1;
} | func0:
ENDBR64
PUSH RBP
PXOR XMM0,XMM0
MOV RBP,RSP
PUSH R15
MOV R15,RSI
PUSH R14
LEA R14,[RBP + -0x1d0]
PUSH R13
MOV R13,RDX
PUSH R12
LEA R12,[RBP + -0x1e8]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x218
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RBP + -0x210],XMM0
MOVAPS xmmword ptr [RBP + -0x200],XMM0
CALL 0x001046f0
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV RCX,R12
PXOR XMM0,XMM0
MOV R8D,0x10
MOV RDI,R14
ADD RDX,RSI
MOVAPS xmmword ptr [RBP + -0x1e0],XMM0
LAB_00105d3a:
CALL 0x00118640
MOVDQA XMM0,xmmword ptr [RBP + -0xd0]
MOV R13,qword ptr [RBP + -0x1d8]
PXOR XMM1,XMM1
MOVAPS xmmword ptr [RBP + -0xd0],XMM1
MOVAPS xmmword ptr [RBP + -0x1e0],XMM0
TEST R13,R13
JZ 0x00105da1
MOV RDX,qword ptr [R13 + 0x8]
LEA RCX,[R13 + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x00106100
CMP byte ptr [0x00120460],0x0
JZ 0x001061a0
MOV EAX,dword ptr [R13 + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [R13 + 0x8],EDX
LAB_00105d98:
CMP EAX,0x1
JZ 0x00106270
LAB_00105da1:
LEA RDI,[RBP + -0xa0]
MOV dword ptr [RBP + -0x1f0],0x10
CALL 0x001079f0
MOV RDI,qword ptr [RBP + -0xc0]
LEA RAX,[RBP + -0xb0]
CMP RDI,RAX
JZ 0x00105dda
MOV RAX,qword ptr [RBP + -0xb0]
LEA RSI,[RAX + 0x1]
CALL 0x00104560
LAB_00105dda:
MOV R13,qword ptr [RBP + -0xc8]
TEST R13,R13
JZ 0x00105e22
MOV RDX,qword ptr [R13 + 0x8]
LEA RCX,[R13 + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x001060b0
CMP byte ptr [0x00120460],0x0
JZ 0x001061b0
MOV EAX,dword ptr [R13 + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [R13 + 0x8],EDX
LAB_00105e19:
CMP EAX,0x1
JZ 0x00106290
LAB_00105e22:
MOV RDI,qword ptr [RBP + -0x100]
LEA RAX,[RBP + -0xf0]
CMP RDI,RAX
JZ 0x00105e45
MOV RAX,qword ptr [RBP + -0xf0]
LEA RSI,[RAX + 0x1]
CALL 0x00104560
LAB_00105e45:
LEA RAX,[RBP + -0x1f0]
MOV RDI,qword ptr [R15]
XOR R9D,R9D
XOR R8D,R8D
SUB RSP,0x8
MOV RSI,qword ptr [R15 + 0x8]
MOV qword ptr [RBP + -0x230],RAX
MOV RCX,RAX
PUSH 0x0
LEA R15,[RBP + -0x210]
ADD RSI,RDI
MOV RDX,R15
LAB_00105e76:
CALL 0x0010e210
POP RDX
POP RCX
TEST AL,AL
JZ 0x001062d8
MOV RDX,qword ptr [RBP + -0x208]
MOV RAX,qword ptr [RBP + -0x210]
MOV RSI,RDX
SUB RSI,RAX
CMP RDX,RAX
JZ 0x00105fe0
MOV RCX,RAX
CMP RSI,0x48
JZ 0x00105fe0
CMP byte ptr [RCX + 0x10],0x0
JNZ 0x00105fef
LAB_00105eb9:
LEA RCX,[RBP + -0x1c0]
MOV byte ptr [RBP + -0x1c0],0x0
XOR EDI,EDI
MOV qword ptr [RBP + -0x1d0],RCX
MOV qword ptr [RBP + -0x1c8],0x0
MOV qword ptr [RBP + -0x228],RCX
LAB_00105ee2:
MOV RSI,RDX
MOV R8,qword ptr [RBP + -0x1f8]
SUB RSI,RAX
CMP RDX,RAX
JZ 0x00106080
MOV RDX,qword ptr [RAX]
SUB RDX,R8
CMP RSI,0x48
JZ 0x00106087
CMP byte ptr [RAX + 0x10],0x0
JNZ 0x00106096
LAB_00105f12:
MOVD XMM2,EDX
PSHUFD XMM0,XMM2,0xe0
MOVQ qword ptr [RBX],XMM0
LAB_00105f1f:
MOV RDX,qword ptr [RBP + -0x228]
LEA RAX,[RBX + 0x18]
MOV qword ptr [RBX + 0x8],RAX
CMP RCX,RDX
JZ 0x00106140
MOV RAX,qword ptr [RBP + -0x1c0]
MOV qword ptr [RBX + 0x8],RCX
MOV qword ptr [RBX + 0x18],RAX
LAB_00105f46:
MOV RAX,qword ptr [RBP + -0x1d8]
MOV qword ptr [RBX + 0x10],RDI
MOV RDI,RAX
TEST RAX,RAX
JZ 0x00105f93
MOV RDX,qword ptr [RAX + 0x8]
LEA RCX,[RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x001060d8
CMP byte ptr [0x00120460],0x0
JZ 0x00106190
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_00105f8a:
CMP EAX,0x1
JZ 0x00106280
LAB_00105f93:
MOV RDI,R12
CALL 0x00104640
MOV RDI,qword ptr [RBP + -0x210]
TEST RDI,RDI
JZ 0x00105fb6
MOV RSI,qword ptr [RBP + -0x200]
SUB RSI,RDI
CALL 0x00104560
LAB_00105fb6:
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001062bb
LEA RSP,[RBP + -0x28]
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00105fe0:
LEA RCX,[RAX + RSI*0x1 + -0x48]
CMP byte ptr [RCX + 0x10],0x0
JZ 0x00105eb9
LAB_00105fef:
MOV RAX,qword ptr [RCX]
MOV R13,qword ptr [RCX + 0x8]
LEA RCX,[RBP + -0x1c0]
MOV qword ptr [RBP + -0x1c8],0x0
MOV qword ptr [RBP + -0x228],RCX
SUB R13,RAX
MOV qword ptr [RBP + -0x238],RAX
MOV qword ptr [RBP + -0x1d0],RCX
MOV qword ptr [RBP + -0x218],R13
CMP R13,0xf
JA 0x001061c0
CMP R13,0x1
JNZ 0x00106128
MOV RAX,qword ptr [RBP + -0x238]
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x1c0],AL
MOV RAX,qword ptr [RBP + -0x228]
LAB_00106052:
MOV qword ptr [RBP + -0x1c8],R13
MOV byte ptr [RAX + R13*0x1],0x0
MOV RDX,qword ptr [RBP + -0x208]
MOV RAX,qword ptr [RBP + -0x210]
MOV RCX,qword ptr [RBP + -0x1d0]
MOV RDI,qword ptr [RBP + -0x1c8]
JMP 0x00105ee2
LAB_00106080:
MOV RDX,qword ptr [RAX + -0x48]
SUB RDX,R8
LAB_00106087:
LEA RAX,[RAX + RSI*0x1 + -0x48]
CMP byte ptr [RAX + 0x10],0x0
JZ 0x00105f12
LAB_00106096:
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
MOV dword ptr [RBX + 0x4],EDX
MOV RAX,RSI
ADD RAX,RDX
MOV dword ptr [RBX],EAX
JMP 0x00105f1f
LAB_001060b0:
MOV RAX,qword ptr [R13]
MOV RDI,R13
MOV qword ptr [R13 + 0x8],0x0
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R13]
MOV RDI,R13
CALL qword ptr [RAX + 0x18]
JMP 0x00105e22
LAB_001060d8:
MOV RAX,qword ptr [RDI]
MOV R15,RDI
MOV qword ptr [RDI + 0x8],0x0
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R15]
MOV RDI,R15
CALL qword ptr [RAX + 0x18]
JMP 0x00105f93
LAB_00106100:
MOV RAX,qword ptr [R13]
MOV RDI,R13
MOV qword ptr [R13 + 0x8],0x0
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R13]
MOV RDI,R13
CALL qword ptr [RAX + 0x18]
JMP 0x00105da1
LAB_00106128:
TEST R13,R13
JNZ 0x001062c0
MOV RAX,qword ptr [RBP + -0x228]
JMP 0x00106052
LAB_00106140:
LEA RDX,[RDI + 0x1]
CMP EDX,0x8
JNC 0x00106210
TEST DL,0x4
JNZ 0x0010629d
TEST EDX,EDX
JZ 0x00105f46
MOVZX ECX,byte ptr [RBP + -0x1c0]
MOV byte ptr [RAX],CL
TEST DL,0x2
JZ 0x00105f46
MOV RCX,qword ptr [RBP + -0x228]
MOV EDX,EDX
MOVZX ECX,word ptr [RCX + RDX*0x1 + -0x2]
MOV word ptr [RAX + RDX*0x1 + -0x2],CX
JMP 0x00105f46
LAB_00106190:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00105f8a
LAB_001061a0:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00105d98
LAB_001061b0:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00105e19
LAB_001061c0:
LEA RSI,[RBP + -0x218]
XOR EDX,EDX
MOV RDI,R14
CALL 0x001046a0
MOV qword ptr [RBP + -0x1d0],RAX
MOV RDI,RAX
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x1c0],RAX
LAB_001061e9:
MOV RSI,qword ptr [RBP + -0x238]
MOV RDX,R13
CALL 0x00104540
MOV R13,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RBP + -0x1d0]
JMP 0x00106052
LAB_00106210:
MOV RCX,qword ptr [RBP + -0x1c0]
MOV qword ptr [RAX],RCX
MOV R11,qword ptr [RBP + -0x228]
MOV ECX,EDX
MOV RSI,qword ptr [R11 + RCX*0x1 + -0x8]
MOV qword ptr [RAX + RCX*0x1 + -0x8],RSI
LEA RSI,[RAX + 0x8]
AND RSI,-0x8
SUB RAX,RSI
ADD EDX,EAX
SUB R11,RAX
AND EDX,0xfffffff8
MOV R10,R11
CMP EDX,0x8
JC 0x00105f46
AND EDX,0xfffffff8
XOR EAX,EAX
LAB_00106251:
MOV ECX,EAX
ADD EAX,0x8
MOV R8,qword ptr [R10 + RCX*0x1]
MOV qword ptr [RSI + RCX*0x1],R8
CMP EAX,EDX
JC 0x00106251
JMP 0x00105f46
LAB_00106270:
MOV RDI,R13
CALL 0x00107570
JMP 0x00105da1
LAB_00106280:
CALL 0x00107570
JMP 0x00105f93
LAB_00106290:
MOV RDI,R13
CALL 0x00107570
JMP 0x00105e22
LAB_0010629d:
MOV ECX,dword ptr [RBP + -0x1c0]
MOV EDX,EDX
MOV dword ptr [RAX],ECX
MOV RCX,qword ptr [RBP + -0x228]
MOV ECX,dword ptr [RCX + RDX*0x1 + -0x4]
MOV dword ptr [RAX + RDX*0x1 + -0x4],ECX
JMP 0x00105f46
LAB_001062bb:
CALL 0x001045a0
LAB_001062c0:
MOV RDI,qword ptr [RBP + -0x228]
JMP 0x001061e9
LAB_001062d8:
JMP 0x001047a9 | /* func0(std::string const&, std::string const&) */
string * func0(string *param_1,string *param_2)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
char cVar2;
int *__src;
int8 uVar3;
int8 uVar4;
bool bVar5;
uint uVar6;
long lVar7;
string *psVar8;
int8 *puVar9;
int iVar10;
uint uVar11;
int8 *in_RDX;
ulong uVar12;
long in_FS_OFFSET;
ulong *local_230;
ulong local_220;
int local_218 [16];
int local_208 [16];
int4 local_1f8 [2];
locale local_1f0 [2];
int local_1e8 [16];
ulong *local_1d8;
int8 local_1d0;
ulong auStack_1c8 [24];
long *local_108;
long local_f8 [4];
int local_d8 [16];
long *local_c8;
long local_b8 [2];
_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>,std::allocator<std::__detail::_StateSeq<std::regex_traits<char>>>>
local_a8 [104];
long local_40;
local_d8._8_8_ = local_d8._0_8_;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_218 = (int [16])0x0;
local_208 = (int [16])0x0;
std::locale::locale(local_1f0);
local_1e8 = (int [16])0x0;
/* try { // try from 00105d3a to 00105d3e has its CatchHandler @ 001062cc */
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler
((_Compiler<std::regex_traits<char>> *)&local_1d8,(char *)*in_RDX,
(char *)*in_RDX + in_RDX[1],local_1f0,0x10);
uVar4 = local_d8._8_8_;
uVar3 = local_1e8._8_8_;
local_d8 = (int [16])0x0;
local_1e8._8_8_ = uVar4;
if ((_Sp_counted_base<(_Lock_policy)2> *)uVar3 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = (_Sp_counted_base<(_Lock_policy)2> *)(uVar3 + 8);
if (*(long *)(uVar3 + 8) == 0x100000001) {
*(int8 *)(uVar3 + 8) = 0;
(**(code **)(*(long *)uVar3 + 0x10))(uVar3);
(**(code **)(*(long *)uVar3 + 0x18))(uVar3);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar10 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar10 = *(int *)(uVar3 + 8);
*(int *)(uVar3 + 8) = iVar10 + -1;
}
if (iVar10 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)uVar3);
}
}
}
local_1f8[0] = 0x10;
std::
_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>,std::allocator<std::__detail::_StateSeq<std::regex_traits<char>>>>
::~_Deque_base(local_a8);
if (local_c8 != local_b8) {
operator_delete(local_c8,local_b8[0] + 1);
}
uVar3 = local_d8._8_8_;
if ((_Sp_counted_base<(_Lock_policy)2> *)local_d8._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = (_Sp_counted_base<(_Lock_policy)2> *)(local_d8._8_8_ + 8);
if (*(long *)(local_d8._8_8_ + 8) == 0x100000001) {
*(int8 *)(local_d8._8_8_ + 8) = 0;
(**(code **)(*(long *)local_d8._8_8_ + 0x10))(local_d8._8_8_);
(**(code **)(*(long *)uVar3 + 0x18))(uVar3);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar10 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar10 = *(int *)(local_d8._8_8_ + 8);
*(int *)(local_d8._8_8_ + 8) = iVar10 + -1;
}
if (iVar10 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)local_d8._8_8_);
}
}
}
if (local_108 != local_f8) {
operator_delete(local_108,local_f8[0] + 1);
}
/* try { // try from 00105e76 to 001061d0 has its CatchHandler @ 001062dd */
bVar5 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)*(int8 *)param_2,
(int)*(int8 *)(param_2 + 8) + (__normal_iterator)*(int8 *)param_2,
(match_results *)local_218,(regex *)local_1f8,0,0,false);
if (!bVar5) {
psVar8 = (string *)FUN_001047a9();
return psVar8;
}
if ((local_218._8_8_ == local_218._0_8_) || (local_218._8_8_ - local_218._0_8_ == 0x48)) {
puVar9 = (int8 *)(local_218._0_8_ + (local_218._8_8_ - local_218._0_8_) + -0x48);
if (*(char *)(puVar9 + 2) != '\0') goto LAB_00105fef;
LAB_00105eb9:
local_1d8 = auStack_1c8;
auStack_1c8[0] = (ulong)auStack_1c8[0]._1_7_ << 8;
local_1d0 = 0;
}
else {
puVar9 = (int8 *)local_218._0_8_;
if (*(char *)(local_218._0_8_ + 0x10) == '\0') goto LAB_00105eb9;
LAB_00105fef:
__src = (int *)*puVar9;
local_1d8 = auStack_1c8;
local_1d0 = 0;
uVar12 = puVar9[1] - (long)__src;
local_220 = uVar12;
if (uVar12 < 0x10) {
if (uVar12 == 1) {
auStack_1c8[0] = CONCAT71(auStack_1c8[0]._1_7_,*__src);
}
else if (uVar12 != 0) goto LAB_001061e9;
}
else {
local_1d8 = (ulong *)std::string::_M_create((ulong *)&local_1d8,(ulong)&local_220);
auStack_1c8[0] = local_220;
LAB_001061e9:
memcpy(local_1d8,__src,uVar12);
}
*(int *)((long)local_1d8 + local_220) = 0;
local_1d0 = local_220;
}
local_230 = auStack_1c8;
if (local_218._8_8_ == local_218._0_8_) {
iVar10 = (int)*(int8 *)(local_218._0_8_ + -0x48) - local_208._8_4_;
}
else {
iVar10 = (int)*(int8 *)local_218._0_8_ - local_208._8_4_;
if (local_218._8_8_ - local_218._0_8_ != 0x48) {
cVar2 = *(char *)(local_218._0_8_ + 0x10);
puVar9 = (int8 *)local_218._0_8_;
goto joined_r0x00106090;
}
}
puVar9 = (int8 *)(local_218._0_8_ + (local_218._8_8_ - local_218._0_8_) + -0x48);
cVar2 = *(char *)(puVar9 + 2);
joined_r0x00106090:
if (cVar2 == '\0') {
*(ulong *)param_1 = CONCAT44(iVar10,iVar10);
}
else {
uVar3 = puVar9[1];
uVar4 = *puVar9;
*(int *)(param_1 + 4) = iVar10;
*(int *)param_1 = ((int)uVar3 - (int)uVar4) + iVar10;
}
psVar8 = param_1 + 0x18;
*(string **)(param_1 + 8) = psVar8;
if (local_1d8 == local_230) {
uVar12 = local_1d0 + 1;
uVar11 = (uint)uVar12;
if (uVar11 < 8) {
if ((uVar12 & 4) == 0) {
if (uVar11 != 0) {
*psVar8 = auStack_1c8[0]._0_1_;
if ((uVar12 & 2) != 0) {
*(int2 *)(param_1 + (uVar12 & 0xffffffff) + 0x16) =
*(int2 *)((long)auStack_1c8 + ((uVar12 & 0xffffffff) - 2));
}
}
}
else {
*(int4 *)psVar8 = (int4)auStack_1c8[0];
*(int4 *)(param_1 + (uVar12 & 0xffffffff) + 0x14) =
*(int4 *)((long)auStack_1c8 + ((uVar12 & 0xffffffff) - 4));
}
}
else {
*(ulong *)psVar8 = auStack_1c8[0];
*(int8 *)(param_1 + (uVar12 & 0xffffffff) + 0x10) =
*(int8 *)((long)auStack_1c8 + ((uVar12 & 0xffffffff) - 8));
lVar7 = (long)psVar8 - ((ulong)(param_1 + 0x20) & 0xfffffffffffffff8);
uVar11 = uVar11 + (int)lVar7 & 0xfffffff8;
if (7 < uVar11) {
uVar6 = 0;
do {
uVar12 = (ulong)uVar6;
uVar6 = uVar6 + 8;
*(int8 *)(((ulong)(param_1 + 0x20) & 0xfffffffffffffff8) + uVar12) =
*(int8 *)((long)local_230 + (uVar12 - lVar7));
} while (uVar6 < uVar11);
}
}
}
else {
*(ulong **)(param_1 + 8) = local_1d8;
*(ulong *)(param_1 + 0x18) = auStack_1c8[0];
}
*(ulong *)(param_1 + 0x10) = local_1d0;
if ((_Sp_counted_base<(_Lock_policy)2> *)local_1e8._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = (_Sp_counted_base<(_Lock_policy)2> *)(local_1e8._8_8_ + 8);
if (*(long *)(local_1e8._8_8_ + 8) == 0x100000001) {
*(int8 *)(local_1e8._8_8_ + 8) = 0;
(**(code **)(*(long *)local_1e8._8_8_ + 0x10))();
(**(code **)(*(long *)local_1e8._8_8_ + 0x18))(local_1e8._8_8_);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar10 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar10 = *(int *)(local_1e8._8_8_ + 8);
*(int *)(local_1e8._8_8_ + 8) = iVar10 + -1;
}
if (iVar10 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)local_1e8._8_8_);
}
}
}
std::locale::~locale(local_1f0);
if ((void *)local_218._0_8_ != (void *)0x0) {
operator_delete((void *)local_218._0_8_,local_208._0_8_ - local_218._0_8_);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,427 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::tuple<std::string, int, int> func0(const std::string& text, const std::string& pattern) {
std::smatch match;
std::regex re(pattern);
if (std::regex_search(text, match, re)) {
return {match.str(), match.position(), match.position() + match.length()};
}
throw std::runtime_error("Pattern not found");
}
| int main() {
assert((func0("The quick brown fox jumps over the lazy dog.", "fox") == std::make_tuple("fox", 16, 19)));
assert((func0("Its been a very crazy procedure right", "crazy") == std::make_tuple("crazy", 16, 21)));
assert((func0("Hardest choices required strongest will", "will") == std::make_tuple("will", 35, 39)));
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
mov %rsi,%r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x208,%rsp
mov 0x8(%rdx),%r14
mov (%rdx),%rbx
mov %fs:0x28,%rax
mov %rax,0x1f8(%rsp)
xor %eax,%eax
lea 0x18(%rsp),%rbp
lea 0x48(%rsp),%r13
movaps %xmm0,0x20(%rsp)
mov %rbp,%rdi
movaps %xmm0,0x30(%rsp)
callq 47d0 <_ZNSt6localeC1Ev@plt>
mov %rbp,%rsi
mov %r13,%rdi
movl $0x10,0x40(%rsp)
callq 4550 <_ZNSt6localeC1ERKS_@plt>
test %r14,%r14
mov $0x0,%eax
mov %r13,%rcx
cmove %rax,%rbx
mov 0x40(%rsp),%r8d
lea (%rbx,%r14,1),%rdx
lea 0x60(%rsp),%r14
mov %rbx,%rsi
mov %r14,%rdi
callq 198a0 <_ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC1EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE>
movdqa 0x160(%rsp),%xmm1
mov 0x190(%rsp),%rdi
pxor %xmm0,%xmm0
movaps %xmm0,0x160(%rsp)
movaps %xmm1,0x50(%rsp)
test %rdi,%rdi
je 57f6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0xf6>
mov 0x1d8(%rsp),%rax
mov 0x1b8(%rsp),%rbx
add $0x8,%rax
cmp %rbx,%rax
jbe 57f1 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0xf1>
mov (%rbx),%rdi
mov %rax,(%rsp)
add $0x8,%rbx
callq 4600 <_ZdlPv@plt>
mov (%rsp),%rax
cmp %rbx,%rax
ja 57d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0xd0>
mov 0x190(%rsp),%rdi
callq 4600 <_ZdlPv@plt>
mov 0x170(%rsp),%rdi
lea 0x180(%rsp),%rax
cmp %rax,%rdi
je 5810 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x110>
callq 4600 <_ZdlPv@plt>
mov 0x168(%rsp),%rbx
test %rbx,%rbx
je 5840 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x140>
mov 0x1c78c(%rip),%rax
test %rax,%rax
je 5a90 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x390>
mov $0xffffffff,%edx
lock xadd %edx,0x8(%rbx)
cmp $0x1,%edx
je 5aa2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3a2>
mov 0x130(%rsp),%rdi
lea 0x140(%rsp),%rax
cmp %rax,%rdi
je 585a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x15a>
callq 4600 <_ZdlPv@plt>
mov %rbp,%rdi
callq 4700 <_ZNSt6localeD1Ev@plt>
mov (%r15),%rdi
mov 0x8(%r15),%rsi
xor %r8d,%r8d
lea 0x40(%rsp),%r15
lea 0x20(%rsp),%rdx
add %rdi,%rsi
mov %r15,%rcx
callq bb10 <_ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE>
test %al,%al
je 5b8d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x48d>
mov 0x28(%rsp),%rdx
mov 0x20(%rsp),%rax
mov %rdx,%rcx
sub %rax,%rcx
cmp %rax,%rdx
je 59a8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2a8>
mov %rax,%rsi
cmp $0x48,%rcx
je 59a8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2a8>
cmpb $0x0,0x10(%rsi)
jne 59b7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2b7>
lea 0x70(%rsp),%rbx
movb $0x0,0x70(%rsp)
mov 0x38(%rsp),%rdi
xor %r8d,%r8d
mov %rbx,0x60(%rsp)
mov %rbx,%rsi
movq $0x0,0x68(%rsp)
cmp %rdx,%rax
je 5a2d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x32d>
mov (%rax),%rdx
sub %rdi,%rdx
cmpb $0x0,0x10(%rax)
mov %rdx,%rcx
je 58fe <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1fe>
mov 0x8(%rax),%rcx
sub (%rax),%rcx
add %rdx,%rcx
lea 0x18(%r12),%rax
mov %ecx,(%r12)
mov %edx,0x4(%r12)
mov %rax,0x8(%r12)
cmp %rbx,%rsi
je 5ae0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3e0>
mov 0x70(%rsp),%rax
mov %rsi,0x8(%r12)
mov %rax,0x18(%r12)
mov 0x58(%rsp),%rbp
mov %r8,0x10(%r12)
test %rbp,%rbp
je 5960 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x260>
mov 0x1c671(%rip),%rax
test %rax,%rax
je 5a40 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x340>
mov $0xffffffff,%edx
lock xadd %edx,0x8(%rbp)
cmp $0x1,%edx
je 5a52 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x352>
nopl 0x0(%rax,%rax,1)
mov %r13,%rdi
callq 4700 <_ZNSt6localeD1Ev@plt>
mov 0x20(%rsp),%rdi
test %rdi,%rdi
je 5977 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x277>
callq 4600 <_ZdlPv@plt>
mov 0x1f8(%rsp),%rax
xor %fs:0x28,%rax
jne 5b6e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x46e>
add $0x208,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
lea -0x48(%rax,%rcx,1),%rsi
cmpb $0x0,0x10(%rsi)
je 58b9 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1b9>
mov (%rsi),%rcx
mov 0x8(%rsi),%rax
lea 0x70(%rsp),%rbx
mov %rbx,0x60(%rsp)
sub %rcx,%rax
mov %rcx,0x8(%rsp)
mov %rax,(%rsp)
mov %rax,0x18(%rsp)
cmp $0xf,%rax
ja 5b10 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x410>
cmpq $0x1,(%rsp)
jne 5af8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3f8>
movzbl (%rcx),%eax
mov %al,0x70(%rsp)
mov %rbx,%rax
mov (%rsp),%rcx
mov %rcx,0x68(%rsp)
movb $0x0,(%rax,%rcx,1)
mov 0x28(%rsp),%rdx
mov 0x20(%rsp),%rax
mov 0x60(%rsp),%rsi
mov %rdx,%rcx
mov 0x68(%rsp),%r8
mov 0x38(%rsp),%rdi
sub %rax,%rcx
cmp %rdx,%rax
jne 58e5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1e5>
lea -0x48(%rax,%rcx,1),%rax
jmpq 58e5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x1e5>
nopw 0x0(%rax,%rax,1)
mov 0x8(%rbp),%edx
lea -0x1(%rdx),%ecx
mov %ecx,0x8(%rbp)
cmp $0x1,%edx
jne 5960 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x260>
mov 0x0(%rbp),%rdx
mov %rax,(%rsp)
mov %rbp,%rdi
callq *0x10(%rdx)
mov (%rsp),%rax
test %rax,%rax
je 5b50 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x450>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 5960 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x260>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 5960 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x260>
mov 0x8(%rbx),%edx
lea -0x1(%rdx),%ecx
mov %ecx,0x8(%rbx)
cmp $0x1,%edx
jne 5840 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x140>
mov (%rbx),%rdx
mov %rax,(%rsp)
mov %rbx,%rdi
callq *0x10(%rdx)
mov (%rsp),%rax
test %rax,%rax
je 5b60 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x460>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbx)
cmp $0x1,%eax
jne 5840 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x140>
mov (%rbx),%rax
mov %rbx,%rdi
callq *0x18(%rax)
jmpq 5840 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x140>
nopl (%rax)
movdqa 0x70(%rsp),%xmm2
movups %xmm2,0x18(%r12)
jmpq 5929 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x229>
nopl 0x0(%rax)
cmpq $0x0,(%rsp)
jne 5b73 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x473>
mov %rbx,%rax
jmpq 59f8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2f8>
nopw 0x0(%rax,%rax,1)
xor %edx,%edx
mov %rbp,%rsi
mov %r14,%rdi
callq 4770 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,0x60(%rsp)
mov %rax,%rdi
mov 0x18(%rsp),%rax
mov %rax,0x70(%rsp)
mov (%rsp),%rdx
mov 0x8(%rsp),%rsi
callq 45c0 <memcpy@plt>
mov 0x18(%rsp),%rax
mov %rax,(%rsp)
mov 0x60(%rsp),%rax
jmpq 59f8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x2f8>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmpq 5a77 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x377>
xchg %ax,%ax
mov 0xc(%rbx),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbx)
jmpq 5ac6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x3c6>
callq 4660 <__stack_chk_fail@plt>
mov %rbx,%rdi
jmp 5b2f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_+0x42f>
endbr64
mov %rax,%rbx
jmpq 4856 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_.cold>
endbr64
jmpq 4884 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_.cold+0x2e>
jmpq 4891 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_.cold+0x3b>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
endbr64
push rbp
pxor xmm0, xmm0
mov rbp, rsp
push r15
mov r15, rsi
push r14
mov r14, rdx
push r13
lea r13, [rbp+var_1D0]
push r12
lea r12, [rbp+var_1E8]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 218h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movaps [rbp+var_210], xmm0
movaps [rbp+var_200], xmm0
call __ZNSt6localeC1Ev; std::locale::locale(void)
mov rsi, [r14]
mov rdx, [r14+8]
pxor xmm0, xmm0
mov r8d, 10h
mov rcx, r12
mov rdi, r13
movaps [rbp+var_1E0], xmm0
add rdx, rsi
call _ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC2EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE; std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(char const*,char const*,std::locale const&,std::regex_constants::syntax_option_type)
movdqa xmm0, [rbp+var_D0]
mov rdi, qword ptr [rbp+var_1E0+8]
pxor xmm1, xmm1
movaps [rbp+var_D0], xmm1
movaps [rbp+var_1E0], xmm0
test rdi, rdi
jz short loc_5E99
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5E99:
mov rdi, [rbp+var_A0]
mov [rbp+var_1F0], 10h
test rdi, rdi
jz short loc_5F13
mov rax, [rbp+var_58]
lea r14, [rax+8]
mov rax, [rbp+var_78]
mov [rbp+var_228], rax
cmp rax, r14
jnb short loc_5EFF
nop word ptr [rax+rax+00000000h]
loc_5ED0:
mov rax, [rbp+var_228]
mov esi, 1F8h; unsigned __int64
mov rdi, [rax]; void *
call __ZdlPvm; operator delete(void *,ulong)
add [rbp+var_228], 8
mov rax, [rbp+var_228]
cmp rax, r14
jb short loc_5ED0
mov rdi, [rbp+var_A0]; void *
loc_5EFF:
mov rax, [rbp+var_98]
lea rsi, ds:0[rax*8]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5F13:
lea rdi, [rbp+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rdi, qword ptr [rbp+var_D0+8]
test rdi, rdi
jz short loc_5F30
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5F30:
lea rdi, [rbp+var_100]
lea r14, [rbp+var_210]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
sub rsp, 8
mov rdi, [r15]
mov rsi, [r15+8]
lea rax, [rbp+var_1F0]
xor r9d, r9d
xor r8d, r8d
mov rdx, r14
mov [rbp+var_230], rax
add rsi, rdi
mov rcx, rax
push 0
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
pop rdx
pop rcx
test al, al
jz loc_62AA
mov rdx, qword ptr [rbp+var_210+8]
mov rax, qword ptr [rbp+var_210]
mov rsi, rdx
sub rsi, rax
cmp rdx, rax
jz loc_60A0
mov rcx, rax
cmp rsi, 48h ; 'H'
jz loc_60A0
cmp byte ptr [rcx+10h], 0
jnz loc_60AF
loc_5FB0:
lea rcx, [rbp+var_1C0]
mov byte ptr [rbp+var_1C0], 0
xor r9d, r9d
mov r8, qword ptr [rbp+var_200+8]
mov [rbp+var_1D0], rcx
mov [rbp+var_1C8], 0
mov [rbp+var_228], rcx
cmp rdx, rax
jz loc_6149
loc_5FEA:
mov rdx, [rax]
sub rdx, r8
cmp byte ptr [rax+10h], 0
mov rdi, rdx
jnz loc_6165
loc_5FFD:
mov [rbx], edx
loc_5FFF:
mov rdx, [rbp+var_228]
lea rax, [rbx+18h]
mov [rbx+4], edi
mov [rbx+8], rax
cmp rcx, rdx
jz loc_6198
mov rax, [rbp+var_1C0]
mov [rbx+8], rcx
mov [rbx+18h], rax
loc_6029:
mov [rbx+10h], r9
mov rdi, r13
mov rax, [rbp+var_228]
mov [rbp+var_1C8], 0
mov [rbp+var_1D0], rax
mov byte ptr [rbp+var_1C0], 0
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rdi, qword ptr [rbp+var_1E0+8]
test rdi, rdi
jz short loc_6066
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_6066:
mov rdi, r12; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rdi, r14
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector()
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_62A5
lea rsp, [rbp-28h]
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_60A0:
lea rcx, [rax+rsi-48h]
cmp byte ptr [rcx+10h], 0
jz loc_5FB0
loc_60AF:
mov rax, [rcx]
mov r15, [rcx+8]
lea rcx, [rbp+var_1C0]
mov [rbp+var_1C8], 0
mov [rbp+var_228], rcx
sub r15, rax
mov [rbp+src], rax
mov [rbp+var_1D0], rcx
mov [rbp+var_218], r15
cmp r15, 0Fh
ja loc_61E0
cmp r15, 1
jnz loc_6180
movzx eax, byte ptr [rax]
mov byte ptr [rbp+var_1C0], al
loc_6104:
mov rax, [rbp+var_228]
loc_610B:
mov [rbp+var_1C8], r15
mov byte ptr [rax+r15], 0
mov rdx, qword ptr [rbp+var_210+8]
mov rax, qword ptr [rbp+var_210]
mov rcx, [rbp+var_1D0]
mov rsi, rdx
mov r9, [rbp+var_1C8]
mov r8, qword ptr [rbp+var_200+8]
sub rsi, rax
cmp rdx, rax
jnz loc_5FEA
loc_6149:
mov rdi, [rax-48h]
lea rax, [rax+rsi-48h]
mov rdx, [rax]
sub rdi, r8
sub rdx, r8
cmp byte ptr [rax+10h], 0
jz loc_5FFD
loc_6165:
mov rsi, [rax+8]
sub rsi, [rax]
mov rax, rsi
add rax, rdx
mov [rbx], eax
jmp loc_5FFF
loc_6180:
test r15, r15
jz loc_6104
mov rdi, [rbp+var_228]
jmp short loc_6209
loc_6198:
lea rdx, [r9+1]
cmp edx, 8
jnb loc_6230
test dl, 4
jnz loc_6287
test edx, edx
jz loc_6029
movzx ecx, byte ptr [rbp+var_1C0]
mov [rax], cl
test dl, 2
jz loc_6029
mov rcx, [rbp+var_228]
mov edx, edx
movzx ecx, word ptr [rcx+rdx-2]
mov [rax+rdx-2], cx
jmp loc_6029
loc_61E0:
lea rsi, [rbp+var_218]
xor edx, edx
mov rdi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rbp+var_1D0], rax
mov rdi, rax; dest
mov rax, [rbp+var_218]
mov [rbp+var_1C0], rax
loc_6209:
mov rsi, [rbp+src]; src
mov rdx, r15; n
call _memcpy
mov r15, [rbp+var_218]
mov rax, [rbp+var_1D0]
jmp loc_610B
loc_6230:
mov rcx, [rbp+var_1C0]
mov [rax], rcx
mov rdi, [rbp+var_228]
mov ecx, edx
mov rsi, [rdi+rcx-8]
mov [rax+rcx-8], rsi
lea rsi, [rax+8]
and rsi, 0FFFFFFFFFFFFFFF8h
sub rax, rsi
add edx, eax
sub rdi, rax
and edx, 0FFFFFFF8h
mov r8, rdi
cmp edx, 8
jb loc_6029
and edx, 0FFFFFFF8h
xor eax, eax
loc_6271:
mov ecx, eax
add eax, 8
mov rdi, [r8+rcx]
mov [rsi+rcx], rdi
cmp eax, edx
jb short loc_6271
jmp loc_6029
loc_6287:
mov ecx, dword ptr [rbp+var_1C0]
mov edx, edx
mov [rax], ecx
mov rcx, [rbp+var_228]
mov ecx, [rcx+rdx-4]
mov [rax+rdx-4], ecx
jmp loc_6029
loc_62A5:
call ___stack_chk_fail
loc_62AA:
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6__cold; func0(std::string const&,std::string const&) [clone]
endbr64
jmp loc_4813
endbr64
mov rbx, rax
jmp loc_4818 | long long func0(long long a1, long long *a2, long long *a3)
{
long long v6; // rsi
long long v7; // rdx
__m128i v8; // xmm0
long long v9; // rdi
void *v10; // rdi
unsigned long long v11; // r14
long long v12; // rdi
long long v13; // rsi
long long v14; // rax
long long v15; // rsi
long long v16; // rcx
_QWORD *v17; // rcx
size_t v18; // r9
long long v19; // r8
long long v20; // rdx
int v21; // edi
_QWORD *v22; // rax
long long v23; // rax
_BYTE *v25; // rax
long long v26; // r15
size_t v27; // r15
_QWORD *v28; // rax
long long v29; // rdi
_QWORD *v30; // rdi
unsigned int v31; // edx
unsigned long long v32; // rsi
char *v33; // rax
unsigned int v34; // edx
char *v35; // r8
unsigned int v36; // edx
unsigned int v37; // eax
long long v38; // rcx
long long v39; // [rsp-10h] [rbp-250h]
void *src; // [rsp+8h] [rbp-238h]
void **v41; // [rsp+18h] [rbp-228h]
size_t v42; // [rsp+28h] [rbp-218h] BYREF
__int128 v43; // [rsp+30h] [rbp-210h] BYREF
__int128 v44; // [rsp+40h] [rbp-200h]
int v45; // [rsp+50h] [rbp-1F0h] BYREF
char v46[8]; // [rsp+58h] [rbp-1E8h] BYREF
__m128i v47; // [rsp+60h] [rbp-1E0h]
_QWORD *v48; // [rsp+70h] [rbp-1D0h] BYREF
size_t v49; // [rsp+78h] [rbp-1C8h]
_QWORD v50[24]; // [rsp+80h] [rbp-1C0h] BYREF
char v51[48]; // [rsp+140h] [rbp-100h] BYREF
__m128i v52; // [rsp+170h] [rbp-D0h] BYREF
char v53[32]; // [rsp+180h] [rbp-C0h] BYREF
void *v54; // [rsp+1A0h] [rbp-A0h]
long long v55; // [rsp+1A8h] [rbp-98h]
unsigned long long v56; // [rsp+1C8h] [rbp-78h]
long long v57; // [rsp+1E8h] [rbp-58h]
unsigned long long v58; // [rsp+208h] [rbp-38h]
v58 = __readfsqword(0x28u);
v43 = 0LL;
v44 = 0LL;
std::locale::locale((std::locale *)v46);
v6 = *a3;
v7 = a3[1];
v47 = 0LL;
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(&v48, v6, v6 + v7, v46, 16LL);
v8 = _mm_load_si128(&v52);
v9 = v47.m128i_i64[1];
v52 = 0LL;
v47 = v8;
if ( v9 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
v10 = v54;
v45 = 16;
if ( v54 )
{
v11 = v57 + 8;
v41 = (void **)v56;
if ( v56 < v57 + 8 )
{
do
operator delete(*v41++, 0x1F8uLL);
while ( (unsigned long long)v41 < v11 );
v10 = v54;
}
operator delete(v10, 8 * v55);
}
std::string::_M_dispose(v53);
if ( v52.m128i_i64[1] )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
std::string::_M_dispose(v51);
v12 = *a2;
v13 = *a2 + a2[1];
if ( !(unsigned __int8)std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
*a2,
v13,
(unsigned int)&v43,
(unsigned int)&v45,
0,
0,
0) )
func0(v12, v13, v39);
v14 = v43;
v15 = *((_QWORD *)&v43 + 1) - v43;
if ( *((_QWORD *)&v43 + 1) == (_QWORD)v43 || (v16 = v43, v15 == 72) )
{
v16 = *((_QWORD *)&v43 + 1) - 72LL;
if ( !*(_BYTE *)(*((_QWORD *)&v43 + 1) - 72LL + 16) )
{
LABEL_14:
v17 = v50;
LOBYTE(v50[0]) = 0;
v18 = 0LL;
v19 = *((_QWORD *)&v44 + 1);
v48 = v50;
v49 = 0LL;
if ( *((_QWORD *)&v43 + 1) != (_QWORD)v43 )
goto LABEL_15;
LABEL_28:
v29 = *(_QWORD *)(v14 - 72);
v14 = v14 + v15 - 72;
v21 = v29 - v19;
v20 = *(_QWORD *)v14 - v19;
if ( !*(_BYTE *)(v14 + 16) )
goto LABEL_16;
goto LABEL_29;
}
}
else if ( !*(_BYTE *)(v43 + 16) )
{
goto LABEL_14;
}
v25 = *(_BYTE **)v16;
v26 = *(_QWORD *)(v16 + 8);
v49 = 0LL;
v27 = v26 - (_QWORD)v25;
src = v25;
v48 = v50;
v42 = v27;
if ( v27 > 0xF )
{
v48 = (_QWORD *)std::string::_M_create(&v48, &v42, 0LL);
v30 = v48;
v50[0] = v42;
}
else
{
if ( v27 == 1 )
{
LOBYTE(v50[0]) = *v25;
LABEL_26:
v28 = v50;
goto LABEL_27;
}
if ( !v27 )
goto LABEL_26;
v30 = v50;
}
memcpy(v30, src, v27);
v27 = v42;
v28 = v48;
LABEL_27:
v49 = v27;
*((_BYTE *)v28 + v27) = 0;
v14 = v43;
v17 = v48;
v18 = v49;
v19 = *((_QWORD *)&v44 + 1);
v15 = *((_QWORD *)&v43 + 1) - v43;
if ( *((_QWORD *)&v43 + 1) == (_QWORD)v43 )
goto LABEL_28;
LABEL_15:
v20 = *(_QWORD *)v14 - v19;
v21 = v20;
if ( !*(_BYTE *)(v14 + 16) )
{
LABEL_16:
*(_DWORD *)a1 = v20;
goto LABEL_17;
}
LABEL_29:
*(_DWORD *)a1 = v20 + *(_DWORD *)(v14 + 8) - *(_DWORD *)v14;
LABEL_17:
v22 = (_QWORD *)(a1 + 24);
*(_DWORD *)(a1 + 4) = v21;
*(_QWORD *)(a1 + 8) = a1 + 24;
if ( v17 == v50 )
{
v31 = v18 + 1;
if ( (unsigned int)(v18 + 1) >= 8 )
{
*v22 = v50[0];
*(_QWORD *)((char *)v22 + v31 - 8) = *(_QWORD *)((char *)&v50[-1] + v31);
v32 = (a1 + 32) & 0xFFFFFFFFFFFFFFF8LL;
v33 = (char *)v22 - v32;
v34 = ((_DWORD)v33 + v31) & 0xFFFFFFF8;
v35 = (char *)((char *)v50 - v33);
if ( v34 >= 8 )
{
v36 = v34 & 0xFFFFFFF8;
v37 = 0;
do
{
v38 = v37;
v37 += 8;
*(_QWORD *)(v32 + v38) = *(_QWORD *)&v35[v38];
}
while ( v37 < v36 );
}
}
else if ( (v31 & 4) != 0 )
{
*(_DWORD *)v22 = v50[0];
*(_DWORD *)((char *)v22 + v31 - 4) = *(_DWORD *)((char *)&v49 + v31 + 4);
}
else if ( (_DWORD)v18 != -1 )
{
*(_BYTE *)v22 = v50[0];
if ( (v31 & 2) != 0 )
*(_WORD *)((char *)v22 + v31 - 2) = *(_WORD *)((char *)&v49 + v31 + 6);
}
}
else
{
v23 = v50[0];
*(_QWORD *)(a1 + 8) = v17;
*(_QWORD *)(a1 + 24) = v23;
}
*(_QWORD *)(a1 + 16) = v18;
v49 = 0LL;
v48 = v50;
LOBYTE(v50[0]) = 0;
std::string::_M_dispose(&v48);
if ( v47.m128i_i64[1] )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
std::locale::~locale((std::locale *)v46);
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v43);
return a1;
} | func0:
ENDBR64
PUSH RBP
PXOR XMM0,XMM0
MOV RBP,RSP
PUSH R15
MOV R15,RSI
PUSH R14
MOV R14,RDX
PUSH R13
LEA R13,[RBP + -0x1d0]
PUSH R12
LEA R12,[RBP + -0x1e8]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x218
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RBP + -0x210],XMM0
MOVAPS xmmword ptr [RBP + -0x200],XMM0
CALL 0x00104730
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
PXOR XMM0,XMM0
MOV R8D,0x10
MOV RCX,R12
MOV RDI,R13
MOVAPS xmmword ptr [RBP + -0x1e0],XMM0
ADD RDX,RSI
LAB_00105e69:
CALL 0x001192d0
MOVDQA XMM0,xmmword ptr [RBP + -0xd0]
MOV RDI,qword ptr [RBP + -0x1d8]
PXOR XMM1,XMM1
MOVAPS xmmword ptr [RBP + -0xd0],XMM1
MOVAPS xmmword ptr [RBP + -0x1e0],XMM0
TEST RDI,RDI
JZ 0x00105e99
CALL 0x00107510
LAB_00105e99:
MOV RDI,qword ptr [RBP + -0xa0]
MOV dword ptr [RBP + -0x1f0],0x10
TEST RDI,RDI
JZ 0x00105f13
MOV RAX,qword ptr [RBP + -0x58]
LEA R14,[RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x228],RAX
CMP RAX,R14
JNC 0x00105eff
NOP word ptr [RAX + RAX*0x1]
LAB_00105ed0:
MOV RAX,qword ptr [RBP + -0x228]
MOV ESI,0x1f8
MOV RDI,qword ptr [RAX]
CALL 0x001045a0
ADD qword ptr [RBP + -0x228],0x8
MOV RAX,qword ptr [RBP + -0x228]
CMP RAX,R14
JC 0x00105ed0
MOV RDI,qword ptr [RBP + -0xa0]
LAB_00105eff:
MOV RAX,qword ptr [RBP + -0x98]
LEA RSI,[RAX*0x8]
CALL 0x001045a0
LAB_00105f13:
LEA RDI,[RBP + -0xc0]
CALL 0x00104620
MOV RDI,qword ptr [RBP + -0xc8]
TEST RDI,RDI
JZ 0x00105f30
CALL 0x00107510
LAB_00105f30:
LEA RDI,[RBP + -0x100]
LEA R14,[RBP + -0x210]
CALL 0x00104620
SUB RSP,0x8
MOV RDI,qword ptr [R15]
MOV RSI,qword ptr [R15 + 0x8]
LEA RAX,[RBP + -0x1f0]
XOR R9D,R9D
XOR R8D,R8D
MOV RDX,R14
MOV qword ptr [RBP + -0x230],RAX
ADD RSI,RDI
MOV RCX,RAX
PUSH 0x0
LAB_00105f6d:
CALL 0x001115b0
POP RDX
POP RCX
TEST AL,AL
JZ 0x001062aa
MOV RDX,qword ptr [RBP + -0x208]
MOV RAX,qword ptr [RBP + -0x210]
MOV RSI,RDX
SUB RSI,RAX
CMP RDX,RAX
JZ 0x001060a0
MOV RCX,RAX
CMP RSI,0x48
JZ 0x001060a0
CMP byte ptr [RCX + 0x10],0x0
JNZ 0x001060af
LAB_00105fb0:
LEA RCX,[RBP + -0x1c0]
MOV byte ptr [RBP + -0x1c0],0x0
XOR R9D,R9D
MOV R8,qword ptr [RBP + -0x1f8]
MOV qword ptr [RBP + -0x1d0],RCX
MOV qword ptr [RBP + -0x1c8],0x0
MOV qword ptr [RBP + -0x228],RCX
CMP RDX,RAX
JZ 0x00106149
LAB_00105fea:
MOV RDX,qword ptr [RAX]
SUB RDX,R8
CMP byte ptr [RAX + 0x10],0x0
MOV RDI,RDX
JNZ 0x00106165
LAB_00105ffd:
MOV dword ptr [RBX],EDX
LAB_00105fff:
MOV RDX,qword ptr [RBP + -0x228]
LEA RAX,[RBX + 0x18]
MOV dword ptr [RBX + 0x4],EDI
MOV qword ptr [RBX + 0x8],RAX
CMP RCX,RDX
JZ 0x00106198
MOV RAX,qword ptr [RBP + -0x1c0]
MOV qword ptr [RBX + 0x8],RCX
MOV qword ptr [RBX + 0x18],RAX
LAB_00106029:
MOV qword ptr [RBX + 0x10],R9
MOV RDI,R13
MOV RAX,qword ptr [RBP + -0x228]
MOV qword ptr [RBP + -0x1c8],0x0
MOV qword ptr [RBP + -0x1d0],RAX
MOV byte ptr [RBP + -0x1c0],0x0
CALL 0x00104620
MOV RDI,qword ptr [RBP + -0x1d8]
TEST RDI,RDI
JZ 0x00106066
CALL 0x00107510
LAB_00106066:
MOV RDI,R12
CALL 0x00104680
MOV RDI,R14
CALL 0x00107590
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001062a5
LEA RSP,[RBP + -0x28]
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001060a0:
LEA RCX,[RAX + RSI*0x1 + -0x48]
CMP byte ptr [RCX + 0x10],0x0
JZ 0x00105fb0
LAB_001060af:
MOV RAX,qword ptr [RCX]
MOV R15,qword ptr [RCX + 0x8]
LEA RCX,[RBP + -0x1c0]
MOV qword ptr [RBP + -0x1c8],0x0
MOV qword ptr [RBP + -0x228],RCX
SUB R15,RAX
MOV qword ptr [RBP + -0x238],RAX
MOV qword ptr [RBP + -0x1d0],RCX
MOV qword ptr [RBP + -0x218],R15
CMP R15,0xf
JA 0x001061e0
CMP R15,0x1
JNZ 0x00106180
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x1c0],AL
LAB_00106104:
MOV RAX,qword ptr [RBP + -0x228]
LAB_0010610b:
MOV qword ptr [RBP + -0x1c8],R15
MOV byte ptr [RAX + R15*0x1],0x0
MOV RDX,qword ptr [RBP + -0x208]
MOV RAX,qword ptr [RBP + -0x210]
MOV RCX,qword ptr [RBP + -0x1d0]
MOV RSI,RDX
MOV R9,qword ptr [RBP + -0x1c8]
MOV R8,qword ptr [RBP + -0x1f8]
SUB RSI,RAX
CMP RDX,RAX
JNZ 0x00105fea
LAB_00106149:
MOV RDI,qword ptr [RAX + -0x48]
LEA RAX,[RAX + RSI*0x1 + -0x48]
MOV RDX,qword ptr [RAX]
SUB RDI,R8
SUB RDX,R8
CMP byte ptr [RAX + 0x10],0x0
JZ 0x00105ffd
LAB_00106165:
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
MOV RAX,RSI
ADD RAX,RDX
MOV dword ptr [RBX],EAX
JMP 0x00105fff
LAB_00106180:
TEST R15,R15
JZ 0x00106104
MOV RDI,qword ptr [RBP + -0x228]
JMP 0x00106209
LAB_00106198:
LEA RDX,[R9 + 0x1]
CMP EDX,0x8
JNC 0x00106230
TEST DL,0x4
JNZ 0x00106287
TEST EDX,EDX
JZ 0x00106029
MOVZX ECX,byte ptr [RBP + -0x1c0]
MOV byte ptr [RAX],CL
TEST DL,0x2
JZ 0x00106029
MOV RCX,qword ptr [RBP + -0x228]
MOV EDX,EDX
MOVZX ECX,word ptr [RCX + RDX*0x1 + -0x2]
MOV word ptr [RAX + RDX*0x1 + -0x2],CX
JMP 0x00106029
LAB_001061e0:
LEA RSI,[RBP + -0x218]
XOR EDX,EDX
MOV RDI,R13
CALL 0x001046e0
MOV qword ptr [RBP + -0x1d0],RAX
MOV RDI,RAX
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x1c0],RAX
LAB_00106209:
MOV RSI,qword ptr [RBP + -0x238]
MOV RDX,R15
CALL 0x00104570
MOV R15,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RBP + -0x1d0]
JMP 0x0010610b
LAB_00106230:
MOV RCX,qword ptr [RBP + -0x1c0]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x228]
MOV ECX,EDX
MOV RSI,qword ptr [RDI + RCX*0x1 + -0x8]
MOV qword ptr [RAX + RCX*0x1 + -0x8],RSI
LEA RSI,[RAX + 0x8]
AND RSI,-0x8
SUB RAX,RSI
ADD EDX,EAX
SUB RDI,RAX
AND EDX,0xfffffff8
MOV R8,RDI
CMP EDX,0x8
JC 0x00106029
AND EDX,0xfffffff8
XOR EAX,EAX
LAB_00106271:
MOV ECX,EAX
ADD EAX,0x8
MOV RDI,qword ptr [R8 + RCX*0x1]
MOV qword ptr [RSI + RCX*0x1],RDI
CMP EAX,EDX
JC 0x00106271
JMP 0x00106029
LAB_00106287:
MOV ECX,dword ptr [RBP + -0x1c0]
MOV EDX,EDX
MOV dword ptr [RAX],ECX
MOV RCX,qword ptr [RBP + -0x228]
MOV ECX,dword ptr [RCX + RDX*0x1 + -0x4]
MOV dword ptr [RAX + RDX*0x1 + -0x4],ECX
JMP 0x00106029
LAB_001062a5:
CALL 0x001045e0
LAB_001062aa:
JMP 0x001047ca | /* func0(std::string const&, std::string const&) */
string * func0(string *param_1,string *param_2)
{
char cVar1;
int *__src;
int8 this;
int auVar2 [16];
bool bVar3;
uint uVar4;
string *psVar5;
int8 *puVar6;
ulong uVar7;
int iVar8;
uint uVar9;
int8 *in_RDX;
string *psVar10;
long lVar11;
int iVar12;
ulong uVar13;
long in_FS_OFFSET;
ulong *local_230;
ulong local_220;
int local_218 [16];
int local_208 [16];
int4 local_1f8 [2];
locale local_1f0 [2];
int local_1e8 [16];
ulong *local_1d8;
int8 local_1d0;
ulong auStack_1c8 [30];
int local_d8 [48];
void *local_a8;
long local_a0;
int8 *local_80;
long local_60;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_218 = (int [16])0x0;
local_208 = (int [16])0x0;
std::locale::locale(local_1f0);
local_1e8 = (int [16])0x0;
/* try { // try from 00105e69 to 00105e6d has its CatchHandler @ 001062b8 */
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler
((_Compiler<std::regex_traits<char>> *)&local_1d8,(char *)*in_RDX,
(char *)*in_RDX + in_RDX[1],local_1f0,0x10);
auVar2 = local_d8._0_16_;
this = local_1e8._8_8_;
local_d8._0_16_ = (int [16])0x0;
local_1e8 = auVar2;
if ((_Sp_counted_base<(_Lock_policy)2> *)this != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release((_Sp_counted_base<(_Lock_policy)2> *)this);
}
local_1f8[0] = 0x10;
if (local_a8 != (void *)0x0) {
for (puVar6 = local_80; puVar6 < (int8 *)(local_60 + 8U); puVar6 = puVar6 + 1) {
operator_delete((void *)*puVar6,0x1f8);
}
operator_delete(local_a8,local_a0 * 8);
}
std::string::_M_dispose();
if ((_Sp_counted_base<(_Lock_policy)2> *)local_d8._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release
((_Sp_counted_base<(_Lock_policy)2> *)local_d8._8_8_);
}
std::string::_M_dispose();
psVar5 = *(string **)param_2;
psVar10 = psVar5 + *(long *)(param_2 + 8);
/* try { // try from 00105f6d to 001061f0 has its CatchHandler @ 001062af */
bVar3 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)psVar5,(__normal_iterator)psVar10,(match_results *)local_218
,(regex *)local_1f8,0,0,false);
if (!bVar3) {
psVar5 = (string *)func0(psVar5,psVar10);
return psVar5;
}
lVar11 = local_218._8_8_ - local_218._0_8_;
if ((local_218._8_8_ == local_218._0_8_) || (lVar11 == 0x48)) {
puVar6 = (int8 *)(local_218._0_8_ + lVar11 + -0x48);
if (*(char *)(puVar6 + 2) == '\0') goto LAB_00105fb0;
LAB_001060af:
__src = (int *)*puVar6;
local_1d8 = auStack_1c8;
local_1d0 = 0;
uVar13 = puVar6[1] - (long)__src;
local_220 = uVar13;
if (uVar13 < 0x10) {
if (uVar13 == 1) {
auStack_1c8[0] = CONCAT71(auStack_1c8[0]._1_7_,*__src);
}
else if (uVar13 != 0) goto LAB_00106209;
}
else {
local_1d8 = (ulong *)std::string::_M_create((ulong *)&local_1d8,(ulong)&local_220);
auStack_1c8[0] = local_220;
LAB_00106209:
memcpy(local_1d8,__src,uVar13);
}
*(int *)((long)local_1d8 + local_220) = 0;
iVar12 = local_208._8_4_;
lVar11 = local_218._8_8_ - local_218._0_8_;
uVar13 = local_220;
if (local_218._8_8_ == local_218._0_8_) {
LAB_00106149:
puVar6 = (int8 *)(local_218._0_8_ + lVar11 + -0x48);
iVar8 = (int)*puVar6 - iVar12;
cVar1 = *(char *)(puVar6 + 2);
iVar12 = (int)*(int8 *)(local_218._0_8_ + -0x48) - iVar12;
goto joined_r0x0010615f;
}
}
else {
puVar6 = (int8 *)local_218._0_8_;
if (*(char *)(local_218._0_8_ + 0x10) != '\0') goto LAB_001060af;
LAB_00105fb0:
local_1d8 = auStack_1c8;
auStack_1c8[0] = (ulong)auStack_1c8[0]._1_7_ << 8;
iVar12 = local_208._8_4_;
uVar13 = 0;
if (local_218._8_8_ == local_218._0_8_) goto LAB_00106149;
}
iVar8 = (int)*(int8 *)local_218._0_8_ - iVar12;
cVar1 = *(char *)(local_218._0_8_ + 0x10);
puVar6 = (int8 *)local_218._0_8_;
iVar12 = iVar8;
joined_r0x0010615f:
if (cVar1 == '\0') {
*(int *)param_1 = iVar8;
}
else {
*(int *)param_1 = ((int)puVar6[1] - (int)*puVar6) + iVar8;
}
local_230 = auStack_1c8;
psVar5 = param_1 + 0x18;
*(int *)(param_1 + 4) = iVar12;
*(string **)(param_1 + 8) = psVar5;
if (local_1d8 == local_230) {
uVar7 = uVar13 + 1;
uVar9 = (uint)uVar7;
if (uVar9 < 8) {
if ((uVar7 & 4) == 0) {
if (uVar9 != 0) {
*psVar5 = auStack_1c8[0]._0_1_;
if ((uVar7 & 2) != 0) {
*(int2 *)(param_1 + (uVar7 & 0xffffffff) + 0x16) =
*(int2 *)((long)auStack_1c8 + ((uVar7 & 0xffffffff) - 2));
}
}
}
else {
*(int4 *)psVar5 = (int4)auStack_1c8[0];
*(int4 *)(param_1 + (uVar7 & 0xffffffff) + 0x14) =
*(int4 *)((long)auStack_1c8 + ((uVar7 & 0xffffffff) - 4));
}
}
else {
*(ulong *)psVar5 = auStack_1c8[0];
*(int8 *)(param_1 + (uVar7 & 0xffffffff) + 0x10) =
*(int8 *)((long)auStack_1c8 + ((uVar7 & 0xffffffff) - 8));
lVar11 = (long)psVar5 - ((ulong)(param_1 + 0x20) & 0xfffffffffffffff8);
uVar9 = uVar9 + (int)lVar11 & 0xfffffff8;
if (7 < uVar9) {
uVar4 = 0;
do {
uVar7 = (ulong)uVar4;
uVar4 = uVar4 + 8;
*(int8 *)(((ulong)(param_1 + 0x20) & 0xfffffffffffffff8) + uVar7) =
*(int8 *)((long)local_230 + (uVar7 - lVar11));
} while (uVar4 < uVar9);
}
}
}
else {
*(ulong **)(param_1 + 8) = local_1d8;
*(ulong *)(param_1 + 0x18) = auStack_1c8[0];
}
*(ulong *)(param_1 + 0x10) = uVar13;
local_1d0 = 0;
local_1d8 = local_230;
auStack_1c8[0] = auStack_1c8[0] & 0xffffffffffffff00;
std::string::_M_dispose();
if ((_Sp_counted_base<(_Lock_policy)2> *)local_1e8._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release
((_Sp_counted_base<(_Lock_policy)2> *)local_1e8._8_8_);
}
std::locale::~locale(local_1f0);
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::~vector((vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*)local_218);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,428 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<std::vector<int>> bell(n+1, std::vector<int>(n+1, 0));
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %edi,-0x64(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x5d(%rbp),%rax
mov %rax,%rdi
callq 16c2 <_ZNSaISt6vectorIiSaIiEEEC1Ev>
lea -0x5e(%rbp),%rax
mov %rax,%rdi
callq 15b2 <_ZNSaIiEC1Ev>
movl $0x0,-0x5c(%rbp)
mov -0x64(%rbp),%eax
add $0x1,%eax
movslq %eax,%rsi
lea -0x5e(%rbp),%rcx
lea -0x5c(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 15f2 <_ZNSt6vectorIiSaIiEEC1EmRKiRKS0_>
mov -0x64(%rbp),%eax
add $0x1,%eax
movslq %eax,%rsi
lea -0x5d(%rbp),%rcx
lea -0x30(%rbp),%rdx
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 1702 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEC1EmRKS1_RKS2_>
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 167a <_ZNSt6vectorIiSaIiEED1Ev>
lea -0x5e(%rbp),%rax
mov %rax,%rdi
callq 15d2 <_ZNSaIiED1Ev>
lea -0x5d(%rbp),%rax
mov %rax,%rdi
callq 16e2 <_ZNSaISt6vectorIiSaIiEEED1Ev>
lea -0x50(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 17d2 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov $0x0,%esi
mov %rax,%rdi
callq 1800 <_ZNSt6vectorIiSaIiEEixEm>
movl $0x1,(%rax)
movl $0x1,-0x58(%rbp)
mov -0x58(%rbp),%eax
cmp -0x64(%rbp),%eax
jg 145e <_Z5func0i+0x1d5>
mov -0x58(%rbp),%eax
sub $0x1,%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 17d2 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x58(%rbp),%eax
sub $0x1,%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 1800 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x58(%rbp),%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 17d2 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov $0x0,%esi
mov %rax,%rdi
callq 1800 <_ZNSt6vectorIiSaIiEEixEm>
mov %ebx,(%rax)
movl $0x1,-0x54(%rbp)
mov -0x54(%rbp),%eax
cmp -0x58(%rbp),%eax
jg 1455 <_Z5func0i+0x1cc>
mov -0x58(%rbp),%eax
sub $0x1,%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 17d2 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x54(%rbp),%eax
sub $0x1,%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 1800 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x58(%rbp),%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 17d2 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x54(%rbp),%eax
sub $0x1,%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 1800 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
add %eax,%ebx
mov -0x58(%rbp),%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 17d2 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x54(%rbp),%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 1800 <_ZNSt6vectorIiSaIiEEixEm>
mov %ebx,(%rax)
addl $0x1,-0x54(%rbp)
jmpq 13b7 <_Z5func0i+0x12e>
addl $0x1,-0x58(%rbp)
jmpq 1350 <_Z5func0i+0xc7>
mov -0x64(%rbp),%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 17d2 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov $0x0,%esi
mov %rax,%rdi
callq 1800 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 178a <_ZNSt6vectorIS_IiSaIiEESaIS1_EED1Ev>
mov %ebx,%eax
mov -0x18(%rbp),%rcx
xor %fs:0x28,%rcx
je 14e8 <_Z5func0i+0x25f>
jmp 14e3 <_Z5func0i+0x25a>
endbr64
mov %rax,%rbx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 167a <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
jmp 14bd <_Z5func0i+0x234>
endbr64
mov %rax,%rbx
lea -0x5e(%rbp),%rax
mov %rax,%rdi
callq 15d2 <_ZNSaIiED1Ev>
lea -0x5d(%rbp),%rax
mov %rax,%rdi
callq 16e2 <_ZNSaISt6vectorIiSaIiEEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1190 <_Unwind_Resume@plt>
callq 1150 <__stack_chk_fail@plt>
add $0x68,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_74], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_6D]
mov [rbp+var_58], rax
nop
nop
lea rax, [rbp+var_6E]
mov [rbp+var_60], rax
nop
nop
mov [rbp+var_6C], 0
mov eax, [rbp+var_74]
add eax, 1
movsxd rsi, eax
lea rcx, [rbp+var_6E]
lea rdx, [rbp+var_6C]
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2EmRKiRKS0_; std::vector<int>::vector(ulong,int const&,std::allocator<int> const&)
mov eax, [rbp+var_74]
add eax, 1
movsxd rsi, eax
lea rcx, [rbp+var_6D]
lea rdx, [rbp+var_30]
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEC2EmRKS1_RKS2_; std::vector<std::vector<int>>::vector(ulong,std::vector<int> const&,std::allocator<std::vector<int>> const&)
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
lea rax, [rbp+var_6E]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
lea rax, [rbp+var_6D]
mov rdi, rax
call _ZNSt15__new_allocatorISt6vectorIiSaIiEEED2Ev; std::__new_allocator<std::vector<int>>::~__new_allocator()
nop
lea rax, [rbp+var_50]
mov esi, 0
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov esi, 0
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov dword ptr [rax], 1
mov [rbp+var_68], 1
jmp loc_1470
loc_1373:
mov eax, [rbp+var_68]
sub eax, 1
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_68]
sub eax, 1
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_68]
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov esi, 0
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rax], ebx
mov [rbp+var_64], 1
jmp loc_1460
loc_13D3:
mov eax, [rbp+var_68]
sub eax, 1
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_64]
sub eax, 1
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_68]
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_64]
sub eax, 1
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
add ebx, eax
mov eax, [rbp+var_68]
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_64]
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rax], ebx
add [rbp+var_64], 1
loc_1460:
mov eax, [rbp+var_64]
cmp eax, [rbp+var_68]
jle loc_13D3
add [rbp+var_68], 1
loc_1470:
mov eax, [rbp+var_68]
cmp eax, [rbp+var_74]
jle loc_1373
mov eax, [rbp+var_74]
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov esi, 0
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EED2Ev; std::vector<std::vector<int>>::~vector()
mov eax, ebx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1519
jmp short loc_1514
endbr64
mov rbx, rax
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp short loc_14DB
endbr64
mov rbx, rax
loc_14DB:
lea rax, [rbp+var_6E]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
lea rax, [rbp+var_6D]
mov rdi, rax
call _ZNSt15__new_allocatorISt6vectorIiSaIiEEED2Ev; std::__new_allocator<std::vector<int>>::~__new_allocator()
nop
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_150C
call ___stack_chk_fail
loc_150C:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1514:
call ___stack_chk_fail
loc_1519:
mov rbx, [rbp+var_8]
leave
retn | long long func0(int a1)
{
long long v1; // rax
long long v2; // rax
int v3; // ebx
long long v4; // rax
long long v5; // rax
int v6; // ebx
long long v7; // rax
int v8; // ebx
long long v9; // rax
long long v10; // rax
unsigned int v11; // ebx
char v13; // [rsp+12h] [rbp-6Eh] BYREF
char v14; // [rsp+13h] [rbp-6Dh] BYREF
int v15; // [rsp+14h] [rbp-6Ch] BYREF
int i; // [rsp+18h] [rbp-68h]
int j; // [rsp+1Ch] [rbp-64h]
char *v18; // [rsp+20h] [rbp-60h]
char *v19; // [rsp+28h] [rbp-58h]
_BYTE v20[32]; // [rsp+30h] [rbp-50h] BYREF
_BYTE v21[24]; // [rsp+50h] [rbp-30h] BYREF
unsigned long long v22; // [rsp+68h] [rbp-18h]
v22 = __readfsqword(0x28u);
v19 = &v14;
v18 = &v13;
v15 = 0;
std::vector<int>::vector(v21, a1 + 1, &v15, &v13);
std::vector<std::vector<int>>::vector(v20, a1 + 1, v21, &v14);
std::vector<int>::~vector(v21);
std::__new_allocator<int>::~__new_allocator(&v13);
std::__new_allocator<std::vector<int>>::~__new_allocator(&v14);
v1 = std::vector<std::vector<int>>::operator[](v20, 0LL);
*(_DWORD *)std::vector<int>::operator[](v1, 0LL) = 1;
for ( i = 1; i <= a1; ++i )
{
v2 = std::vector<std::vector<int>>::operator[](v20, i - 1);
v3 = *(_DWORD *)std::vector<int>::operator[](v2, i - 1);
v4 = std::vector<std::vector<int>>::operator[](v20, i);
*(_DWORD *)std::vector<int>::operator[](v4, 0LL) = v3;
for ( j = 1; j <= i; ++j )
{
v5 = std::vector<std::vector<int>>::operator[](v20, i - 1);
v6 = *(_DWORD *)std::vector<int>::operator[](v5, j - 1);
v7 = std::vector<std::vector<int>>::operator[](v20, i);
v8 = *(_DWORD *)std::vector<int>::operator[](v7, j - 1) + v6;
v9 = std::vector<std::vector<int>>::operator[](v20, i);
*(_DWORD *)std::vector<int>::operator[](v9, j) = v8;
}
}
v10 = std::vector<std::vector<int>>::operator[](v20, a1);
v11 = *(_DWORD *)std::vector<int>::operator[](v10, 0LL);
std::vector<std::vector<int>>::~vector(v20);
return v11;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV dword ptr [RBP + -0x74],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x6d]
MOV qword ptr [RBP + -0x58],RAX
NOP
NOP
LEA RAX,[RBP + -0x6e]
MOV qword ptr [RBP + -0x60],RAX
NOP
NOP
MOV dword ptr [RBP + -0x6c],0x0
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOVSXD RSI,EAX
LEA RCX,[RBP + -0x6e]
LEA RDX,[RBP + -0x6c]
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
LAB_001012fb:
CALL 0x0010160e
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOVSXD RSI,EAX
LEA RCX,[RBP + -0x6d]
LEA RDX,[RBP + -0x30]
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
LAB_00101318:
CALL 0x001016ee
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00101694
LEA RAX,[RBP + -0x6e]
MOV RDI,RAX
CALL 0x00101820
NOP
LEA RAX,[RBP + -0x6d]
MOV RDI,RAX
CALL 0x00101a0e
NOP
LEA RAX,[RBP + -0x50]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x001017ce
MOV ESI,0x0
MOV RDI,RAX
CALL 0x001017fc
MOV dword ptr [RAX],0x1
MOV dword ptr [RBP + -0x68],0x1
JMP 0x00101470
LAB_00101373:
MOV EAX,dword ptr [RBP + -0x68]
SUB EAX,0x1
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001017ce
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x68]
SUB EAX,0x1
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x001017fc
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x68]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001017ce
MOV ESI,0x0
MOV RDI,RAX
CALL 0x001017fc
MOV dword ptr [RAX],EBX
MOV dword ptr [RBP + -0x64],0x1
JMP 0x00101460
LAB_001013d3:
MOV EAX,dword ptr [RBP + -0x68]
SUB EAX,0x1
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001017ce
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,0x1
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x001017fc
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x68]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001017ce
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,0x1
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x001017fc
MOV EAX,dword ptr [RAX]
ADD EBX,EAX
MOV EAX,dword ptr [RBP + -0x68]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001017ce
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x64]
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x001017fc
MOV dword ptr [RAX],EBX
ADD dword ptr [RBP + -0x64],0x1
LAB_00101460:
MOV EAX,dword ptr [RBP + -0x64]
CMP EAX,dword ptr [RBP + -0x68]
JLE 0x001013d3
ADD dword ptr [RBP + -0x68],0x1
LAB_00101470:
MOV EAX,dword ptr [RBP + -0x68]
CMP EAX,dword ptr [RBP + -0x74]
JLE 0x00101373
MOV EAX,dword ptr [RBP + -0x74]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001017ce
MOV ESI,0x0
MOV RDI,RAX
CALL 0x001017fc
MOV EBX,dword ptr [RAX]
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00101774
MOV EAX,EBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101519
JMP 0x00101514
LAB_00101514:
CALL 0x00101170
LAB_00101519:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(int) */
int4 func0(int param_1)
{
int iVar1;
int iVar2;
int4 uVar3;
vector<int,std::allocator<int>> *pvVar4;
int4 *puVar5;
int *piVar6;
long in_FS_OFFSET;
allocator local_76;
allocator local_75;
int local_74;
int local_70;
int local_6c;
allocator *local_68;
allocator *local_60;
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
local_58 [32];
vector<int,std::allocator<int>> local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = &local_75;
local_68 = &local_76;
local_74 = 0;
/* try { // try from 001012fb to 001012ff has its CatchHandler @ 001014d4 */
std::vector<int,std::allocator<int>>::vector(local_38,(long)(param_1 + 1),&local_74,&local_76);
/* try { // try from 00101318 to 0010131c has its CatchHandler @ 001014bf */
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::vector(local_58,(long)(param_1 + 1),(vector *)local_38,&local_75);
std::vector<int,std::allocator<int>>::~vector(local_38);
std::__new_allocator<int>::~__new_allocator((__new_allocator<int> *)&local_76);
std::__new_allocator<std::vector<int,std::allocator<int>>>::~__new_allocator
((__new_allocator<std::vector<int,std::allocator<int>>> *)&local_75);
pvVar4 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,0);
puVar5 = (int4 *)std::vector<int,std::allocator<int>>::operator[](pvVar4,0);
*puVar5 = 1;
for (local_70 = 1; local_70 <= param_1; local_70 = local_70 + 1) {
pvVar4 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)(local_70 + -1));
puVar5 = (int4 *)
std::vector<int,std::allocator<int>>::operator[](pvVar4,(long)(local_70 + -1));
uVar3 = *puVar5;
pvVar4 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)local_70);
puVar5 = (int4 *)std::vector<int,std::allocator<int>>::operator[](pvVar4,0);
*puVar5 = uVar3;
for (local_6c = 1; local_6c <= local_70; local_6c = local_6c + 1) {
pvVar4 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)(local_70 + -1));
piVar6 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar4,(long)(local_6c + -1))
;
iVar1 = *piVar6;
pvVar4 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)local_70);
piVar6 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar4,(long)(local_6c + -1))
;
iVar2 = *piVar6;
pvVar4 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)local_70);
piVar6 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar4,(long)local_6c);
*piVar6 = iVar1 + iVar2;
}
}
pvVar4 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)param_1);
puVar5 = (int4 *)std::vector<int,std::allocator<int>>::operator[](pvVar4,0);
uVar3 = *puVar5;
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::~vector(local_58);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
} |
2,429 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<std::vector<int>> bell(n+1, std::vector<int>(n+1, 0));
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,0xc(%rsp)
lea 0x1(%rdi),%ebp
movslq %ebp,%rbp
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rbp
ja 12d3 <_Z5func0i+0x6a>
test %rbp,%rbp
je 1477 <_Z5func0i+0x20e>
lea 0x0(,%rbp,4),%r12
mov %r12,%rdi
callq 1140 <_Znwm@plt>
mov %rax,%r15
lea (%rax,%r12,1),%rdx
movl $0x0,(%rax)
add $0x4,%rax
cmp %rax,%rdx
jne 12b4 <_Z5func0i+0x4b>
lea 0x0(%rbp,%rbp,2),%rdi
shl $0x3,%rdi
callq 1140 <_Znwm@plt>
jmp 12df <_Z5func0i+0x76>
lea 0xd2e(%rip),%rdi
callq 1100 <_ZSt20__throw_length_errorPKc@plt>
mov %rax,(%rsp)
mov %r12,%r14
sar $0x2,%r14
mov %rax,%rbx
jmp 1348 <_Z5func0i+0xdf>
callq 10e0 <_ZSt17__throw_bad_allocv@plt>
endbr64
mov %rax,%rdi
callq 10f0 <__cxa_begin_catch@plt>
mov (%rsp),%rbp
cmp %rbx,%rbp
je 13c0 <_Z5func0i+0x157>
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 131b <_Z5func0i+0xb2>
callq 1130 <_ZdlPv@plt>
add $0x18,%rbp
jmp 1304 <_Z5func0i+0x9b>
mov %rax,%rdi
mov %rdi,(%rbx)
lea (%rdi,%r12,1),%r13
mov %r13,0x10(%rbx)
mov %r12,%rdx
mov %r15,%rsi
callq 1120 <memcpy@plt>
mov %r13,0x8(%rbx)
add $0x18,%rbx
sub $0x1,%rbp
je 1388 <_Z5func0i+0x11f>
movq $0x0,(%rbx)
movq $0x0,0x8(%rbx)
movq $0x0,0x10(%rbx)
test %r14,%r14
je 1381 <_Z5func0i+0x118>
movabs $0x1fffffffffffffff,%rax
cmp %rax,%r14
ja 12ef <_Z5func0i+0x86>
mov %r12,%rdi
callq 1140 <_Znwm@plt>
jmp 1321 <_Z5func0i+0xb8>
mov $0x0,%edi
jmp 1324 <_Z5func0i+0xbb>
test %r15,%r15
je 1395 <_Z5func0i+0x12c>
mov %r15,%rdi
callq 1130 <_ZdlPv@plt>
mov (%rsp),%r9
mov (%r9),%rax
movl $0x1,(%rax)
mov 0xc(%rsp),%eax
test %eax,%eax
jle 1434 <_Z5func0i+0x1cb>
lea 0x1(%rax),%r11d
mov $0x4,%r8d
mov $0x1,%r10d
jmp 1419 <_Z5func0i+0x1b0>
callq 1150 <__cxa_rethrow@plt>
endbr64
mov %rax,%rbx
callq 1160 <__cxa_end_catch@plt>
mov (%rsp),%rdi
callq 1130 <_ZdlPv@plt>
test %r15,%r15
je 13e7 <_Z5func0i+0x17e>
mov %r15,%rdi
callq 1130 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1170 <_Unwind_Resume@plt>
mov 0x18(%rsi),%rcx
mov (%rsi),%rdi
mov (%rcx,%rax,1),%edx
add (%rdi,%rax,1),%edx
add $0x4,%rax
mov %edx,(%rcx,%rax,1)
cmp %r8,%rax
jne 13ef <_Z5func0i+0x186>
add $0x1,%r10d
add $0x18,%r9
add $0x4,%r8
cmp %r11d,%r10d
je 1434 <_Z5func0i+0x1cb>
mov %r9,%rsi
mov (%r9),%rax
mov -0x4(%rax,%r8,1),%edx
mov 0x18(%r9),%rax
mov %edx,(%rax)
test %r10d,%r10d
jle 1408 <_Z5func0i+0x19f>
mov %rbp,%rax
jmp 13ef <_Z5func0i+0x186>
movslq 0xc(%rsp),%rax
lea (%rax,%rax,2),%rax
mov (%rsp),%rsi
mov (%rsi,%rax,8),%rax
mov (%rax),%r12d
cmp %rbx,%rsi
je 14a0 <_Z5func0i+0x237>
mov %rsi,%rbp
jmp 145b <_Z5func0i+0x1f2>
add $0x18,%rbp
cmp %rbp,%rbx
je 14a0 <_Z5func0i+0x237>
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 1452 <_Z5func0i+0x1e9>
callq 1130 <_ZdlPv@plt>
jmp 1452 <_Z5func0i+0x1e9>
endbr64
mov %rax,%rbx
jmpq 13da <_Z5func0i+0x171>
mov 0x0,%rax
movl $0x1,(%rax)
movslq 0xc(%rsp),%rax
lea (%rax,%rax,2),%rax
shl $0x3,%rax
mov (%rax),%rax
mov (%rax),%r12d
movq $0x0,(%rsp)
mov (%rsp),%rdi
callq 1130 <_ZdlPv@plt>
mov %r12d,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
lea ebx, [rdi+1]
movsxd rbx, ebx
mov rax, rbx
shr rax, 3Dh
jnz short loc_130C
mov r13d, edi
test rbx, rbx
jz loc_144F
lea r15, ds:0[rbx*4]
mov rdi, r15; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov [rsp+58h+var_58], rax
lea rdx, [rax+r15]
mov [rsp+58h+var_48], rdx
loc_12E6:
mov dword ptr [rax], 0
add rax, 4
cmp rdx, rax
jnz short loc_12E6
mov [rsp+58h+var_50], rdx
lea rdi, [rbx+rbx*2]
shl rdi, 3; unsigned __int64
call __Znwm; operator new(ulong)
jmp loc_148A
loc_130C:
mov rax, [rsp+58h+var_40]
sub rax, fs:28h
jnz short loc_1328
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_1328:
call ___stack_chk_fail
loc_132D:
mov rbx, rax
test r14, r14
jz short loc_1340
mov rsi, r15; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1340:
mov rax, [rbp+0]
mov dword ptr [rax], 1
test r13d, r13d
jle short loc_13AB
mov r9, rbp
add r13d, 1
mov r8d, 4
mov r10d, 1
loc_1362:
mov rsi, r9
mov rax, [r9]
mov edx, [rax+r8-4]
mov rax, [r9+18h]
mov [rax], edx
test r10d, r10d
jle loc_1479
mov eax, 0
loc_1381:
mov rcx, [rsi+18h]
mov rdi, [rsi]
mov edx, [rcx+rax]
add edx, [rdi+rax]
add rax, 4
mov [rcx+rax], edx
cmp r8, rax
jnz short loc_1381
add r10d, 1
add r9, 18h
add r8, 4
cmp r10d, r13d
jnz short loc_1362
loc_13AB:
mov rax, [rbp+r12-18h]
mov r14d, [rax]
cmp rbx, rbp
jz short loc_1411
mov r13, rbp
jmp short loc_13FA
endbr64
mov rbx, rax
test rbp, rbp
jz short loc_13D4
mov rsi, r12; unsigned __int64
mov rdi, rbp; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_13D4:
mov rdi, rsp
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+arg_10]
sub rax, fs:28h
jz short loc_1447
call ___stack_chk_fail
loc_13F1:
add r13, 18h
cmp rbx, r13
jz short loc_1411
loc_13FA:
mov rdi, [r13+0]; void *
test rdi, rdi
jz short loc_13F1
mov rsi, [r13+10h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_13F1
loc_1411:
mov rsi, r12; unsigned __int64
mov rdi, rbp; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rsp+58h+var_40]
sub rax, fs:28h
jnz short loc_14A8
mov eax, r14d
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
endbr64
mov rbx, rax
jmp short loc_13D4
loc_1447:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_144F:
mov [rsp+58h+var_58], 0
mov [rsp+58h+var_48], 0
mov [rsp+58h+var_50], 0
mov r15, rbx
mov r14d, 0
mov ebp, 0
jmp short loc_148D
loc_1479:
add r10d, 1
add r9, 18h
add r8, 4
jmp loc_1362
loc_148A:
mov rbp, rax
loc_148D:
lea r12, [rbx+rbx*2]
shl r12, 3
mov rdx, rsp
mov rsi, rbx
mov rdi, rbp
call _ZSt18__do_uninit_fill_nIPSt6vectorIiSaIiEEmS2_ET_S4_T0_RKT1_; std::__do_uninit_fill_n<std::vector<int> *,ulong,std::vector<int>>(std::vector<int> *,ulong,std::vector<int> const&)
jmp loc_132D
loc_14A8:
call ___stack_chk_fail | long long func0(int a1)
{
unsigned long long v1; // rbx
unsigned long long v2; // r15
_DWORD *v3; // rax
void *v4; // r14
_DWORD *v5; // rdx
long long v6; // rbx
_DWORD **v7; // r9
long long v8; // r8
int v9; // r10d
unsigned long long v10; // rax
_DWORD *v11; // rcx
int v12; // edx
unsigned int v13; // r14d
void **v14; // r13
_DWORD **v16; // rbp
unsigned long long v17; // r12
_DWORD *v18; // [rsp+0h] [rbp-58h] BYREF
_DWORD *v19; // [rsp+8h] [rbp-50h]
_DWORD *v20; // [rsp+10h] [rbp-48h]
unsigned long long v21; // [rsp+18h] [rbp-40h]
v21 = __readfsqword(0x28u);
v1 = a1 + 1;
if ( v1 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( a1 == -1 )
{
v18 = 0LL;
v20 = 0LL;
v19 = 0LL;
v2 = 0LL;
v4 = 0LL;
v16 = 0LL;
}
else
{
v2 = 4 * v1;
v3 = (_DWORD *)operator new(4 * v1);
v4 = v3;
v18 = v3;
v5 = &v3[v1];
v20 = v5;
do
*v3++ = 0;
while ( v5 != v3 );
v19 = v5;
v16 = (_DWORD **)operator new(24 * v1);
}
v17 = 3 * v1;
v6 = ((long long ( *)(_DWORD **, unsigned long long, _DWORD **))std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>)(
v16,
v1,
&v18);
if ( v4 )
operator delete(v4, v2);
**v16 = 1;
if ( a1 > 0 )
{
v7 = v16;
v8 = 4LL;
v9 = 1;
do
{
while ( 1 )
{
*v7[3] = (*v7)[(unsigned long long)v8 / 4 - 1];
if ( v9 > 0 )
break;
++v9;
v7 += 3;
v8 += 4LL;
}
v10 = 0LL;
do
{
v11 = v7[3];
v12 = (*v7)[v10 / 4] + v11[v10 / 4];
v10 += 4LL;
v11[v10 / 4] = v12;
}
while ( v8 != v10 );
++v9;
v7 += 3;
v8 += 4LL;
}
while ( v9 != a1 + 1 );
}
v13 = *v16[v17 - 3];
if ( (_DWORD **)v6 != v16 )
{
v14 = (void **)v16;
do
{
if ( *v14 )
operator delete(*v14, (_BYTE *)v14[2] - (_BYTE *)*v14);
v14 += 3;
}
while ( (void **)v6 != v14 );
}
operator delete(v16, v17 * 8);
return v13;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
LEA EBX,[RDI + 0x1]
MOVSXD RBX,EBX
MOV RAX,RBX
SHR RAX,0x3d
JNZ 0x0010130c
MOV R13D,EDI
TEST RBX,RBX
JZ 0x0010144f
LEA R15,[RBX*0x4]
MOV RDI,R15
LAB_001012d1:
CALL 0x00101130
MOV R14,RAX
MOV qword ptr [RSP],RAX
LEA RDX,[RAX + R15*0x1]
MOV qword ptr [RSP + 0x10],RDX
LAB_001012e6:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x001012e6
MOV qword ptr [RSP + 0x8],RDX
LEA RDI,[RBX + RBX*0x2]
SHL RDI,0x3
LAB_00101302:
CALL 0x00101130
JMP 0x0010148a
LAB_0010130c:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101328
LEA RDI,[0x102008]
LAB_00101323:
CALL 0x00101100
LAB_00101328:
CALL 0x00101150
LAB_0010132d:
MOV RBX,RAX
TEST R14,R14
JZ 0x00101340
MOV RSI,R15
MOV RDI,R14
CALL 0x00101140
LAB_00101340:
MOV RAX,qword ptr [RBP]
MOV dword ptr [RAX],0x1
TEST R13D,R13D
JLE 0x001013ab
MOV R9,RBP
ADD R13D,0x1
MOV R8D,0x4
MOV R10D,0x1
LAB_00101362:
MOV RSI,R9
MOV RAX,qword ptr [R9]
MOV EDX,dword ptr [RAX + R8*0x1 + -0x4]
MOV RAX,qword ptr [R9 + 0x18]
MOV dword ptr [RAX],EDX
TEST R10D,R10D
JLE 0x00101479
MOV EAX,0x0
LAB_00101381:
MOV RCX,qword ptr [RSI + 0x18]
MOV RDI,qword ptr [RSI]
MOV EDX,dword ptr [RCX + RAX*0x1]
ADD EDX,dword ptr [RDI + RAX*0x1]
ADD RAX,0x4
MOV dword ptr [RCX + RAX*0x1],EDX
CMP R8,RAX
JNZ 0x00101381
ADD R10D,0x1
ADD R9,0x18
ADD R8,0x4
CMP R10D,R13D
JNZ 0x00101362
LAB_001013ab:
MOV RAX,qword ptr [RBP + R12*0x1 + -0x18]
MOV R14D,dword ptr [RAX]
CMP RBX,RBP
JZ 0x00101411
MOV R13,RBP
JMP 0x001013fa
LAB_001013f1:
ADD R13,0x18
CMP RBX,R13
JZ 0x00101411
LAB_001013fa:
MOV RDI,qword ptr [R13]
TEST RDI,RDI
JZ 0x001013f1
MOV RSI,qword ptr [R13 + 0x10]
SUB RSI,RDI
CALL 0x00101140
JMP 0x001013f1
LAB_00101411:
MOV RSI,R12
MOV RDI,RBP
CALL 0x00101140
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014a8
MOV EAX,R14D
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010144f:
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV R15,RBX
MOV R14D,0x0
MOV EBP,0x0
JMP 0x0010148d
LAB_00101479:
ADD R10D,0x1
ADD R9,0x18
ADD R8,0x4
JMP 0x00101362
LAB_0010148a:
MOV RBP,RAX
LAB_0010148d:
LEA R12,[RBX + RBX*0x2]
SHL R12,0x3
MOV RDX,RSP
MOV RSI,RBX
MOV RDI,RBP
LAB_0010149e:
CALL 0x0010156f
JMP 0x0010132d
LAB_001014a8:
CALL 0x00101150 | /* func0(int) */
int4 func0(int param_1)
{
int *piVar1;
int *piVar2;
int4 uVar3;
void *pvVar4;
int4 *puVar5;
int4 *puVar6;
vector *pvVar7;
long lVar8;
vector *pvVar9;
ulong uVar10;
long lVar11;
vector *pvVar12;
int iVar13;
ulong uVar14;
long in_FS_OFFSET;
int4 *local_58;
int4 *local_50;
int4 *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar10 = (ulong)(param_1 + 1);
if (uVar10 >> 0x3d != 0) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
if (uVar10 == 0) {
local_58 = (int4 *)0x0;
local_48 = (int4 *)0x0;
local_50 = (int4 *)0x0;
puVar5 = (int4 *)0x0;
pvVar7 = (vector *)0x0;
uVar14 = 0;
}
else {
uVar14 = uVar10 * 4;
puVar5 = (int4 *)operator_new(uVar14);
local_50 = puVar5 + uVar10;
puVar6 = puVar5;
do {
*puVar6 = 0;
puVar6 = puVar6 + 1;
} while (local_50 != puVar6);
local_58 = puVar5;
local_48 = local_50;
/* try { // try from 00101302 to 00101306 has its CatchHandler @ 0010143e */
pvVar7 = (vector *)operator_new(uVar10 * 0x18);
}
/* try { // try from 0010149e to 001014a2 has its CatchHandler @ 001013bd */
pvVar9 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
(pvVar7,uVar10,(vector *)&local_58);
if (puVar5 != (int4 *)0x0) {
operator_delete(puVar5,uVar14);
}
**(int4 **)pvVar7 = 1;
if (0 < param_1) {
lVar11 = 4;
iVar13 = 1;
pvVar12 = pvVar7;
do {
for (; **(int4 **)(pvVar12 + 0x18) = *(int4 *)(*(long *)pvVar12 + -4 + lVar11),
iVar13 < 1; iVar13 = iVar13 + 1) {
pvVar12 = pvVar12 + 0x18;
lVar11 = lVar11 + 4;
}
lVar8 = 0;
do {
piVar1 = (int *)(*(long *)(pvVar12 + 0x18) + lVar8);
piVar2 = (int *)(*(long *)pvVar12 + lVar8);
lVar8 = lVar8 + 4;
*(int *)(*(long *)(pvVar12 + 0x18) + lVar8) = *piVar1 + *piVar2;
} while (lVar11 != lVar8);
iVar13 = iVar13 + 1;
pvVar12 = pvVar12 + 0x18;
lVar11 = lVar11 + 4;
} while (iVar13 != param_1 + 1);
}
uVar3 = **(int4 **)(pvVar7 + (uVar10 * 0x18 - 0x18));
for (pvVar12 = pvVar7; pvVar9 != pvVar12; pvVar12 = pvVar12 + 0x18) {
pvVar4 = *(void **)pvVar12;
if (pvVar4 != (void *)0x0) {
operator_delete(pvVar4,*(long *)(pvVar12 + 0x10) - (long)pvVar4);
}
}
operator_delete(pvVar7,uVar10 * 0x18);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,430 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<std::vector<int>> bell(n+1, std::vector<int>(n+1, 0));
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
return 0;
}
| O2 | cpp | func0(int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r15
push %r14
push %r13
push %r12
push %rbp
lea 0x1(%rdi),%ebp
push %rbx
movslq %ebp,%rbp
sub $0x18,%rsp
mov %edi,0xc(%rsp)
cmp %rax,%rbp
ja 1542 <_Z5func0i+0x1e2>
test %rbp,%rbp
je 1512 <_Z5func0i+0x1b2>
lea 0x0(,%rbp,4),%r12
mov %r12,%rdi
callq 1140 <_Znwm@plt>
mov %rax,%r14
lea (%rax,%r12,1),%rdx
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 13b0 <_Z5func0i+0x50>
lea 0x0(%rbp,%rbp,2),%rdi
shl $0x3,%rdi
callq 1140 <_Znwm@plt>
mov %r12,%r13
mov %rax,(%rsp)
mov %rax,%rbx
sar $0x2,%r13
jmp 1422 <_Z5func0i+0xc2>
nopl (%rax)
movabs $0x1fffffffffffffff,%rax
cmp %rax,%r13
ja 153d <_Z5func0i+0x1dd>
mov %r12,%rdi
callq 1140 <_Znwm@plt>
mov %rax,%rdi
lea (%rdi,%r12,1),%r15
mov %rdi,(%rbx)
mov %r12,%rdx
mov %r14,%rsi
mov %r15,0x10(%rbx)
add $0x18,%rbx
callq 1120 <memcpy@plt>
mov %r15,-0x10(%rbx)
sub $0x1,%rbp
je 1448 <_Z5func0i+0xe8>
movq $0x0,(%rbx)
movq $0x0,0x8(%rbx)
movq $0x0,0x10(%rbx)
test %r13,%r13
jne 13e0 <_Z5func0i+0x80>
xor %edi,%edi
jmp 13fe <_Z5func0i+0x9e>
nopw 0x0(%rax,%rax,1)
mov %r14,%rdi
callq 1130 <_ZdlPv@plt>
mov (%rsp),%rax
mov (%rax),%rdi
mov 0xc(%rsp),%eax
movl $0x1,(%rdi)
test %eax,%eax
jle 14c0 <_Z5func0i+0x160>
mov (%rsp),%rax
xor %ecx,%ecx
mov $0x1,%edx
lea 0x18(%rax),%r8
mov 0xc(%rsp),%eax
sub $0x1,%eax
lea 0x4(,%rax,4),%r9
nopl 0x0(%rax,%rax,1)
mov (%r8),%rsi
xor %eax,%eax
mov %edx,(%rsi)
jmp 149c <_Z5func0i+0x13c>
nopl 0x0(%rax)
add $0x4,%rax
add (%rdi,%rax,1),%edx
mov %edx,0x4(%rsi,%rax,1)
cmp %rcx,%rax
jne 1498 <_Z5func0i+0x138>
add $0x4,%rcx
cmp %rcx,%r9
je 14c0 <_Z5func0i+0x160>
mov (%rsi,%rcx,1),%edx
add $0x18,%r8
mov %rsi,%rdi
jmp 1488 <_Z5func0i+0x128>
nopl (%rax)
movslq 0xc(%rsp),%rax
mov (%rsp),%rcx
lea (%rax,%rax,2),%rax
mov (%rcx,%rax,8),%rax
mov (%rax),%r12d
cmp %rbx,%rcx
je 14f7 <_Z5func0i+0x197>
mov %rcx,%rbp
nopl 0x0(%rax)
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 14ee <_Z5func0i+0x18e>
callq 1130 <_ZdlPv@plt>
add $0x18,%rbp
cmp %rbp,%rbx
jne 14e0 <_Z5func0i+0x180>
mov (%rsp),%rdi
callq 1130 <_ZdlPv@plt>
add $0x18,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov 0x0,%rax
movq $0x0,(%rsp)
movl $0x1,(%rax)
movslq 0xc(%rsp),%rax
lea (%rax,%rax,2),%rax
shl $0x3,%rax
mov (%rax),%rax
mov (%rax),%r12d
jmp 14f7 <_Z5func0i+0x197>
callq 10e0 <_ZSt17__throw_bad_allocv@plt>
lea 0xabf(%rip),%rdi
callq 1100 <_ZSt20__throw_length_errorPKc@plt>
endbr64
mov %rax,%rdi
jmpq 1180 <_Z5func0i.cold>
endbr64
mov %rax,%rbp
jmpq 11a8 <_Z5func0i.cold+0x28>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov ebx, edi
lea ebp, [rbx+1]
movsxd rbp, ebp
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov rax, rbp
shr rax, 3Dh
jnz loc_154A
pxor xmm0, xmm0
lea r13, [rbp+rbp*2+0]
movups [rsp+68h+var_58+8], xmm0
shl r13, 3
test rbp, rbp
jz loc_14B5
lea r15, ds:0[rbp*4]
mov rdi, r15; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, r15; n
xor esi, esi; c
lea r12, [rax+r15]
mov rdi, rax; s
mov qword ptr [rsp+68h+var_58], rax
mov r14, rax
mov [rsp+68h+var_48], r12
call _memset
mov rdi, r13; unsigned __int64
mov qword ptr [rsp+68h+var_58+8], r12
call __Znwm; operator new(ulong)
lea rdx, [rsp+68h+var_58]
mov rsi, rbp
mov rdi, rax
mov r12, rax
mov [rsp+68h+var_60], rdx
call _ZSt18__do_uninit_fill_nIPSt6vectorIiSaIiEEmS2_ET_S4_T0_RKT1_; std::__do_uninit_fill_n<std::vector<int> *,ulong,std::vector<int>>(std::vector<int> *,ulong,std::vector<int> const&)
mov rsi, r15; unsigned __int64
mov rdi, r14; void *
mov rbp, rax
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [r12]
mov r8, r12
mov ecx, 1
mov edx, 1
mov dword ptr [rax], 1
test ebx, ebx
jz short loc_14EA
xchg ax, ax
loc_1480:
mov rsi, [r8+18h]
mov rdi, [r8]
xor eax, eax
mov [rsi], edx
nop dword ptr [rax+rax+00h]
loc_1490:
add edx, [rdi+rax*4]
mov [rsi+rax*4+4], edx
add rax, 1
cmp rcx, rax
jnz short loc_1490
add r8, 18h
cmp rbx, rcx
jz short loc_14EA
mov rax, [r8]
mov edx, [rax+rcx*4]
add rcx, 1
jmp short loc_1480
loc_14B5:
lea rdx, [rsp+68h+var_58]
xor esi, esi
xor edi, edi
movaps [rsp+68h+var_58], xmm0
mov [rsp+68h+var_48], 0
mov [rsp+68h+var_60], rdx
call _ZSt18__do_uninit_fill_nIPSt6vectorIiSaIiEEmS2_ET_S4_T0_RKT1_; std::__do_uninit_fill_n<std::vector<int> *,ulong,std::vector<int>>(std::vector<int> *,ulong,std::vector<int> const&)
mov rbp, rax
mov rax, qword ptr ds:dword_0
xor r12d, r12d
mov dword ptr [rax], 1
loc_14EA:
mov rax, [r12+r13-18h]
mov r14d, [rax]
cmp r12, rbp
jz short loc_151D
mov rbx, r12
nop word ptr [rax+rax+00h]
loc_1500:
mov rdi, [rbx]; void *
test rdi, rdi
jz short loc_1514
mov rsi, [rbx+10h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1514:
add rbx, 18h
cmp rbx, rbp
jnz short loc_1500
loc_151D:
mov rsi, r13; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1566
add rsp, 38h
mov eax, r14d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_154A:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1566
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_1566:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0i_cold; func0(int) [clone]
endbr64
mov rbx, rax
lea rax, [rsp+arg_8]
mov [rsp+arg_0], rax
jmp loc_11F0
endbr64
mov rbx, rax
jmp loc_11F0 | long long func0(unsigned int a1)
{
long long v1; // rbx
unsigned long long v2; // rbp
unsigned long long v3; // r13
void *v4; // r14
long long *v5; // r12
unsigned long long v6; // rsi
long long v7; // rbp
long long *v8; // r8
long long v9; // rcx
int v10; // edx
int *v11; // rsi
long long v12; // rdi
long long v13; // rax
unsigned int v14; // r14d
void **v15; // rbx
v1 = a1;
v2 = (int)(a1 + 1);
if ( v2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v3 = 3 * v2;
if ( a1 == -1 )
{
v7 = std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>(0LL, 0LL);
v5 = 0LL;
MEMORY[0x10102464C457F] = 1;
}
else
{
v4 = (void *)operator new(4 * v2);
memset(v4, 0, 4 * v2);
v5 = (long long *)operator new(24 * v2);
v6 = 4 * v2;
v7 = std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>(v5, v2);
operator delete(v4, v6);
v8 = v5;
v9 = 1LL;
v10 = 1;
*(_DWORD *)*v5 = 1;
if ( a1 )
{
while ( 1 )
{
v11 = (int *)v8[3];
v12 = *v8;
v13 = 0LL;
*v11 = v10;
do
{
v10 += *(_DWORD *)(v12 + 4 * v13);
v11[++v13] = v10;
}
while ( v9 != v13 );
v8 += 3;
if ( v1 == v9 )
break;
v10 = *(_DWORD *)(*v8 + 4 * v9++);
}
}
}
v14 = *(_DWORD *)v5[v3 - 3];
if ( v5 != (long long *)v7 )
{
v15 = (void **)v5;
do
{
if ( *v15 )
operator delete(*v15, (_BYTE *)v15[2] - (_BYTE *)*v15);
v15 += 3;
}
while ( v15 != (void **)v7 );
}
operator delete(v5, v3 * 8);
return v14;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
LEA EBP,[RBX + 0x1]
MOVSXD RBP,EBP
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x0010154a
PXOR XMM0,XMM0
LEA R13,[RBP + RBP*0x2]
MOVUPS xmmword ptr [RSP + 0x18],XMM0
SHL R13,0x3
TEST RBP,RBP
JZ 0x001014b5
LEA R15,[RBP*0x4]
MOV RDI,R15
LAB_0010140d:
CALL 0x00101170
MOV RDX,R15
XOR ESI,ESI
LEA R12,[RAX + R15*0x1]
MOV RDI,RAX
MOV qword ptr [RSP + 0x10],RAX
MOV R14,RAX
MOV qword ptr [RSP + 0x20],R12
CALL 0x00101140
MOV RDI,R13
MOV qword ptr [RSP + 0x18],R12
LAB_00101438:
CALL 0x00101170
LEA RDX,[RSP + 0x10]
MOV RSI,RBP
MOV RDI,RAX
MOV R12,RAX
MOV qword ptr [RSP + 0x8],RDX
LAB_00101450:
CALL 0x001015d0
MOV RSI,R15
MOV RDI,R14
MOV RBP,RAX
CALL 0x00101180
MOV RAX,qword ptr [R12]
MOV R8,R12
MOV ECX,0x1
MOV EDX,0x1
MOV dword ptr [RAX],0x1
TEST EBX,EBX
JZ 0x001014ea
NOP
LAB_00101480:
MOV RSI,qword ptr [R8 + 0x18]
MOV RDI,qword ptr [R8]
XOR EAX,EAX
MOV dword ptr [RSI],EDX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101490:
ADD EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RSI + RAX*0x4 + 0x4],EDX
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x00101490
ADD R8,0x18
CMP RBX,RCX
JZ 0x001014ea
MOV RAX,qword ptr [R8]
MOV EDX,dword ptr [RAX + RCX*0x4]
ADD RCX,0x1
JMP 0x00101480
LAB_001014b5:
LEA RDX,[RSP + 0x10]
XOR ESI,ESI
XOR EDI,EDI
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x8],RDX
LAB_001014d1:
CALL 0x001015d0
MOV RBP,RAX
MOV RAX,qword ptr [0x00000000]
XOR R12D,R12D
MOV dword ptr [RAX],0x1
LAB_001014ea:
MOV RAX,qword ptr [R12 + R13*0x1 + -0x18]
MOV R14D,dword ptr [RAX]
CMP R12,RBP
JZ 0x0010151d
MOV RBX,R12
NOP word ptr [RAX + RAX*0x1]
LAB_00101500:
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x00101514
MOV RSI,qword ptr [RBX + 0x10]
SUB RSI,RDI
CALL 0x00101180
LAB_00101514:
ADD RBX,0x18
CMP RBX,RBP
JNZ 0x00101500
LAB_0010151d:
MOV RSI,R13
MOV RDI,R12
CALL 0x00101180
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101566
ADD RSP,0x38
MOV EAX,R14D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010154a:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101566
LEA RDI,[0x102008]
LAB_00101561:
CALL 0x00101130
LAB_00101566:
CALL 0x00101190 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int4 func0(int param_1)
{
int4 uVar1;
int *piVar2;
long lVar3;
void *pvVar4;
vector *pvVar5;
vector *pvVar6;
ulong uVar7;
int iVar8;
ulong uVar9;
vector *pvVar10;
ulong uVar11;
long in_FS_OFFSET;
void *local_58;
void *pvStack_50;
void *pvStack_48;
long local_40;
uVar9 = (ulong)(param_1 + 1);
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (uVar9 >> 0x3d == 0) {
pvStack_50 = (void *)0x0;
pvStack_48 = (void *)0x0;
uVar11 = uVar9 * 0x18;
if (uVar9 == 0) {
local_58 = (void *)0x0;
pvStack_50 = (void *)0x0;
pvStack_48 = (void *)0x0;
/* try { // try from 001014d1 to 001014d5 has its CatchHandler @ 0010158d */
pvVar6 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
((vector *)0x0,0,(vector *)&local_58);
pvVar5 = (vector *)0x0;
*_DAT_00000000 = 1;
}
else {
uVar7 = uVar9 * 4;
pvVar4 = operator_new(uVar7);
local_58 = pvVar4;
pvStack_48 = (void *)((long)pvVar4 + uVar7);
memset(pvVar4,0,uVar7);
pvStack_50 = (void *)((long)pvVar4 + uVar7);
/* try { // try from 00101438 to 0010143c has its CatchHandler @ 00101577 */
pvVar5 = (vector *)operator_new(uVar11);
/* try { // try from 00101450 to 00101454 has its CatchHandler @ 0010156b */
pvVar6 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
(pvVar5,uVar9,(vector *)&local_58);
operator_delete(pvVar4,uVar7);
uVar9 = 1;
iVar8 = 1;
**(int4 **)pvVar5 = 1;
pvVar10 = pvVar5;
if (param_1 != 0) {
while( true ) {
piVar2 = *(int **)(pvVar10 + 0x18);
lVar3 = *(long *)pvVar10;
uVar7 = 0;
*piVar2 = iVar8;
do {
iVar8 = iVar8 + *(int *)(lVar3 + uVar7 * 4);
piVar2[uVar7 + 1] = iVar8;
uVar7 = uVar7 + 1;
} while (uVar9 != uVar7);
pvVar10 = pvVar10 + 0x18;
if ((uint)param_1 == uVar9) break;
iVar8 = *(int *)(*(long *)pvVar10 + uVar9 * 4);
uVar9 = uVar9 + 1;
}
}
}
uVar1 = **(int4 **)(pvVar5 + (uVar11 - 0x18));
for (pvVar10 = pvVar5; pvVar10 != pvVar6; pvVar10 = pvVar10 + 0x18) {
pvVar4 = *(void **)pvVar10;
if (pvVar4 != (void *)0x0) {
operator_delete(pvVar4,*(long *)(pvVar10 + 0x10) - (long)pvVar4);
}
}
operator_delete(pvVar5,uVar11);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar1;
}
}
else if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,431 | func0 |
#include <vector>
#include <cassert>
| int func0(int n) {
std::vector<std::vector<int>> bell(n+1, std::vector<int>(n+1, 0));
bell[0][0] = 1;
for (int i = 1; i <= n; i++) {
bell[i][0] = bell[i-1][i-1];
for (int j = 1; j <= i; j++) {
bell[i][j] = bell[i-1][j-1] + bell[i][j-1];
}
}
return bell[n][0];
}
| int main() {
assert(func0(2) == 2);
assert(func0(3) == 5);
assert(func0(4) == 15);
return 0;
}
| O3 | cpp | func0(int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r15
push %r14
lea 0x1(%rdi),%r14d
push %r13
movslq %r14d,%r14
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %edi,0xc(%rsp)
cmp %rax,%r14
ja 15bf <_Z5func0i+0x23f>
test %r14,%r14
je 1595 <_Z5func0i+0x215>
lea 0x0(,%r14,4),%r13
lea (%r14,%r14,2),%rbx
mov %r13,%rdi
shl $0x3,%rbx
callq 1160 <_Znwm@plt>
mov %r13,%rdx
xor %esi,%esi
mov %rax,%rdi
mov %rax,%r15
callq 1120 <memset@plt>
mov %rbx,%rdi
callq 1160 <_Znwm@plt>
mov %rax,%r12
mov %r13,%rax
sar $0x2,%rax
je 1523 <_Z5func0i+0x1a3>
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 15cb <_Z5func0i+0x24b>
mov %r12,%rbx
movq $0x0,0x10(%rbx)
pxor %xmm1,%xmm1
mov %r13,%rdi
movups %xmm1,(%rbx)
callq 1160 <_Znwm@plt>
lea (%rax,%r13,1),%rbp
mov %rax,(%rbx)
mov %rax,%rdi
mov %r13,%rdx
mov %rbp,0x10(%rbx)
mov %r15,%rsi
add $0x18,%rbx
callq 1140 <memcpy@plt>
mov %rbp,-0x10(%rbx)
sub $0x1,%r14
jne 1410 <_Z5func0i+0x90>
mov %r15,%rdi
callq 1150 <_ZdlPv@plt>
mov (%r12),%rax
movl $0x1,(%rax)
mov 0xc(%rsp),%eax
test %eax,%eax
jle 14c0 <_Z5func0i+0x140>
mov 0xc(%rsp),%eax
mov %r12,%r8
mov $0x1,%ecx
mov $0x1,%edx
lea -0x1(%rax),%r9d
add $0x1,%r9
nopl 0x0(%rax)
mov 0x18(%r8),%rsi
mov (%r8),%rdi
xor %eax,%eax
mov %edx,(%rsi)
nopl 0x0(%rax,%rax,1)
add (%rdi,%rax,4),%edx
mov %edx,0x4(%rsi,%rax,4)
add $0x1,%rax
cmp %rcx,%rax
jne 1498 <_Z5func0i+0x118>
add $0x18,%r8
cmp %rcx,%r9
je 14c0 <_Z5func0i+0x140>
mov (%r8),%rax
mov (%rax,%rcx,4),%edx
add $0x1,%rcx
jmp 1488 <_Z5func0i+0x108>
nopl (%rax)
movslq 0xc(%rsp),%rbp
lea 0x0(%rbp,%rbp,2),%rax
mov (%r12,%rax,8),%rax
mov (%rax),%r13d
cmp %r12,%rbx
je 14f7 <_Z5func0i+0x177>
mov %r12,%rbp
nopl 0x0(%rax)
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 1518 <_Z5func0i+0x198>
callq 1150 <_ZdlPv@plt>
add $0x18,%rbp
cmp %rbp,%rbx
jne 14e0 <_Z5func0i+0x160>
mov %r12,%rdi
callq 1150 <_ZdlPv@plt>
add $0x18,%rsp
mov %r13d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
add $0x18,%rbp
cmp %rbp,%rbx
jne 14e0 <_Z5func0i+0x160>
jmp 14f7 <_Z5func0i+0x177>
add %r12,%rbx
mov %r12,%r14
test %r13,%r13
je 1563 <_Z5func0i+0x1e3>
xchg %ax,%ax
pxor %xmm2,%xmm2
mov %r13,0x10(%r14)
mov %r13,%rdx
mov %r15,%rsi
movups %xmm2,(%r14)
xor %edi,%edi
add $0x18,%r14
movq $0x0,-0x18(%r14)
callq 1140 <memcpy@plt>
mov %r13,-0x10(%r14)
cmp %r14,%rbx
jne 1530 <_Z5func0i+0x1b0>
jmpq 144e <_Z5func0i+0xce>
mov %r12,%rax
nopw %cs:0x0(%rax,%rax,1)
movq $0x0,(%rax)
add $0x18,%rax
movq $0x0,-0x8(%rax)
movq $0x0,-0x10(%rax)
cmp %rbx,%rax
jne 1570 <_Z5func0i+0x1f0>
jmpq 144e <_Z5func0i+0xce>
mov 0x0,%rax
movslq 0xc(%rsp),%rbp
xor %r12d,%r12d
movl $0x1,(%rax)
lea 0x0(%rbp,%rbp,2),%rax
shl $0x3,%rax
mov (%rax),%rax
mov (%rax),%r13d
jmpq 14f7 <_Z5func0i+0x177>
lea 0xa42(%rip),%rdi
callq 1110 <_ZSt20__throw_length_errorPKc@plt>
movq $0x0,0x10(%r12)
pxor %xmm0,%xmm0
movups %xmm0,(%r12)
callq 10f0 <_ZSt17__throw_bad_allocv@plt>
endbr64
mov %rax,%rbp
jmpq 11b5 <_Z5func0i.cold+0x15>
endbr64
mov %rax,%rdi
jmpq 11c8 <_Z5func0i.cold+0x28>
endbr64
mov %rax,%rdi
jmpq 11c5 <_Z5func0i.cold+0x25>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
mov ebx, edi
lea ebp, [rbx+1]
movsxd rbp, ebp
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov rax, rbp
shr rax, 3Dh
jnz loc_155B
pxor xmm0, xmm0
lea r13, [rbp+rbp*2+0]
movups [rsp+68h+var_58+8], xmm0
shl r13, 3
test rbp, rbp
jz loc_14B5
lea r15, ds:0[rbp*4]
mov rdi, r15; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, r15; n
xor esi, esi; c
lea r12, [rax+r15]
mov rdi, rax; s
mov qword ptr [rsp+68h+var_58], rax
mov r14, rax
mov [rsp+68h+var_48], r12
call _memset
mov rdi, r13; unsigned __int64
mov qword ptr [rsp+68h+var_58+8], r12
call __Znwm; operator new(ulong)
lea rdx, [rsp+68h+var_58]
mov rsi, rbp
mov rdi, rax
mov r12, rax
mov [rsp+68h+var_60], rdx
call _ZSt18__do_uninit_fill_nIPSt6vectorIiSaIiEEmS2_ET_S4_T0_RKT1_; std::__do_uninit_fill_n<std::vector<int> *,ulong,std::vector<int>>(std::vector<int> *,ulong,std::vector<int> const&)
mov rsi, r15; unsigned __int64
mov rdi, r14; void *
mov rbp, rax
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [r12]
mov r8, r12
mov ecx, 1
mov edx, 1
mov dword ptr [rax], 1
test ebx, ebx
jz short loc_14EA
xchg ax, ax
loc_1480:
mov rsi, [r8+18h]
mov rdi, [r8]
xor eax, eax
mov [rsi], edx
nop dword ptr [rax+rax+00h]
loc_1490:
add edx, [rdi+rax*4]
mov [rsi+rax*4+4], edx
add rax, 1
cmp rcx, rax
jnz short loc_1490
add r8, 18h
cmp rbx, rcx
jz short loc_14EA
mov rax, [r8]
mov edx, [rax+rcx*4]
add rcx, 1
jmp short loc_1480
loc_14B5:
lea rdx, [rsp+68h+var_58]
xor esi, esi
xor edi, edi
movaps [rsp+68h+var_58], xmm0
mov [rsp+68h+var_48], 0
mov [rsp+68h+var_60], rdx
call _ZSt18__do_uninit_fill_nIPSt6vectorIiSaIiEEmS2_ET_S4_T0_RKT1_; std::__do_uninit_fill_n<std::vector<int> *,ulong,std::vector<int>>(std::vector<int> *,ulong,std::vector<int> const&)
mov rbp, rax
mov rax, qword ptr ds:dword_0
xor r12d, r12d
mov dword ptr [rax], 1
loc_14EA:
mov rax, [r12+r13-18h]
mov r14d, [rax]
cmp r12, rbp
jz short loc_151D
mov rbx, r12
nop word ptr [rax+rax+00h]
loc_1500:
mov rdi, [rbx]; void *
test rdi, rdi
jz short loc_1550
mov rsi, [rbx+10h]
add rbx, 18h
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
cmp rbx, rbp
jnz short loc_1500
loc_151D:
mov rsi, r13; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1577
add rsp, 38h
mov eax, r14d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1550:
add rbx, 18h
cmp rbx, rbp
jnz short loc_1500
jmp short loc_151D
loc_155B:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1577
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_1577:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0i_cold; func0(int) [clone]
endbr64
mov rbx, rax
lea rax, [rsp+arg_8]
mov [rsp+arg_0], rax
jmp loc_11F0
endbr64
mov rbx, rax
jmp loc_11F0 | long long func0(unsigned int a1)
{
long long v1; // rbx
unsigned long long v2; // rbp
unsigned long long v3; // r13
void *v4; // r14
long long *v5; // r12
unsigned long long v6; // rsi
long long v7; // rbp
long long *v8; // r8
long long v9; // rcx
int v10; // edx
int *v11; // rsi
long long v12; // rdi
long long v13; // rax
unsigned int v14; // r14d
void **v15; // rbx
void *v16; // rdi
char *v17; // rsi
v1 = a1;
v2 = (int)(a1 + 1);
if ( v2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v3 = 3 * v2;
if ( a1 == -1 )
{
v7 = std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>(0LL, 0LL);
v5 = 0LL;
MEMORY[0x10102464C457F] = 1;
}
else
{
v4 = (void *)operator new(4 * v2);
memset(v4, 0, 4 * v2);
v5 = (long long *)operator new(24 * v2);
v6 = 4 * v2;
v7 = std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>(v5, v2);
operator delete(v4, v6);
v8 = v5;
v9 = 1LL;
v10 = 1;
*(_DWORD *)*v5 = 1;
if ( a1 )
{
while ( 1 )
{
v11 = (int *)v8[3];
v12 = *v8;
v13 = 0LL;
*v11 = v10;
do
{
v10 += *(_DWORD *)(v12 + 4 * v13);
v11[++v13] = v10;
}
while ( v9 != v13 );
v8 += 3;
if ( v1 == v9 )
break;
v10 = *(_DWORD *)(*v8 + 4 * v9++);
}
}
}
v14 = *(_DWORD *)v5[v3 - 3];
if ( v5 != (long long *)v7 )
{
v15 = (void **)v5;
do
{
while ( 1 )
{
v16 = *v15;
if ( !*v15 )
break;
v17 = (char *)v15[2];
v15 += 3;
operator delete(v16, v17 - (_BYTE *)v16);
if ( v15 == (void **)v7 )
goto LABEL_13;
}
v15 += 3;
}
while ( v15 != (void **)v7 );
}
LABEL_13:
operator delete(v5, v3 * 8);
return v14;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
LEA EBP,[RBX + 0x1]
MOVSXD RBP,EBP
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x0010155b
PXOR XMM0,XMM0
LEA R13,[RBP + RBP*0x2]
MOVUPS xmmword ptr [RSP + 0x18],XMM0
SHL R13,0x3
TEST RBP,RBP
JZ 0x001014b5
LEA R15,[RBP*0x4]
MOV RDI,R15
LAB_0010140d:
CALL 0x00101170
MOV RDX,R15
XOR ESI,ESI
LEA R12,[RAX + R15*0x1]
MOV RDI,RAX
MOV qword ptr [RSP + 0x10],RAX
MOV R14,RAX
MOV qword ptr [RSP + 0x20],R12
CALL 0x00101140
MOV RDI,R13
MOV qword ptr [RSP + 0x18],R12
LAB_00101438:
CALL 0x00101170
LEA RDX,[RSP + 0x10]
MOV RSI,RBP
MOV RDI,RAX
MOV R12,RAX
MOV qword ptr [RSP + 0x8],RDX
LAB_00101450:
CALL 0x001015e0
MOV RSI,R15
MOV RDI,R14
MOV RBP,RAX
CALL 0x00101180
MOV RAX,qword ptr [R12]
MOV R8,R12
MOV ECX,0x1
MOV EDX,0x1
MOV dword ptr [RAX],0x1
TEST EBX,EBX
JZ 0x001014ea
NOP
LAB_00101480:
MOV RSI,qword ptr [R8 + 0x18]
MOV RDI,qword ptr [R8]
XOR EAX,EAX
MOV dword ptr [RSI],EDX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101490:
ADD EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RSI + RAX*0x4 + 0x4],EDX
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x00101490
ADD R8,0x18
CMP RBX,RCX
JZ 0x001014ea
MOV RAX,qword ptr [R8]
MOV EDX,dword ptr [RAX + RCX*0x4]
ADD RCX,0x1
JMP 0x00101480
LAB_001014b5:
LEA RDX,[RSP + 0x10]
XOR ESI,ESI
XOR EDI,EDI
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x8],RDX
LAB_001014d1:
CALL 0x001015e0
MOV RBP,RAX
MOV RAX,qword ptr [0x00000000]
XOR R12D,R12D
MOV dword ptr [RAX],0x1
LAB_001014ea:
MOV RAX,qword ptr [R12 + R13*0x1 + -0x18]
MOV R14D,dword ptr [RAX]
CMP R12,RBP
JZ 0x0010151d
MOV RBX,R12
NOP word ptr [RAX + RAX*0x1]
LAB_00101500:
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x00101550
MOV RSI,qword ptr [RBX + 0x10]
ADD RBX,0x18
SUB RSI,RDI
CALL 0x00101180
CMP RBX,RBP
JNZ 0x00101500
LAB_0010151d:
MOV RSI,R13
MOV RDI,R12
CALL 0x00101180
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101577
ADD RSP,0x38
MOV EAX,R14D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101550:
ADD RBX,0x18
CMP RBX,RBP
JNZ 0x00101500
JMP 0x0010151d
LAB_0010155b:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101577
LEA RDI,[0x102008]
LAB_00101572:
CALL 0x00101130
LAB_00101577:
CALL 0x00101190 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int4 func0(int param_1)
{
int4 uVar1;
int *piVar2;
long lVar3;
void *pvVar4;
vector *pvVar5;
vector *pvVar6;
ulong uVar7;
int iVar8;
ulong uVar9;
vector *pvVar10;
ulong uVar11;
long in_FS_OFFSET;
void *local_58;
void *pvStack_50;
void *pvStack_48;
long local_40;
uVar9 = (ulong)(param_1 + 1);
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (uVar9 >> 0x3d == 0) {
pvStack_50 = (void *)0x0;
pvStack_48 = (void *)0x0;
uVar11 = uVar9 * 0x18;
if (uVar9 == 0) {
local_58 = (void *)0x0;
pvStack_50 = (void *)0x0;
pvStack_48 = (void *)0x0;
/* try { // try from 001014d1 to 001014d5 has its CatchHandler @ 0010159e */
pvVar6 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
((vector *)0x0,0,(vector *)&local_58);
pvVar5 = (vector *)0x0;
*_DAT_00000000 = 1;
}
else {
uVar7 = uVar9 * 4;
pvVar4 = operator_new(uVar7);
local_58 = pvVar4;
pvStack_48 = (void *)((long)pvVar4 + uVar7);
memset(pvVar4,0,uVar7);
pvStack_50 = (void *)((long)pvVar4 + uVar7);
/* try { // try from 00101438 to 0010143c has its CatchHandler @ 00101588 */
pvVar5 = (vector *)operator_new(uVar11);
/* try { // try from 00101450 to 00101454 has its CatchHandler @ 0010157c */
pvVar6 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
(pvVar5,uVar9,(vector *)&local_58);
operator_delete(pvVar4,uVar7);
uVar9 = 1;
iVar8 = 1;
**(int4 **)pvVar5 = 1;
pvVar10 = pvVar5;
if (param_1 != 0) {
while( true ) {
piVar2 = *(int **)(pvVar10 + 0x18);
lVar3 = *(long *)pvVar10;
uVar7 = 0;
*piVar2 = iVar8;
do {
iVar8 = iVar8 + *(int *)(lVar3 + uVar7 * 4);
piVar2[uVar7 + 1] = iVar8;
uVar7 = uVar7 + 1;
} while (uVar9 != uVar7);
pvVar10 = pvVar10 + 0x18;
if ((uint)param_1 == uVar9) break;
iVar8 = *(int *)(*(long *)pvVar10 + uVar9 * 4);
uVar9 = uVar9 + 1;
}
}
}
uVar1 = **(int4 **)(pvVar5 + (uVar11 - 0x18));
for (pvVar10 = pvVar5; pvVar10 != pvVar6; pvVar10 = pvVar10 + 0x18) {
while (pvVar4 = *(void **)pvVar10, pvVar4 == (void *)0x0) {
pvVar10 = pvVar10 + 0x18;
if (pvVar10 == pvVar6) goto LAB_0010151d;
}
operator_delete(pvVar4,*(long *)(pvVar10 + 0x10) - (long)pvVar4);
}
LAB_0010151d:
operator_delete(pvVar5,uVar11);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar1;
}
}
else if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,432 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::max(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x18(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x10(%rbp)
lea -0x1c(%rbp),%rdx
lea -0x10(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 132b <_ZSt3maxIiERKT_S2_S2_>
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x14(%rbp),%eax
imul -0xc(%rbp),%eax
cltd
idivl -0x18(%rbp)
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 120d <_Z5func0iii+0x64>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
| _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_18]
sub eax, 1
mov [rbp+var_10], eax
lea rdx, [rbp+var_1C]
lea rax, [rbp+var_10]
mov rsi, rdx
mov rdi, rax
call _ZSt3maxIiERKT_S2_S2_; std::max<int>(int const&,int const&)
mov eax, [rax]
mov [rbp+var_C], eax
mov eax, [rbp+var_14]
imul eax, [rbp+var_C]
cdq
idiv [rbp+var_18]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_11CD
call ___stack_chk_fail
locret_11CD:
leave
retn | long long func0(int a1, int a2, int a3)
{
int v4; // [rsp+4h] [rbp-1Ch] BYREF
int v5; // [rsp+8h] [rbp-18h]
int v6; // [rsp+Ch] [rbp-14h]
int v7; // [rsp+10h] [rbp-10h] BYREF
int v8; // [rsp+14h] [rbp-Ch]
unsigned long long v9; // [rsp+18h] [rbp-8h]
v6 = a1;
v5 = a2;
v4 = a3;
v9 = __readfsqword(0x28u);
v7 = a2 - 1;
v8 = *(_DWORD *)std::max<int>(&v7, &v4);
return (unsigned int)(v8 * v6 / v5);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
LEA RDX,[RBP + -0x1c]
LEA RAX,[RBP + -0x10]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001012a0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,dword ptr [RBP + -0xc]
CDQ
IDIV dword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001011cd
CALL 0x00101070
LAB_001011cd:
LEAVE
RET | /* func0(int, int, int) */
ulong func0(int param_1,int param_2,int param_3)
{
int *piVar1;
long in_FS_OFFSET;
int local_24;
int local_20;
int local_1c;
int local_18;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = param_2 + -1;
local_24 = param_3;
local_20 = param_2;
local_1c = param_1;
piVar1 = std::max<int>(&local_18,&local_24);
local_14 = *piVar1;
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)(local_1c * local_14) / (long)local_20 & 0xffffffff;
} |
2,433 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::max(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
lea -0x1(%rsi),%ecx
cmp %edx,%ecx
mov %edx,%eax
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
| _Z5func0iii:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | /* func0(int, int, int) */
int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
2,434 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::max(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
lea -0x1(%rsi),%ecx
mov %edx,%eax
cmp %edx,%ecx
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0iii:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | /* func0(int, int, int) */
int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
2,435 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::max(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(10, 20, 30) == 15);
assert(func0(1, 2, 1) == 0);
assert(func0(11, 10, 9) == 9);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
lea -0x1(%rsi),%ecx
mov %edx,%eax
cmp %edx,%ecx
cmovge %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0iii:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovge eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 >= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVGE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | /* func0(int, int, int) */
int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_3 <= param_2 + -1) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
return auVar1;
} |
2,436 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> list1, int L) {
list1.erase(list1.begin() + L - 1);
return list1;
}
| int main() {
assert((func0({1,1,2,3,4,4,5,1},3) == std::vector<int>{1, 1, 3, 4, 4, 5, 1}));
assert((func0({0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4},4) == std::vector<int>{0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}));
assert((func0({10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10},5) == std::vector<int>{10, 10, 15, 19, 18, 17, 26, 26, 17, 18, 10}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<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 %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x54(%rbp),%eax
movslq %eax,%rbx
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 1b6a <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x38(%rbp)
lea -0x38(%rbp),%rax
mov %rbx,%rsi
mov %rax,%rdi
callq 1bb6 <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEplEl>
mov %rax,-0x30(%rbp)
lea -0x30(%rbp),%rax
mov $0x1,%esi
mov %rax,%rdi
callq 1c1c <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEmiEl>
mov %rax,-0x28(%rbp)
lea -0x28(%rbp),%rdx
lea -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1c86 <_ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEC1IPiEERKNS0_IT_NS_11__enable_ifIXsrSt10__are_sameIS9_S8_E7__valueES5_E6__typeEEE>
mov -0x20(%rbp),%rdx
mov -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1cb4 <_ZNSt6vectorIiSaIiEE5eraseEN9__gnu_cxx17__normal_iteratorIPKiS1_EE>
mov -0x50(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1b40 <_ZNSt6vectorIiSaIiEEC1EOS1_>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 12fb <_Z5func0St6vectorIiSaIiEEi+0xb2>
callq 1130 <__stack_chk_fail@plt>
mov -0x48(%rbp),%rax
add $0x58,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0St6vectorIiSaIiEEi:
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 rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_54]
movsxd rbx, eax
mov rax, [rbp+var_50]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_38], rax
lea rax, [rbp+var_38]
mov rsi, rbx
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEplEl; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator+(long)
mov [rbp+var_30], rax
lea rax, [rbp+var_30]
mov esi, 1
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEmiEl; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator-(long)
mov [rbp+var_28], rax
lea rdx, [rbp+var_28]
lea rax, [rbp+var_20]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEC2IPivEERKNS0_IT_S5_EE; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::__normal_iterator<int *,void>(__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&)
mov rdx, [rbp+var_20]
mov rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5eraseEN9__gnu_cxx17__normal_iteratorIPKiS1_EE; std::vector<int>::erase(__gnu_cxx::__normal_iterator<int const*,std::vector<int>>)
mov rdx, [rbp+var_50]
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2EOS1_; std::vector<int>::vector(std::vector<int>&&)
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_131B
call ___stack_chk_fail
loc_131B:
mov rax, [rbp+var_48]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rbx
long long v5; // [rsp+28h] [rbp-38h] BYREF
long long v6; // [rsp+30h] [rbp-30h] BYREF
long long v7; // [rsp+38h] [rbp-28h] BYREF
_QWORD v8[3]; // [rsp+40h] [rbp-20h] BYREF
v8[1] = __readfsqword(0x28u);
v3 = a3;
v5 = std::vector<int>::begin(a2);
v6 = __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator+(&v5, v3);
v7 = __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator-(&v6, 1LL);
__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::__normal_iterator<int *,void>(v8, &v7);
std::vector<int>::erase(a2, v8[0]);
std::vector<int>::vector(a1, a2);
return a1;
} | 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 RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x54]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00101bd8
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[RBP + -0x38]
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00101c24
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RBP + -0x30]
MOV ESI,0x1
MOV RDI,RAX
CALL 0x00101c8a
MOV qword ptr [RBP + -0x28],RAX
LEA RDX,[RBP + -0x28]
LEA RAX,[RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101cf4
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101d22
MOV RDX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101bae
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010131b
CALL 0x00101150
LAB_0010131b:
MOV RAX,qword ptr [RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> >, int) */
vector<int,std::allocator<int>> * func0(vector param_1,int param_2)
{
int in_EDX;
int4 in_register_00000034;
vector<int,std::allocator<int>> *this;
int4 in_register_0000003c;
long in_FS_OFFSET;
int8 local_40;
int8 local_38;
int8 local_30;
int8 local_28;
long local_20;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_00000034,param_2);
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = std::vector<int,std::allocator<int>>::begin(this);
local_38 = __normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator+
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)&local_40,
(long)in_EDX);
local_30 = __normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator-
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)&local_38,1)
;
__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::__normal_iterator<int*,void>
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)&local_28,
(__normal_iterator *)&local_30);
std::vector<int,std::allocator<int>>::erase(this,local_28);
std::vector<int,std::allocator<int>>::vector
((vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1),
(vector *)this);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
} |
2,437 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> list1, int L) {
list1.erase(list1.begin() + L - 1);
return list1;
}
| int main() {
assert((func0({1,1,2,3,4,4,5,1},3) == std::vector<int>{1, 1, 3, 4, 4, 5, 1}));
assert((func0({0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4},4) == std::vector<int>{0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}));
assert((func0({10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10},5) == std::vector<int>{10, 10, 15, 19, 18, 17, 26, 26, 17, 18, 10}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov (%rsi),%rcx
movslq %edx,%rax
shl $0x2,%rax
lea (%rcx,%rax,1),%rsi
mov 0x8(%rbx),%rdx
cmp %rdx,%rsi
je 127d <_Z5func0St6vectorIiSaIiEEi+0x34>
sub %rsi,%rdx
lea -0x4(%rcx,%rax,1),%rdi
callq 1140 <memmove@plt>
mov 0x8(%rbx),%rax
sub $0x4,%rax
mov (%rbx),%rdx
mov %rdx,0x0(%rbp)
mov %rax,0x8(%rbp)
mov 0x10(%rbx),%rax
mov %rax,0x10(%rbp)
movq $0x0,0x10(%rbx)
movq $0x0,0x8(%rbx)
movq $0x0,(%rbx)
mov %rbp,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov rbx, rsi
mov rcx, [rsi]
movsxd rax, edx
shl rax, 2
mov rdx, [rsi+8]
lea rsi, [rcx+rax]; src
cmp rdx, rsi
jz short loc_1283
lea rdi, [rcx+rax-4]; dest
sub rdx, rsi; n
cmp rdx, 4
jle short loc_12BF
call _memmove
loc_1283:
mov rax, [rbx+8]
sub rax, 4
mov rdx, [rbx]
mov [rbp+0], rdx
mov [rbp+8], rax
mov rax, [rbx+10h]
mov [rbp+10h], rax
mov qword ptr [rbx+10h], 0
mov qword ptr [rbx+8], 0
mov qword ptr [rbx], 0
mov rax, rbp
add rsp, 8
pop rbx
pop rbp
retn
loc_12BF:
jnz short loc_1283
mov eax, [rsi]
mov [rdi], eax
jmp short loc_1283 | long long * func0(long long *a1, long long *a2, int a3)
{
long long v5; // rcx
long long v6; // rax
char *v7; // rdx
char *v8; // rsi
_DWORD *v9; // rdi
signed long long v10; // rdx
long long v11; // rax
v5 = *a2;
v6 = 4LL * a3;
v7 = (char *)a2[1];
v8 = (char *)(*a2 + v6);
if ( v7 != v8 )
{
v9 = (_DWORD *)(v5 + v6 - 4);
v10 = v7 - v8;
if ( v10 <= 4 )
{
if ( v10 == 4 )
*v9 = *(_DWORD *)v8;
}
else
{
memmove(v9, v8, v10);
}
}
v11 = a2[1] - 4;
*a1 = *a2;
a1[1] = v11;
a1[2] = a2[2];
a2[2] = 0LL;
a2[1] = 0LL;
*a2 = 0LL;
return a1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV RBX,RSI
MOV RCX,qword ptr [RSI]
MOVSXD RAX,EDX
SHL RAX,0x2
MOV RDX,qword ptr [RSI + 0x8]
LEA RSI,[RCX + RAX*0x1]
CMP RDX,RSI
JZ 0x00101283
LEA RDI,[RCX + RAX*0x1 + -0x4]
SUB RDX,RSI
CMP RDX,0x4
JLE 0x001012bf
CALL 0x00101140
LAB_00101283:
MOV RAX,qword ptr [RBX + 0x8]
SUB RAX,0x4
MOV RDX,qword ptr [RBX]
MOV qword ptr [RBP],RDX
MOV qword ptr [RBP + 0x8],RAX
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RBP + 0x10],RAX
MOV qword ptr [RBX + 0x10],0x0
MOV qword ptr [RBX + 0x8],0x0
MOV qword ptr [RBX],0x0
MOV RAX,RBP
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001012bf:
JNZ 0x00101283
MOV EAX,dword ptr [RSI]
MOV dword ptr [RDI],EAX
JMP 0x00101283 | /* func0(std::vector<int, std::allocator<int> >, int) */
long * func0(vector param_1,int param_2)
{
int4 *__src;
int4 *__dest;
long lVar1;
int in_EDX;
size_t __n;
int4 in_register_00000034;
long *plVar2;
int4 in_register_0000003c;
long *plVar3;
plVar3 = (long *)CONCAT44(in_register_0000003c,param_1);
plVar2 = (long *)CONCAT44(in_register_00000034,param_2);
__src = (int4 *)(*plVar2 + (long)in_EDX * 4);
if ((int4 *)plVar2[1] != __src) {
__dest = (int4 *)(*plVar2 + -4 + (long)in_EDX * 4);
__n = plVar2[1] - (long)__src;
if ((long)__n < 5) {
if (__n == 4) {
*__dest = *__src;
}
}
else {
memmove(__dest,__src,__n);
}
}
lVar1 = plVar2[1];
*plVar3 = *plVar2;
plVar3[1] = lVar1 + -4;
plVar3[2] = plVar2[2];
plVar2[2] = 0;
plVar2[1] = 0;
*plVar2 = 0;
return plVar3;
} |
2,438 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> list1, int L) {
list1.erase(list1.begin() + L - 1);
return list1;
}
| int main() {
assert((func0({1,1,2,3,4,4,5,1},3) == std::vector<int>{1, 1, 3, 4, 4, 5, 1}));
assert((func0({0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4},4) == std::vector<int>{0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}));
assert((func0({10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10},5) == std::vector<int>{10, 10, 15, 19, 18, 17, 26, 26, 17, 18, 10}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r12
movslq %edx,%rdx
mov %rdi,%r12
push %rbx
mov %rsi,%rbx
mov %rbx,%rdi
sub $0x8,%rsp
mov (%rsi),%rax
lea -0x4(%rax,%rdx,4),%rsi
callq 1960 <_ZNSt6vectorIiSaIiEE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPiS1_EE>
mov (%rbx),%rax
movq $0x0,(%rbx)
mov %rax,(%r12)
mov 0x8(%rbx),%rax
movq $0x0,0x8(%rbx)
mov %rax,0x8(%r12)
mov 0x10(%rbx),%rax
movq $0x0,0x10(%rbx)
mov %rax,0x10(%r12)
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %r12
retq
| _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
movsxd rdx, edx
mov rbp, rdi
push rbx
shl rdx, 2
mov rbx, rsi
sub rsp, 8
mov rax, [rsi]
mov rcx, [rsi+8]
lea rsi, [rax+rdx]; src
cmp rcx, rsi
jz short loc_1694
lea rdi, [rax+rdx-4]; dest
mov rdx, rcx
sub rdx, rsi; n
cmp rdx, 4
jle short loc_16C8
call _memmove
mov rax, [rbx]
mov rsi, [rbx+8]
loc_1694:
mov [rbp+0], rax
mov rax, [rbx+10h]
sub rsi, 4
pxor xmm0, xmm0
mov [rbp+8], rsi
mov [rbp+10h], rax
mov rax, rbp
mov qword ptr [rbx+10h], 0
movups xmmword ptr [rbx], xmm0
add rsp, 8
pop rbx
pop rbp
retn
loc_16C8:
jz short loc_16D0
loc_16CA:
mov rsi, rcx
jmp short loc_1694
loc_16D0:
mov edx, [rdi+4]
mov [rdi], edx
jmp short loc_16CA | _QWORD * func0(_QWORD *a1, long long *a2, int a3)
{
long long v3; // rdx
long long v5; // rax
char *v6; // rcx
char *v7; // rsi
long long v8; // rax
_QWORD *result; // rax
v3 = 4LL * a3;
v5 = *a2;
v6 = (char *)a2[1];
v7 = (char *)(*a2 + v3);
if ( v6 != v7 )
{
if ( v6 - v7 <= 4 )
{
if ( v6 - v7 == 4 )
*(_DWORD *)(v5 + v3 - 4) = *(_DWORD *)(v5 + v3);
v7 = v6;
}
else
{
memmove((void *)(v5 + v3 - 4), v7, v6 - v7);
v5 = *a2;
v7 = (char *)a2[1];
}
}
*a1 = v5;
v8 = a2[2];
a1[1] = v7 - 4;
a1[2] = v8;
result = a1;
a2[2] = 0LL;
*(_OWORD *)a2 = 0LL;
return result;
} | func0:
ENDBR64
PUSH RBP
MOVSXD RDX,EDX
MOV RBP,RDI
PUSH RBX
SHL RDX,0x2
MOV RBX,RSI
SUB RSP,0x8
MOV RAX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8]
LEA RSI,[RAX + RDX*0x1]
CMP RCX,RSI
JZ 0x00101694
LEA RDI,[RAX + RDX*0x1 + -0x4]
MOV RDX,RCX
SUB RDX,RSI
CMP RDX,0x4
JLE 0x001016c8
CALL 0x00101140
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x8]
LAB_00101694:
MOV qword ptr [RBP],RAX
MOV RAX,qword ptr [RBX + 0x10]
SUB RSI,0x4
PXOR XMM0,XMM0
MOV qword ptr [RBP + 0x8],RSI
MOV qword ptr [RBP + 0x10],RAX
MOV RAX,RBP
MOV qword ptr [RBX + 0x10],0x0
MOVUPS xmmword ptr [RBX],XMM0
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001016c8:
JZ 0x001016d0
LAB_001016ca:
MOV RSI,RCX
JMP 0x00101694
LAB_001016d0:
MOV EDX,dword ptr [RDI + 0x4]
MOV dword ptr [RDI],EDX
JMP 0x001016ca | /* func0(std::vector<int, std::allocator<int> >, int) */
long * func0(long *param_1,int (*param_2) [16],int param_3)
{
int4 *__dest;
void *pvVar1;
long lVar2;
size_t __n;
void *__src;
lVar2 = *(long *)*param_2;
pvVar1 = *(void **)(*param_2 + 8);
__src = (void *)(lVar2 + (long)param_3 * 4);
if (pvVar1 != __src) {
__dest = (int4 *)(lVar2 + -4 + (long)param_3 * 4);
__n = (long)pvVar1 - (long)__src;
if ((long)__n < 5) {
__src = pvVar1;
if (__n == 4) {
*__dest = __dest[1];
}
}
else {
memmove(__dest,__src,__n);
lVar2 = *(long *)*param_2;
__src = *(void **)(*param_2 + 8);
}
}
*param_1 = lVar2;
lVar2 = *(long *)param_2[1];
param_1[1] = (long)__src + -4;
param_1[2] = lVar2;
*(int8 *)param_2[1] = 0;
*param_2 = (int [16])0x0;
return param_1;
} |
2,439 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(std::vector<int> list1, int L) {
list1.erase(list1.begin() + L - 1);
return list1;
}
| int main() {
assert((func0({1,1,2,3,4,4,5,1},3) == std::vector<int>{1, 1, 3, 4, 4, 5, 1}));
assert((func0({0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4},4) == std::vector<int>{0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}));
assert((func0({10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10},5) == std::vector<int>{10, 10, 15, 19, 18, 17, 26, 26, 17, 18, 10}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r12
movslq %edx,%rax
mov %rdi,%r12
push %rbx
shl $0x2,%rax
mov %rsi,%rbx
sub $0x8,%rsp
mov (%rsi),%rcx
mov 0x8(%rsi),%rdx
lea (%rcx,%rax,1),%rsi
cmp %rsi,%rdx
je 16ec <_Z5func0St6vectorIiSaIiEEi+0x3c>
sub %rsi,%rdx
lea -0x4(%rcx,%rax,1),%rdi
callq 1140 <memmove@plt>
mov (%rbx),%rcx
mov 0x8(%rbx),%rsi
mov 0x10(%rbx),%rax
sub $0x4,%rsi
pxor %xmm0,%xmm0
mov %rcx,(%r12)
mov %rsi,0x8(%r12)
mov %rax,0x10(%r12)
mov %r12,%rax
movq $0x0,0x10(%rbx)
movups %xmm0,(%rbx)
add $0x8,%rsp
pop %rbx
pop %r12
retq
nopl 0x0(%rax)
| _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
movsxd rdx, edx
mov rbp, rdi
push rbx
shl rdx, 2
mov rbx, rsi
sub rsp, 8
mov rax, [rsi]
mov rcx, [rsi+8]
lea rsi, [rax+rdx]; src
cmp rcx, rsi
jz short loc_1764
lea rdi, [rax+rdx-4]; dest
mov rdx, rcx
sub rdx, rsi; n
cmp rdx, 4
jle short loc_1798
call _memmove
mov rax, [rbx]
mov rsi, [rbx+8]
loc_1764:
mov [rbp+0], rax
mov rax, [rbx+10h]
sub rsi, 4
pxor xmm0, xmm0
mov [rbp+8], rsi
mov [rbp+10h], rax
mov rax, rbp
mov qword ptr [rbx+10h], 0
movups xmmword ptr [rbx], xmm0
add rsp, 8
pop rbx
pop rbp
retn
loc_1798:
jz short loc_17A0
loc_179A:
mov rsi, rcx
jmp short loc_1764
loc_17A0:
mov edx, [rsi]
mov [rdi], edx
jmp short loc_179A | _QWORD * func0(_QWORD *a1, long long *a2, int a3)
{
long long v4; // rdx
long long v6; // rax
char *v7; // rcx
char *v8; // rsi
_DWORD *v9; // rdi
long long v10; // rax
_QWORD *result; // rax
v4 = 4LL * a3;
v6 = *a2;
v7 = (char *)a2[1];
v8 = (char *)(*a2 + v4);
if ( v7 != v8 )
{
v9 = (_DWORD *)(v6 + v4 - 4);
if ( v7 - v8 <= 4 )
{
if ( v7 - v8 == 4 )
*v9 = *(_DWORD *)v8;
v8 = v7;
}
else
{
memmove(v9, v8, v7 - v8);
v6 = *a2;
v8 = (char *)a2[1];
}
}
*a1 = v6;
v10 = a2[2];
a1[1] = v8 - 4;
a1[2] = v10;
result = a1;
a2[2] = 0LL;
*(_OWORD *)a2 = 0LL;
return result;
} | func0:
ENDBR64
PUSH RBP
MOVSXD RDX,EDX
MOV RBP,RDI
PUSH RBX
SHL RDX,0x2
MOV RBX,RSI
SUB RSP,0x8
MOV RAX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8]
LEA RSI,[RAX + RDX*0x1]
CMP RCX,RSI
JZ 0x00101764
LEA RDI,[RAX + RDX*0x1 + -0x4]
MOV RDX,RCX
SUB RDX,RSI
CMP RDX,0x4
JLE 0x00101798
CALL 0x00101140
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x8]
LAB_00101764:
MOV qword ptr [RBP],RAX
MOV RAX,qword ptr [RBX + 0x10]
SUB RSI,0x4
PXOR XMM0,XMM0
MOV qword ptr [RBP + 0x8],RSI
MOV qword ptr [RBP + 0x10],RAX
MOV RAX,RBP
MOV qword ptr [RBX + 0x10],0x0
MOVUPS xmmword ptr [RBX],XMM0
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00101798:
JZ 0x001017a0
LAB_0010179a:
MOV RSI,RCX
JMP 0x00101764
LAB_001017a0:
MOV EDX,dword ptr [RSI]
MOV dword ptr [RDI],EDX
JMP 0x0010179a | /* func0(std::vector<int, std::allocator<int> >, int) */
long * func0(long *param_1,int (*param_2) [16],int param_3)
{
int4 *__src;
int4 *__dest;
int4 *puVar1;
long lVar2;
size_t __n;
int4 *puVar3;
lVar2 = *(long *)*param_2;
puVar1 = *(int4 **)(*param_2 + 8);
__src = (int4 *)(lVar2 + (long)param_3 * 4);
puVar3 = __src;
if (puVar1 != __src) {
__dest = (int4 *)(lVar2 + -4 + (long)param_3 * 4);
__n = (long)puVar1 - (long)__src;
if ((long)__n < 5) {
puVar3 = puVar1;
if (__n == 4) {
*__dest = *__src;
}
}
else {
memmove(__dest,__src,__n);
lVar2 = *(long *)*param_2;
puVar3 = *(int4 **)(*param_2 + 8);
}
}
*param_1 = lVar2;
lVar2 = *(long *)param_2[1];
param_1[1] = (long)(puVar3 + -1);
param_1[2] = lVar2;
*(int8 *)param_2[1] = 0;
*param_2 = (int [16])0x0;
return param_1;
} |
2,440 | func0 |
#include <vector>
#include <assert.h>
#include <algorithm>
#include <climits>
| int func0(const std::vector<std::vector<int>>& test_list, int N) {
int res = INT_MIN;
for (const auto& sub : test_list) {
res = std::max(res, sub[N]);
}
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 19);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 10);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 1) == 11);
return 0;
}
| O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x80000000,-0x2c(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1cb2 <_ZNKSt6vectorIS_IiSaIiEESaIS1_EE5beginEv>
mov %rax,-0x28(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1d0a <_ZNKSt6vectorIS_IiSaIiEESaIS1_EE3endEv>
mov %rax,-0x20(%rbp)
lea -0x20(%rbp),%rdx
lea -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1d62 <_ZN9__gnu_cxxneIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESD_>
test %al,%al
je 133b <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xb2>
lea -0x28(%rbp),%rax
mov %rax,%rdi
callq 1dc6 <_ZNK9__gnu_cxx17__normal_iteratorIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEdeEv>
mov %rax,-0x10(%rbp)
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
mov -0x10(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1ddc <_ZNKSt6vectorIiSaIiEEixEm>
mov %rax,%rdx
lea -0x2c(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1e00 <_ZSt3maxIiERKT_S2_S2_>
mov (%rax),%eax
mov %eax,-0x2c(%rbp)
lea -0x28(%rbp),%rax
mov %rax,%rdi
callq 1da2 <_ZN9__gnu_cxx17__normal_iteratorIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEppEv>
jmp 12da <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x51>
mov -0x2c(%rbp),%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1352 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xc9>
callq 1150 <__stack_chk_fail@plt>
leaveq
retq
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_2C], 80000000h
mov rax, [rbp+var_38]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EE5beginEv; std::vector<std::vector<int>>::begin(void)
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EE3endEv; std::vector<std::vector<int>>::end(void)
mov [rbp+var_20], rax
jmp short loc_1344
loc_12FC:
lea rax, [rbp+var_28]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEdeEv; __gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>>::operator*(void)
mov [rbp+var_10], rax
mov eax, [rbp+var_3C]
movsxd rdx, eax
mov rax, [rbp+var_10]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rdx, rax
lea rax, [rbp+var_2C]
mov rsi, rdx
mov rdi, rax
call _ZSt3maxIiERKT_S2_S2_; std::max<int>(int const&,int const&)
mov eax, [rax]
mov [rbp+var_2C], eax
lea rax, [rbp+var_28]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEppEv; __gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>>::operator++(void)
loc_1344:
lea rdx, [rbp+var_20]
lea rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESD_; __gnu_cxx::operator!=<std::vector<int> const*,std::vector<std::vector<int>>>(__gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>> const&,__gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>> const&)
test al, al
jnz short loc_12FC
mov eax, [rbp+var_2C]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_1372
call ___stack_chk_fail
locret_1372:
leave
retn | long long func0(long long a1, int a2)
{
long long v2; // rax
unsigned int v4; // [rsp+14h] [rbp-2Ch] BYREF
long long v5; // [rsp+18h] [rbp-28h] BYREF
_QWORD v6[2]; // [rsp+20h] [rbp-20h] BYREF
long long v7; // [rsp+30h] [rbp-10h]
unsigned long long v8; // [rsp+38h] [rbp-8h]
v8 = __readfsqword(0x28u);
v4 = 0x80000000;
v6[1] = a1;
v5 = std::vector<std::vector<int>>::begin(a1);
v6[0] = std::vector<std::vector<int>>::end(a1);
while ( (unsigned __int8)__gnu_cxx::operator!=<std::vector<int> const*,std::vector<std::vector<int>>>(&v5, v6) )
{
v7 = __gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>>::operator*(&v5);
v2 = std::vector<int>::operator[](v7, a2);
v4 = *(_DWORD *)std::max<int>(&v4, v2);
__gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>>::operator++(&v5);
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x2c],0x80000000
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101cc8
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101d14
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00101344
LAB_001012fc:
LEA RAX,[RBP + -0x28]
MOV RDI,RAX
CALL 0x00101dc8
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101dde
MOV RDX,RAX
LEA RAX,[RBP + -0x2c]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101e02
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
LEA RAX,[RBP + -0x28]
MOV RDI,RAX
CALL 0x00101da4
LAB_00101344:
LEA RDX,[RBP + -0x20]
LEA RAX,[RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101d64
TEST AL,AL
JNZ 0x001012fc
MOV EAX,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101372
CALL 0x00101170
LAB_00101372:
LEAVE
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int) */
int func0(vector *param_1,int param_2)
{
bool bVar1;
int *piVar2;
long in_FS_OFFSET;
int local_34;
int8 local_30;
int8 local_28;
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*local_20;
vector<int,std::allocator<int>> *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_34 = -0x80000000;
local_20 = (vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)param_1;
local_30 = std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::begin((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)param_1);
local_28 = std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::end(local_20);
while( true ) {
bVar1 = operator!=((__normal_iterator *)&local_30,(__normal_iterator *)&local_28);
if (!bVar1) break;
local_18 = (vector<int,std::allocator<int>> *)
__normal_iterator<std::vector<int,std::allocator<int>>const*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
::operator*((__normal_iterator<std::vector<int,std::allocator<int>>const*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
*)&local_30);
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](local_18,(long)param_2);
piVar2 = std::max<int>(&local_34,piVar2);
local_34 = *piVar2;
__normal_iterator<std::vector<int,std::allocator<int>>const*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
::operator++((__normal_iterator<std::vector<int,std::allocator<int>>const*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
*)&local_30);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_34;
} |
2,441 | func0 |
#include <vector>
#include <assert.h>
#include <algorithm>
#include <climits>
| int func0(const std::vector<std::vector<int>>& test_list, int N) {
int res = INT_MIN;
for (const auto& sub : test_list) {
res = std::max(res, sub[N]);
}
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 19);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 10);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 1) == 11);
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movl $0x80000000,0x4(%rsp)
mov (%rdi),%rdx
mov 0x8(%rdi),%rdi
cmp %rdi,%rdx
je 1306 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x5d>
movslq %esi,%rsi
lea 0x0(,%rsi,4),%rcx
lea 0x4(%rsp),%rsi
mov %rcx,%rax
add (%rdx),%rax
mov (%rax),%r8d
cmp %r8d,0x4(%rsp)
cmovge %rsi,%rax
mov (%rax),%eax
mov %eax,0x4(%rsp)
add $0x18,%rdx
cmp %rdx,%rdi
jne 12e5 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x3c>
mov 0x4(%rsp),%eax
mov 0x8(%rsp),%rcx
xor %fs:0x28,%rcx
jne 131f <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x76>
add $0x18,%rsp
retq
callq 1170 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
sub rsp, 18h
mov rax, fs:28h
mov [rsp+18h+var_10], rax
xor eax, eax
mov [rsp+18h+var_14], 80000000h
mov rax, [rdi]
mov rdi, [rdi+8]
cmp rdi, rax
jz short loc_130B
movsxd rsi, esi
lea rcx, ds:0[rsi*4]
lea rsi, [rsp+18h+var_14]
jmp short loc_12F6
loc_12E7:
mov edx, [rdx]
mov [rsp+18h+var_14], edx
add rax, 18h
cmp rdi, rax
jz short loc_130B
loc_12F6:
mov rdx, rcx
add rdx, [rax]
mov r8d, [rdx]
cmp [rsp+18h+var_14], r8d
jl short loc_12E7
mov rdx, rsi
jmp short loc_12E7
loc_130B:
mov eax, [rsp+18h+var_14]
mov rdx, [rsp+18h+var_10]
sub rdx, fs:28h
jnz short loc_1324
add rsp, 18h
retn
loc_1324:
call ___stack_chk_fail | long long func0(long long a1, int a2)
{
_QWORD *v2; // rax
_QWORD *i; // rdi
unsigned int *v4; // rdx
unsigned int v6; // [rsp+4h] [rbp-14h] BYREF
unsigned long long v7; // [rsp+8h] [rbp-10h]
v7 = __readfsqword(0x28u);
v6 = 0x80000000;
v2 = *(_QWORD **)a1;
for ( i = *(_QWORD **)(a1 + 8); i != v2; v2 += 3 )
{
v4 = (unsigned int *)(*v2 + 4LL * a2);
if ( (int)v6 >= (int)*v4 )
v4 = &v6;
v6 = *v4;
}
return v6;
} | func0:
ENDBR64
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x4],0x80000000
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RAX
JZ 0x0010130b
MOVSXD RSI,ESI
LEA RCX,[RSI*0x4]
LEA RSI,[RSP + 0x4]
JMP 0x001012f6
LAB_001012e7:
MOV EDX,dword ptr [RDX]
MOV dword ptr [RSP + 0x4],EDX
ADD RAX,0x18
CMP RDI,RAX
JZ 0x0010130b
LAB_001012f6:
MOV RDX,RCX
ADD RDX,qword ptr [RAX]
MOV R8D,dword ptr [RDX]
CMP dword ptr [RSP + 0x4],R8D
JL 0x001012e7
MOV RDX,RSI
JMP 0x001012e7
LAB_0010130b:
MOV EAX,dword ptr [RSP + 0x4]
MOV RDX,qword ptr [RSP + 0x8]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101324
ADD RSP,0x18
RET
LAB_00101324:
CALL 0x00101170 | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int) */
int func0(vector *param_1,int param_2)
{
long *plVar1;
int *piVar2;
long in_FS_OFFSET;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_14 = -0x80000000;
plVar1 = *(long **)param_1;
if (*(long **)(param_1 + 8) != plVar1) {
do {
piVar2 = (int *)((long)param_2 * 4 + *plVar1);
if (*piVar2 <= local_14) {
piVar2 = &local_14;
}
local_14 = *piVar2;
plVar1 = plVar1 + 3;
} while (*(long **)(param_1 + 8) != plVar1);
}
if (*(long *)(in_FS_OFFSET + 0x28) == *(long *)(in_FS_OFFSET + 0x28)) {
return local_14;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,442 | func0 |
#include <vector>
#include <assert.h>
#include <algorithm>
#include <climits>
| int func0(const std::vector<std::vector<int>>& test_list, int N) {
int res = INT_MIN;
for (const auto& sub : test_list) {
res = std::max(res, sub[N]);
}
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 19);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 10);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 1) == 11);
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdi
cmp %rdi,%rax
je 17b8 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x48>
movslq %esi,%rsi
mov $0x80000000,%r8d
lea 0x0(,%rsi,4),%rcx
nopl 0x0(%rax)
mov (%rax),%rdx
mov (%rdx,%rcx,1),%edx
cmp %edx,%r8d
cmovl %edx,%r8d
add $0x18,%rax
cmp %rax,%rdi
jne 1798 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x28>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0x80000000,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
mov rax, [rdi]
mov rdi, [rdi+8]
cmp rdi, rax
jz short loc_1840
movsxd rsi, esi
mov edx, 80000000h
shl rsi, 2
nop dword ptr [rax+00h]
loc_1820:
mov rcx, [rax]
mov ecx, [rcx+rsi]
cmp edx, ecx
cmovl edx, ecx
add rax, 18h
cmp rdi, rax
jnz short loc_1820
mov eax, edx
retn
loc_1840:
mov edx, 80000000h
mov eax, edx
retn | long long func0(long long a1, int a2)
{
_QWORD *v2; // rax
_QWORD *v3; // rdi
unsigned int v4; // edx
long long v5; // rsi
v2 = *(_QWORD **)a1;
v3 = *(_QWORD **)(a1 + 8);
if ( v3 == v2 )
return 0x80000000LL;
v4 = 0x80000000;
v5 = 4LL * a2;
do
{
if ( (signed int)v4 < *(_DWORD *)(*v2 + v5) )
v4 = *(_DWORD *)(*v2 + v5);
v2 += 3;
}
while ( v3 != v2 );
return v4;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RAX
JZ 0x00101840
MOVSXD RSI,ESI
MOV EDX,0x80000000
SHL RSI,0x2
NOP dword ptr [RAX]
LAB_00101820:
MOV RCX,qword ptr [RAX]
MOV ECX,dword ptr [RCX + RSI*0x1]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x18
CMP RDI,RAX
JNZ 0x00101820
MOV EAX,EDX
RET
LAB_00101840:
MOV EDX,0x80000000
MOV EAX,EDX
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int) */
int func0(vector *param_1,int param_2)
{
int iVar1;
long *plVar2;
int iVar3;
plVar2 = *(long **)param_1;
if (*(long **)(param_1 + 8) != plVar2) {
iVar3 = -0x80000000;
do {
iVar1 = *(int *)(*plVar2 + (long)param_2 * 4);
if (iVar3 < iVar1) {
iVar3 = iVar1;
}
plVar2 = plVar2 + 3;
} while (*(long **)(param_1 + 8) != plVar2);
return iVar3;
}
return -0x80000000;
} |
2,443 | func0 |
#include <vector>
#include <assert.h>
#include <algorithm>
#include <climits>
| int func0(const std::vector<std::vector<int>>& test_list, int N) {
int res = INT_MIN;
for (const auto& sub : test_list) {
res = std::max(res, sub[N]);
}
return res;
}
| int main() {
assert(func0({{5, 6, 7}, {1, 3, 5}, {8, 9, 19}}, 2) == 19);
assert(func0({{6, 7, 8}, {2, 4, 6}, {9, 10, 20}}, 1) == 10);
assert(func0({{7, 8, 9}, {3, 5, 7}, {10, 11, 21}}, 1) == 11);
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdi
cmp %rdi,%rax
je 1848 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x48>
movslq %esi,%rsi
mov $0x80000000,%r8d
lea 0x0(,%rsi,4),%rcx
nopl 0x0(%rax)
mov (%rax),%rdx
add $0x18,%rax
mov (%rdx,%rcx,1),%edx
cmp %edx,%r8d
jge 183a <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x3a>
mov %edx,%r8d
cmp %rax,%rdi
jne 1828 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x28>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x80000000,%r8d
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
mov rax, [rdi]
mov rdi, [rdi+8]
cmp rdi, rax
jz short loc_18F0
movsxd rsi, esi
mov edx, 80000000h
shl rsi, 2
nop dword ptr [rax+00h]
loc_18D0:
mov rcx, [rax]
mov ecx, [rcx+rsi]
cmp edx, ecx
cmovl edx, ecx
add rax, 18h
cmp rdi, rax
jnz short loc_18D0
mov eax, edx
retn
loc_18F0:
mov edx, 80000000h
mov eax, edx
retn | long long func0(long long a1, int a2)
{
_QWORD *v2; // rax
_QWORD *v3; // rdi
unsigned int v4; // edx
long long v5; // rsi
v2 = *(_QWORD **)a1;
v3 = *(_QWORD **)(a1 + 8);
if ( v3 == v2 )
return 0x80000000LL;
v4 = 0x80000000;
v5 = 4LL * a2;
do
{
if ( (signed int)v4 < *(_DWORD *)(*v2 + v5) )
v4 = *(_DWORD *)(*v2 + v5);
v2 += 3;
}
while ( v3 != v2 );
return v4;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RAX
JZ 0x001018f0
MOVSXD RSI,ESI
MOV EDX,0x80000000
SHL RSI,0x2
NOP dword ptr [RAX]
LAB_001018d0:
MOV RCX,qword ptr [RAX]
MOV ECX,dword ptr [RCX + RSI*0x1]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x18
CMP RDI,RAX
JNZ 0x001018d0
MOV EAX,EDX
RET
LAB_001018f0:
MOV EDX,0x80000000
MOV EAX,EDX
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int) */
int func0(vector *param_1,int param_2)
{
int iVar1;
long *plVar2;
int iVar3;
plVar2 = *(long **)param_1;
if (*(long **)(param_1 + 8) != plVar2) {
iVar3 = -0x80000000;
do {
iVar1 = *(int *)(*plVar2 + (long)param_2 * 4);
if (iVar3 < iVar1) {
iVar3 = iVar1;
}
plVar2 = plVar2 + 3;
} while (*(long **)(param_1 + 8) != plVar2);
return iVar3;
}
return -0x80000000;
} |
2,444 | func0 |
#include <vector>
#include <cassert>
| std::vector<std::vector<char>> func0(const std::vector<std::vector<char>>& lst) {
std::vector<std::vector<char>> result;
if (!lst.empty()) {
size_t numColumns = lst[0].size();
for (size_t i = 0; i < numColumns; ++i) {
std::vector<char> columnVector;
for (const auto& row : lst) {
columnVector.push_back(row[i]);
}
result.push_back(columnVector);
}
}
return result;
}
| int main() {
// Test case 1
std::vector<std::vector<char>> input1 = {{'x', 'y'}, {'a', 'b'}, {'m', 'n'}};
std::vector<std::vector<char>> expected1 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}};
assert(func0(input1) == expected1);
// Test case 2
std::vector<std::vector<char>> input2 = {{'1', '2'}, {'3', '4'}, {'5', '6'}, {'7', '8'}};
std::vector<std::vector<char>> expected2 = {{'1', '3', '5', '7'}, {'2', '4', '6', '8'}};
assert(func0(input2) == expected2);
// Test case 3
std::vector<std::vector<char>> input3 = {{'x', 'y', 'z'}, {'a', 'b', 'c'}, {'m', 'n', 'o'}};
std::vector<std::vector<char>> expected3 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}, {'z', 'c', 'o'}};
assert(func0(input3) == expected3);
return 0;
}
| O0 | cpp | func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > 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),%rax
mov %rax,%rdi
callq 2626 <_ZNSt6vectorIS_IcSaIcEESaIS1_EEC1Ev>
mov -0x70(%rbp),%rax
mov %rax,%rdi
callq 279c <_ZNKSt6vectorIS_IcSaIcEESaIS1_EE5emptyEv>
xor $0x1,%eax
test %al,%al
je 14c4 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x15b>
mov -0x70(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 2804 <_ZNKSt6vectorIS_IcSaIcEESaIS1_EEixEm>
mov %rax,%rdi
callq 2832 <_ZNKSt6vectorIcSaIcEE4sizeEv>
mov %rax,-0x48(%rbp)
movq $0x0,-0x50(%rbp)
mov -0x50(%rbp),%rax
cmp -0x48(%rbp),%rax
jae 14c4 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x15b>
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 2686 <_ZNSt6vectorIcSaIcEEC1Ev>
mov -0x70(%rbp),%rax
mov %rax,-0x40(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 2918 <_ZNKSt6vectorIS_IcSaIcEESaIS1_EE5beginEv>
mov %rax,-0x60(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 2970 <_ZNKSt6vectorIS_IcSaIcEESaIS1_EE3endEv>
mov %rax,-0x58(%rbp)
lea -0x58(%rbp),%rdx
lea -0x60(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 29c8 <_ZN9__gnu_cxxneIPKSt6vectorIcSaIcEES1_IS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESD_>
test %al,%al
je 1471 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x108>
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 2a2c <_ZNK9__gnu_cxx17__normal_iteratorIPKSt6vectorIcSaIcEES1_IS3_SaIS3_EEEdeEv>
mov %rax,-0x38(%rbp)
mov -0x50(%rbp),%rdx
mov -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2a42 <_ZNKSt6vectorIcSaIcEEixEm>
mov %rax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2a62 <_ZNSt6vectorIcSaIcEE9push_backERKc>
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 2a08 <_ZN9__gnu_cxx17__normal_iteratorIPKSt6vectorIcSaIcEES1_IS3_SaIS3_EEEppEv>
jmp 1417 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0xae>
lea -0x30(%rbp),%rdx
mov -0x68(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2ae2 <_ZNSt6vectorIS_IcSaIcEESaIS1_EE9push_backERKS1_>
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 28d0 <_ZNSt6vectorIcSaIcEED1Ev>
addq $0x1,-0x50(%rbp)
jmpq 13d5 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x6c>
endbr64
mov %rax,%rbx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 28d0 <_ZNSt6vectorIcSaIcEED1Ev>
mov -0x68(%rbp),%rax
mov %rax,%rdi
callq 2754 <_ZNSt6vectorIS_IcSaIcEESaIS1_EED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1260 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 14d9 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x170>
callq 1200 <__stack_chk_fail@plt>
mov -0x68(%rbp),%rax
add $0x68,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIS_IcSaIcEESaIS1_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 _ZNSt6vectorIS_IcSaIcEESaIS1_EEC2Ev; std::vector<std::vector<char>>::vector(void)
mov rax, [rbp+var_70]
mov rdi, rax
call _ZNKSt6vectorIS_IcSaIcEESaIS1_EE5emptyEv; std::vector<std::vector<char>>::empty(void)
xor eax, 1
test al, al
jz loc_143A
mov rax, [rbp+var_70]
mov esi, 0
mov rdi, rax
call _ZNKSt6vectorIS_IcSaIcEESaIS1_EEixEm; std::vector<std::vector<char>>::operator[](ulong)
mov rdi, rax
call _ZNKSt6vectorIcSaIcEE4sizeEv; std::vector<char>::size(void)
mov [rbp+var_48], rax
mov [rbp+var_50], 0
jmp loc_13EC
loc_133A:
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIcSaIcEEC2Ev; std::vector<char>::vector(void)
mov rax, [rbp+var_70]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIS_IcSaIcEESaIS1_EE5beginEv; std::vector<std::vector<char>>::begin(void)
mov [rbp+var_60], rax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIS_IcSaIcEESaIS1_EE3endEv; std::vector<std::vector<char>>::end(void)
mov [rbp+var_58], rax
jmp short loc_13B1
loc_1370:
lea rax, [rbp+var_60]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKSt6vectorIcSaIcEES1_IS3_SaIS3_EEEdeEv; __gnu_cxx::__normal_iterator<std::vector<char> const*,std::vector<std::vector<char>>>::operator*(void)
mov [rbp+var_38], rax
mov rdx, [rbp+var_50]
mov rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIcSaIcEEixEm; std::vector<char>::operator[](ulong)
mov rdx, rax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIcSaIcEE9push_backERKc; std::vector<char>::push_back(char const&)
lea rax, [rbp+var_60]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKSt6vectorIcSaIcEES1_IS3_SaIS3_EEEppEv; __gnu_cxx::__normal_iterator<std::vector<char> const*,std::vector<std::vector<char>>>::operator++(void)
loc_13B1:
lea rdx, [rbp+var_58]
lea rax, [rbp+var_60]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPKSt6vectorIcSaIcEES1_IS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESD_; __gnu_cxx::operator!=<std::vector<char> const*,std::vector<std::vector<char>>>(__gnu_cxx::__normal_iterator<std::vector<char> const*,std::vector<std::vector<char>>> const&,__gnu_cxx::__normal_iterator<std::vector<char> const*,std::vector<std::vector<char>>> const&)
test al, al
jnz short loc_1370
lea rdx, [rbp+var_30]
mov rax, [rbp+var_68]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IcSaIcEESaIS1_EE9push_backERKS1_; std::vector<std::vector<char>>::push_back(std::vector<char> const&)
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
add [rbp+var_50], 1
loc_13EC:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_48]
jb loc_133A
jmp short loc_143A
endbr64
mov rbx, rax
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
mov rax, [rbp+var_68]
mov rdi, rax
call _ZNSt6vectorIS_IcSaIcEESaIS1_EED2Ev; std::vector<std::vector<char>>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1432
call ___stack_chk_fail
loc_1432:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_143A:
nop
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_144F
call ___stack_chk_fail
loc_144F:
mov rax, [rbp+var_68]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v5; // [rsp+10h] [rbp-60h] BYREF
long long v6; // [rsp+18h] [rbp-58h] BYREF
unsigned long long i; // [rsp+20h] [rbp-50h]
unsigned long long v8; // [rsp+28h] [rbp-48h]
long long v9; // [rsp+30h] [rbp-40h]
long long v10; // [rsp+38h] [rbp-38h]
_BYTE v11[24]; // [rsp+40h] [rbp-30h] BYREF
unsigned long long v12; // [rsp+58h] [rbp-18h]
v12 = __readfsqword(0x28u);
std::vector<std::vector<char>>::vector(a1);
if ( (unsigned __int8)std::vector<std::vector<char>>::empty(a2) != 1 )
{
v2 = std::vector<std::vector<char>>::operator[](a2, 0LL);
v8 = std::vector<char>::size(v2);
for ( i = 0LL; i < v8; ++i )
{
std::vector<char>::vector(v11);
v9 = a2;
v5 = std::vector<std::vector<char>>::begin(a2);
v6 = std::vector<std::vector<char>>::end(v9);
while ( (unsigned __int8)__gnu_cxx::operator!=<std::vector<char> const*,std::vector<std::vector<char>>>(&v5, &v6) )
{
v10 = __gnu_cxx::__normal_iterator<std::vector<char> const*,std::vector<std::vector<char>>>::operator*(&v5);
v3 = std::vector<char>::operator[](v10, i);
std::vector<char>::push_back(v11, v3);
__gnu_cxx::__normal_iterator<std::vector<char> const*,std::vector<std::vector<char>>>::operator++(&v5);
}
std::vector<std::vector<char>>::push_back(a1, v11);
std::vector<char>::~vector(v11);
}
}
return a1;
} | 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 0x00102592
MOV RAX,qword ptr [RBP + -0x70]
MOV RDI,RAX
CALL 0x00102702
XOR EAX,0x1
TEST AL,AL
JZ 0x0010143a
MOV RAX,qword ptr [RBP + -0x70]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x0010276a
MOV RDI,RAX
CALL 0x00102798
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x50],0x0
JMP 0x001013ec
LAB_0010133a:
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x001025fa
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00102890
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x001028dc
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001013b1
LAB_00101370:
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x00102990
MOV qword ptr [RBP + -0x38],RAX
MOV RDX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001029a6
MOV RDX,RAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
LAB_001013a0:
CALL 0x001029c6
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x0010296c
LAB_001013b1:
LEA RDX,[RBP + -0x58]
LEA RAX,[RBP + -0x60]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010292c
TEST AL,AL
JNZ 0x00101370
LEA RDX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x68]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102a92
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00102836
ADD qword ptr [RBP + -0x50],0x1
LAB_001013ec:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x0010133a
JMP 0x0010143a
LAB_0010143a:
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010144f
CALL 0x00101190
LAB_0010144f:
MOV RAX,qword ptr [RBP + -0x68]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char,
std::allocator<char> > > > const&) */
vector * func0(vector *param_1)
{
char cVar1;
bool bVar2;
vector<char,std::allocator<char>> *this;
char *pcVar3;
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
*in_RSI;
long in_FS_OFFSET;
int8 local_68;
int8 local_60;
ulong local_58;
ulong local_50;
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
*local_48;
vector<char,std::allocator<char>> *local_40;
vector<char,std::allocator<char>> local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
::vector((vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
*)param_1);
cVar1 = std::
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
::empty(in_RSI);
if (cVar1 != '\x01') {
this = (vector<char,std::allocator<char>> *)
std::
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
::operator[](in_RSI,0);
local_50 = std::vector<char,std::allocator<char>>::size(this);
for (local_58 = 0; local_58 < local_50; local_58 = local_58 + 1) {
std::vector<char,std::allocator<char>>::vector(local_38);
local_48 = in_RSI;
local_68 = std::
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
::begin(in_RSI);
local_60 = std::
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
::end(local_48);
while (bVar2 = operator!=((__normal_iterator *)&local_68,(__normal_iterator *)&local_60),
bVar2) {
local_40 = (vector<char,std::allocator<char>> *)
__normal_iterator<std::vector<char,std::allocator<char>>const*,std::vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>>
::operator*((__normal_iterator<std::vector<char,std::allocator<char>>const*,std::vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>>
*)&local_68);
pcVar3 = (char *)std::vector<char,std::allocator<char>>::operator[](local_40,local_58);
/* try { // try from 001013a0 to 001013da has its CatchHandler @ 001013fc */
std::vector<char,std::allocator<char>>::push_back(local_38,pcVar3);
__normal_iterator<std::vector<char,std::allocator<char>>const*,std::vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>>
::operator++((__normal_iterator<std::vector<char,std::allocator<char>>const*,std::vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>>
*)&local_68);
}
std::
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
::push_back((vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
*)param_1,(vector *)local_38);
std::vector<char,std::allocator<char>>::~vector(local_38);
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,445 | func0 |
#include <vector>
#include <cassert>
| std::vector<std::vector<char>> func0(const std::vector<std::vector<char>>& lst) {
std::vector<std::vector<char>> result;
if (!lst.empty()) {
size_t numColumns = lst[0].size();
for (size_t i = 0; i < numColumns; ++i) {
std::vector<char> columnVector;
for (const auto& row : lst) {
columnVector.push_back(row[i]);
}
result.push_back(columnVector);
}
}
return result;
}
| int main() {
// Test case 1
std::vector<std::vector<char>> input1 = {{'x', 'y'}, {'a', 'b'}, {'m', 'n'}};
std::vector<std::vector<char>> expected1 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}};
assert(func0(input1) == expected1);
// Test case 2
std::vector<std::vector<char>> input2 = {{'1', '2'}, {'3', '4'}, {'5', '6'}, {'7', '8'}};
std::vector<std::vector<char>> expected2 = {{'1', '3', '5', '7'}, {'2', '4', '6', '8'}};
assert(func0(input2) == expected2);
// Test case 3
std::vector<std::vector<char>> input3 = {{'x', 'y', 'z'}, {'a', 'b', 'c'}, {'m', 'n', 'o'}};
std::vector<std::vector<char>> expected3 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}, {'z', 'c', 'o'}};
assert(func0(input3) == expected3);
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r13
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rax
cmp 0x8(%rsi),%rax
je 14b8 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1ef>
mov %rsi,%r15
mov 0x8(%rax),%rdx
sub (%rax),%rdx
mov %rdx,0x8(%rsp)
je 14b8 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1ef>
mov $0x0,%ebx
lea 0x10(%rsp),%rax
mov %rax,(%rsp)
jmpq 142b <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x162>
mov (%rsp),%rdi
callq 20a0 <_ZNSt6vectorIcSaIcEE17_M_realloc_insertIJRKcEEEvN9__gnu_cxx17__normal_iteratorIPcS1_EEDpOT_>
add $0x18,%rbp
cmp %rbp,%r12
je 136c <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0xa3>
mov %rbx,%rdx
add 0x0(%rbp),%rdx
mov 0x18(%rsp),%rsi
cmp 0x20(%rsp),%rsi
je 133a <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x71>
movzbl (%rdx),%eax
mov %al,(%rsi)
addq $0x1,0x18(%rsp)
jmp 1343 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x7a>
mov 0x8(%r13),%rbp
mov 0x10(%r13),%rsi
cmp %rsi,%rbp
je 14a7 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1de>
mov 0x18(%rsp),%rdi
sub 0x10(%rsp),%rdi
mov %rdi,%r12
movq $0x0,0x0(%rbp)
movq $0x0,0x8(%rbp)
movq $0x0,0x10(%rbp)
je 148c <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1c3>
js 13b1 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0xe8>
callq 1180 <_Znwm@plt>
jmp 13dc <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x113>
callq 1110 <_ZSt17__throw_bad_allocv@plt>
endbr64
mov %rax,%rbx
mov 0x10(%rsp),%rdi
test %rdi,%rdi
je 13cc <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x103>
callq 1170 <_ZdlPv@plt>
mov %r13,%rdi
callq 1d98 <_ZNSt6vectorIS_IcSaIcEESaIS1_EED1Ev>
mov %rbx,%rdi
callq 11d0 <_Unwind_Resume@plt>
mov %rax,%r14
mov %r14,0x0(%rbp)
mov %r14,0x8(%rbp)
add %r14,%r12
mov %r12,0x10(%rbp)
mov 0x10(%rsp),%rsi
mov 0x18(%rsp),%r12
sub %rsi,%r12
jne 1497 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1ce>
add %r14,%r12
mov %r12,0x8(%rbp)
addq $0x18,0x8(%r13)
mov 0x10(%rsp),%rdi
test %rdi,%rdi
je 141c <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x153>
callq 1170 <_ZdlPv@plt>
add $0x1,%rbx
cmp 0x8(%rsp),%rbx
je 14b8 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1ef>
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
mov (%r15),%rbp
mov 0x8(%r15),%r12
cmp %rbp,%r12
jne 134c <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x83>
mov 0x8(%r13),%rbp
mov 0x10(%r13),%rsi
cmp %rsi,%rbp
je 14a7 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1de>
movq $0x0,0x0(%rbp)
movq $0x0,0x8(%rbp)
movq $0x0,0x10(%rbp)
mov $0x0,%r12d
mov $0x0,%r14d
jmpq 13df <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x116>
mov $0x0,%r14d
jmpq 13df <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x116>
mov %r12,%rdx
mov %r14,%rdi
callq 11b0 <memmove@plt>
jmpq 1401 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x138>
mov (%rsp),%rdx
mov %r13,%rdi
callq 21c8 <_ZNSt6vectorIS_IcSaIcEESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_>
jmpq 140d <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x144>
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 14da <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x211>
mov %r13,%rax
add $0x38,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1190 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r12, rdi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rax, [rsi]
cmp [rsi+8], rax
jz loc_1501
mov r14, rsi
mov rdx, [rax+8]
sub rdx, [rax]
mov [rsp+78h+var_68], rdx
jz loc_1501
mov ebx, 0
lea rax, [rsp+78h+src]
mov [rsp+78h+var_70], rax
jmp loc_146C
loc_133B:
mov rdi, [rsp+78h+var_70]
call _ZNSt6vectorIcSaIcEE17_M_realloc_insertIJRKcEEEvN9__gnu_cxx17__normal_iteratorIPcS1_EEDpOT_; std::vector<char>::_M_realloc_insert<char const&>(__gnu_cxx::__normal_iterator<char *,std::vector<char>>,char const&)
loc_1345:
add rbp, 18h
cmp r13, rbp
jz short loc_1371
loc_134E:
mov rdx, rbx
add rdx, [rbp+0]
mov rsi, [rsp+78h+var_50]
cmp rsi, [rsp+78h+var_48]
jz short loc_133B
movzx eax, byte ptr [rdx]
mov [rsi], al
add rsi, 1
mov [rsp+78h+var_50], rsi
jmp short loc_1345
loc_1371:
mov rbp, [r12+8]
cmp rbp, [r12+10h]
jz loc_14E4
mov r15, [rsp+78h+src]
mov qword ptr [rbp+0], 0
mov qword ptr [rbp+8], 0
mov qword ptr [rbp+10h], 0
mov r13, [rsp+78h+var_50]
sub r13, r15
jz loc_14BB
test r13, r13
js short loc_13BB
mov rdi, r13; unsigned __int64
call __Znwm; operator new(ulong)
jmp short loc_1407
loc_13BB:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_1402
call __ZSt17__throw_bad_allocv; std::__throw_bad_alloc(void)
endbr64
mov rbx, rax
lea rdi, [rsp+78h+src]
call _ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
mov rdi, r12
call _ZNSt6vectorIS_IcSaIcEESaIS1_EED2Ev; std::vector<std::vector<char>>::~vector()
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jz loc_14F9
call ___stack_chk_fail
loc_1402:
call ___stack_chk_fail
loc_1407:
mov rdi, rax; dest
mov [rbp+0], rax
mov [rbp+8], rax
lea rax, [rax+r13]
mov [rsp+78h+var_60], rax
mov [rbp+10h], rax
cmp r13, 1
jle loc_14D9
mov rdx, r13; n
mov rsi, r15; src
call _memmove
loc_1434:
mov rax, [rsp+78h+var_60]
mov [rbp+8], rax
add qword ptr [r12+8], 18h
loc_1443:
mov rdi, [rsp+78h+src]; void *
test rdi, rdi
jz short loc_145A
mov rsi, [rsp+78h+var_48]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_145A:
add rbx, 1
mov rax, [rsp+78h+var_68]
cmp rbx, rax
jz loc_1501
loc_146C:
mov [rsp+78h+src], 0
mov [rsp+78h+var_50], 0
mov [rsp+78h+var_48], 0
mov rbp, [r14]
mov r13, [r14+8]
cmp r13, rbp
jnz loc_134E
mov rbp, [r12+8]
cmp rbp, [r12+10h]
jz short loc_14E4
mov qword ptr [rbp+0], 0
mov qword ptr [rbp+8], 0
mov qword ptr [rbp+10h], 0
loc_14BB:
mov qword ptr [rbp+0], 0
mov qword ptr [rbp+10h], 0
mov [rsp+78h+var_60], 0
jmp loc_1434
loc_14D9:
movzx eax, byte ptr [r15]
mov [rdi], al
jmp loc_1434
loc_14E4:
mov rdx, [rsp+78h+var_70]
mov rsi, rbp
mov rdi, r12
call _ZNSt6vectorIS_IcSaIcEESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<std::vector<char>>::_M_realloc_insert<std::vector<char> const&>(__gnu_cxx::__normal_iterator<std::vector<char>*,std::vector<std::vector<char>>>,std::vector<char> const&)
jmp loc_1443
loc_14F9:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1501:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_1523
mov rax, r12
add rsp, 48h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1523:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
long long i; // rbx
_QWORD *v4; // rbp
_BYTE *v5; // rdx
_BYTE *v6; // rsi
_QWORD *v7; // rbp
_BYTE *v8; // r15
signed long long v9; // r13
_BYTE *v10; // rax
_QWORD *v11; // r13
long long v13; // [rsp+10h] [rbp-68h]
_BYTE *v14; // [rsp+18h] [rbp-60h]
void *src; // [rsp+20h] [rbp-58h] BYREF
_BYTE *v16; // [rsp+28h] [rbp-50h]
_BYTE *v17; // [rsp+30h] [rbp-48h]
unsigned long long v18; // [rsp+38h] [rbp-40h]
v18 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
if ( a2[1] != *a2 )
{
v13 = *(_QWORD *)(*a2 + 8LL) - *(_QWORD *)*a2;
if ( v13 )
{
for ( i = 0LL; i != v13; ++i )
{
src = 0LL;
v16 = 0LL;
v17 = 0LL;
v4 = (_QWORD *)*a2;
v11 = (_QWORD *)a2[1];
if ( v11 == (_QWORD *)*a2 )
{
v7 = (_QWORD *)a1[1];
if ( v7 == (_QWORD *)a1[2] )
goto LABEL_24;
*v7 = 0LL;
v7[1] = 0LL;
v7[2] = 0LL;
}
else
{
do
{
v5 = (_BYTE *)(*v4 + i);
v6 = v16;
if ( v16 == v17 )
{
std::vector<char>::_M_realloc_insert<char const&>(&src, v16, v5);
}
else
{
*v16 = *v5;
v16 = v6 + 1;
}
v4 += 3;
}
while ( v11 != v4 );
v7 = (_QWORD *)a1[1];
if ( v7 == (_QWORD *)a1[2] )
{
LABEL_24:
std::vector<std::vector<char>>::_M_realloc_insert<std::vector<char> const&>(a1, v7, &src);
goto LABEL_16;
}
v8 = src;
*v7 = 0LL;
v7[1] = 0LL;
v7[2] = 0LL;
v9 = v16 - v8;
if ( v16 != v8 )
{
if ( v9 < 0 )
std::__throw_bad_alloc();
v10 = (_BYTE *)operator new(v16 - v8);
*v7 = v10;
v7[1] = v10;
v14 = &v10[v9];
v7[2] = &v10[v9];
if ( v9 <= 1 )
*v10 = *v8;
else
memmove(v10, v8, v9);
goto LABEL_15;
}
}
*v7 = 0LL;
v7[2] = 0LL;
v14 = 0LL;
LABEL_15:
v7[1] = v14;
a1[1] += 24LL;
LABEL_16:
if ( src )
operator delete(src, v17 - (_BYTE *)src);
}
}
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RAX
JZ 0x00101501
MOV R14,RSI
MOV RDX,qword ptr [RAX + 0x8]
SUB RDX,qword ptr [RAX]
MOV qword ptr [RSP + 0x10],RDX
JZ 0x00101501
MOV EBX,0x0
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0010146c
LAB_0010133b:
MOV RDI,qword ptr [RSP + 0x8]
LAB_00101340:
CALL 0x0010222e
LAB_00101345:
ADD RBP,0x18
CMP R13,RBP
JZ 0x00101371
LAB_0010134e:
MOV RDX,RBX
ADD RDX,qword ptr [RBP]
MOV RSI,qword ptr [RSP + 0x28]
CMP RSI,qword ptr [RSP + 0x30]
JZ 0x0010133b
MOVZX EAX,byte ptr [RDX]
MOV byte ptr [RSI],AL
ADD RSI,0x1
MOV qword ptr [RSP + 0x28],RSI
JMP 0x00101345
LAB_00101371:
MOV RBP,qword ptr [R12 + 0x8]
CMP RBP,qword ptr [R12 + 0x10]
JZ 0x001014e4
MOV R15,qword ptr [RSP + 0x20]
MOV qword ptr [RBP],0x0
MOV qword ptr [RBP + 0x8],0x0
MOV qword ptr [RBP + 0x10],0x0
MOV R13,qword ptr [RSP + 0x28]
SUB R13,R15
JZ 0x001014bb
TEST R13,R13
JS 0x001013bb
MOV RDI,R13
CALL 0x00101170
JMP 0x00101407
LAB_001013bb:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101402
CALL 0x00101110
LAB_001013d0:
ENDBR64
MOV RBX,RAX
LEA RDI,[RSP + 0x20]
CALL 0x001020c8
MOV RDI,R12
CALL 0x00102076
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001014f9
CALL 0x00101190
LAB_00101402:
CALL 0x00101190
LAB_00101407:
MOV RDI,RAX
MOV qword ptr [RBP],RAX
MOV qword ptr [RBP + 0x8],RAX
LEA RAX,[RAX + R13*0x1]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RBP + 0x10],RAX
CMP R13,0x1
JLE 0x001014d9
MOV RDX,R13
MOV RSI,R15
CALL 0x001011b0
LAB_00101434:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RBP + 0x8],RAX
ADD qword ptr [R12 + 0x8],0x18
LAB_00101443:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x0010145a
MOV RSI,qword ptr [RSP + 0x30]
SUB RSI,RDI
CALL 0x00101180
LAB_0010145a:
ADD RBX,0x1
MOV RAX,qword ptr [RSP + 0x10]
CMP RBX,RAX
JZ 0x00101501
LAB_0010146c:
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV RBP,qword ptr [R14]
MOV R13,qword ptr [R14 + 0x8]
CMP R13,RBP
JNZ 0x0010134e
MOV RBP,qword ptr [R12 + 0x8]
CMP RBP,qword ptr [R12 + 0x10]
JZ 0x001014e4
MOV qword ptr [RBP],0x0
MOV qword ptr [RBP + 0x8],0x0
MOV qword ptr [RBP + 0x10],0x0
LAB_001014bb:
MOV qword ptr [RBP],0x0
MOV qword ptr [RBP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
JMP 0x00101434
LAB_001014d9:
MOVZX EAX,byte ptr [R15]
MOV byte ptr [RDI],AL
JMP 0x00101434
LAB_001014e4:
MOV RDX,qword ptr [RSP + 0x8]
MOV RSI,RBP
MOV RDI,R12
CALL 0x00102374
JMP 0x00101443
LAB_001014f9:
MOV RDI,RBX
LAB_001014fc:
CALL 0x001011d0
LAB_00101501:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101523
MOV RAX,R12
ADD RSP,0x48
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101523:
CALL 0x00101190 | /* func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char,
std::allocator<char> > > > const&) */
vector * func0(vector *param_1)
{
long lVar1;
long lVar2;
long *plVar3;
int *__src;
int *__dest;
int8 uVar4;
long lVar5;
long *plVar6;
int8 *puVar7;
long *in_RSI;
ulong __n;
long in_FS_OFFSET;
int *local_60;
int *local_58;
char *local_50;
char *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
plVar6 = (long *)*in_RSI;
if (((long *)in_RSI[1] != plVar6) && (lVar1 = plVar6[1], lVar2 = *plVar6, lVar1 != lVar2)) {
lVar5 = 0;
do {
local_58 = (int *)0x0;
local_50 = (char *)0x0;
local_48 = (char *)0x0;
plVar6 = (long *)*in_RSI;
plVar3 = (long *)in_RSI[1];
if (plVar3 == plVar6) {
puVar7 = *(int8 **)(param_1 + 8);
if (puVar7 != *(int8 **)(param_1 + 0x10)) {
*puVar7 = 0;
puVar7[1] = 0;
puVar7[2] = 0;
LAB_001014bb:
*puVar7 = 0;
puVar7[2] = 0;
local_60 = (int *)0x0;
goto LAB_00101434;
}
LAB_001014e4:
std::
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
::_M_realloc_insert<std::vector<char,std::allocator<char>>const&>
((vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
*)param_1,(__normal_iterator)puVar7,(vector *)&local_58);
}
else {
do {
if (local_50 == local_48) {
/* try { // try from 00101340 to 001014f3 has its CatchHandler @ 001013d0 */
std::vector<char,std::allocator<char>>::_M_realloc_insert<char_const&>
((vector<char,std::allocator<char>> *)&local_58,(__normal_iterator)local_50,
(char *)(lVar5 + *plVar6));
}
else {
*local_50 = *(char *)(lVar5 + *plVar6);
local_50 = local_50 + 1;
}
__src = local_58;
plVar6 = plVar6 + 3;
} while (plVar3 != plVar6);
puVar7 = *(int8 **)(param_1 + 8);
if (puVar7 == *(int8 **)(param_1 + 0x10)) goto LAB_001014e4;
*puVar7 = 0;
puVar7[1] = 0;
puVar7[2] = 0;
__n = (long)local_50 - (long)local_58;
if (__n == 0) goto LAB_001014bb;
if ((long)__n < 0) {
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
uVar4 = std::__throw_bad_alloc();
/* catch() { ... } // from try @ 00101340 with catch @ 001013d0 */
std::vector<char,std::allocator<char>>::~vector
((vector<char,std::allocator<char>> *)&local_58);
std::
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
::~vector((vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
*)param_1);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar4);
}
__dest = (int *)operator_new(__n);
*puVar7 = __dest;
puVar7[1] = __dest;
local_60 = __dest + __n;
puVar7[2] = local_60;
if ((long)__n < 2) {
*__dest = *__src;
}
else {
memmove(__dest,__src,__n);
}
LAB_00101434:
puVar7[1] = local_60;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x18;
}
if (local_58 != (int *)0x0) {
operator_delete(local_58,(long)local_48 - (long)local_58);
}
lVar5 = lVar5 + 1;
} while (lVar5 != lVar1 - lVar2);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,446 | func0 |
#include <vector>
#include <cassert>
| std::vector<std::vector<char>> func0(const std::vector<std::vector<char>>& lst) {
std::vector<std::vector<char>> result;
if (!lst.empty()) {
size_t numColumns = lst[0].size();
for (size_t i = 0; i < numColumns; ++i) {
std::vector<char> columnVector;
for (const auto& row : lst) {
columnVector.push_back(row[i]);
}
result.push_back(columnVector);
}
}
return result;
}
| int main() {
// Test case 1
std::vector<std::vector<char>> input1 = {{'x', 'y'}, {'a', 'b'}, {'m', 'n'}};
std::vector<std::vector<char>> expected1 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}};
assert(func0(input1) == expected1);
// Test case 2
std::vector<std::vector<char>> input2 = {{'1', '2'}, {'3', '4'}, {'5', '6'}, {'7', '8'}};
std::vector<std::vector<char>> expected2 = {{'1', '3', '5', '7'}, {'2', '4', '6', '8'}};
assert(func0(input2) == expected2);
// Test case 3
std::vector<std::vector<char>> input3 = {{'x', 'y', 'z'}, {'a', 'b', 'c'}, {'m', 'n', 'o'}};
std::vector<std::vector<char>> expected3 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}, {'z', 'c', 'o'}};
assert(func0(input3) == expected3);
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,0x10(%rsp)
mov %rsi,0x28(%rsp)
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov 0x8(%rsi),%r14
mov (%rsi),%rbx
cmp %r14,%rbx
je 1d88 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x2c8>
mov 0x8(%rbx),%rax
sub (%rbx),%rax
mov %rax,0x20(%rsp)
je 1d88 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x2c8>
xor %r13d,%r13d
nopl 0x0(%rax,%rax,1)
movq $0x0,0x30(%rsp)
movq $0x0,0x38(%rsp)
movq $0x0,0x40(%rsp)
cmp %rbx,%r14
je 1d30 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x270>
xor %r12d,%r12d
xor %eax,%eax
jmp 1b83 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0xc3>
nopl 0x0(%rax,%rax,1)
movzbl 0x0(%rbp),%edx
add $0x18,%rbx
mov %dl,(%rax)
addq $0x1,0x38(%rsp)
cmp %rbx,%r14
je 1c20 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x160>
mov 0x38(%rsp),%rax
mov 0x40(%rsp),%r12
mov (%rbx),%rbp
add %r13,%rbp
cmp %rax,%r12
jne 1b60 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0xa0>
mov 0x30(%rsp),%rax
mov %rax,0x8(%rsp)
sub %rax,%r12
movabs $0x7fffffffffffffff,%rax
cmp %rax,%r12
je 1ddf <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x31f>
mov $0x1,%r15d
test %r12,%r12
je 1bd0 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x110>
lea (%r12,%r12,1),%r15
cmp %r15,%r12
jbe 1ce0 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x220>
movabs $0x7fffffffffffffff,%r15
mov %r15,%rdi
callq 1180 <_Znwm@plt>
mov %rax,%rcx
add %rax,%r15
movzbl 0x0(%rbp),%eax
lea 0x1(%rcx,%r12,1),%rbp
mov %al,(%rcx,%r12,1)
test %r12,%r12
jg 1d00 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x240>
cmpq $0x0,0x8(%rsp)
jne 1d13 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x253>
add $0x18,%rbx
mov %rcx,0x30(%rsp)
mov %rbp,0x38(%rsp)
mov %r15,0x40(%rsp)
cmp %rbx,%r14
jne 1b79 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0xb9>
nopl 0x0(%rax)
mov 0x10(%rsp),%rax
mov 0x8(%rax),%rbx
mov 0x10(%rax),%rsi
cmp %rsi,%rbx
je 1d48 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x288>
mov 0x38(%rsp),%rbp
sub 0x30(%rsp),%rbp
movq $0x0,0x8(%rbx)
movq $0x0,(%rbx)
movq $0x0,0x10(%rbx)
je 1db0 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x2f0>
js 1df0 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x330>
mov %rbp,%rdi
callq 1180 <_Znwm@plt>
mov %rax,%rcx
mov 0x10(%rsp),%rax
add %rcx,%rbp
mov 0x8(%rax),%r12
mov %rcx,(%rbx)
xor %r14d,%r14d
mov %rcx,0x8(%rbx)
mov 0x38(%rsp),%rax
mov %rbp,0x10(%rbx)
mov 0x30(%rsp),%rbp
sub %rbp,%rax
jne 1d68 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x2a8>
mov 0x10(%rsp),%rax
add %r14,%rcx
add $0x18,%r12
mov %rcx,0x8(%rbx)
mov %r12,0x8(%rax)
test %rbp,%rbp
je 1cbc <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1fc>
mov %rbp,%rdi
callq 1170 <_ZdlPv@plt>
add $0x1,%r13
cmp 0x20(%rsp),%r13
je 1d88 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x2c8>
mov 0x28(%rsp),%rax
mov (%rax),%rbx
mov 0x8(%rax),%r14
jmpq 1b30 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x70>
nopl 0x0(%rax)
movabs $0x7fffffffffffffff,%rax
test %r15,%r15
cmovs %rax,%r15
jmpq 1bd0 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x110>
nopw %cs:0x0(%rax,%rax,1)
mov 0x8(%rsp),%rsi
mov %rcx,%rdi
mov %r12,%rdx
callq 11b0 <memmove@plt>
mov %rax,%rcx
mov 0x8(%rsp),%rdi
mov %rcx,0x18(%rsp)
callq 1170 <_ZdlPv@plt>
mov 0x18(%rsp),%rcx
jmpq 1c00 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x140>
nopl 0x0(%rax)
mov 0x10(%rsp),%rax
mov 0x8(%rax),%rbx
mov 0x10(%rax),%rsi
cmp %rsi,%rbx
jne 1dbc <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x2fc>
nopw 0x0(%rax,%rax,1)
mov 0x10(%rsp),%rdi
lea 0x30(%rsp),%rdx
callq 2150 <_ZNSt6vectorIS_IcSaIcEESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_>
mov 0x30(%rsp),%rbp
jmpq 1caf <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1ef>
nopl 0x0(%rax)
mov %rcx,%rdi
mov %rax,%rdx
mov %rbp,%rsi
mov %rax,%r14
callq 11b0 <memmove@plt>
mov %rax,%rcx
jmpq 1c9b <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1db>
nopl 0x0(%rax)
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 1deb <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x32b>
mov 0x10(%rsp),%rax
add $0x58,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %rbx,%r12
xor %ebp,%ebp
xor %ecx,%ecx
jmpq 1c7a <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1ba>
movq $0x0,(%rbx)
mov %rbx,%r12
xor %ebp,%ebp
xor %ecx,%ecx
movq $0x0,0x8(%rbx)
movq $0x0,0x10(%rbx)
jmpq 1c7a <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1ba>
lea 0x1253(%rip),%rdi
callq 1140 <_ZSt20__throw_length_errorPKc@plt>
callq 1190 <__stack_chk_fail@plt>
callq 1110 <_ZSt17__throw_bad_allocv@plt>
endbr64
mov %rax,%rbp
jmpq 11e0 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov r12, [rsi+8]
mov rbx, [rsi]
cmp r12, rbx
jz loc_1F08
mov rax, [rbx+8]
sub rax, [rbx]
mov [rsp+68h+var_60], rax
jz loc_1F08
mov r15, rsi
xor ebp, ebp
nop dword ptr [rax+rax+00h]
loc_1DA0:
mov [rsp+68h+var_48], 0
pxor xmm1, xmm1
movaps xmmword ptr [rsp+68h+src], xmm1
cmp r12, rbx
jz loc_1F58
xor eax, eax
xor esi, esi
lea r14, [rsp+68h+src]
jmp short loc_1DF2
loc_1DD0:
movzx eax, byte ptr [rdx]
add rsi, 1
add rbx, 18h
mov [rsi-1], al
mov [rsp+68h+src+8], rsi
cmp r12, rbx
jz short loc_1E18
loc_1DE8:
mov rsi, [rsp+68h+src+8]
mov rax, [rsp+68h+var_48]
loc_1DF2:
mov rdx, [rbx]
add rdx, rbp
cmp rsi, rax
jnz short loc_1DD0
mov rdi, r14
mov [rsp+68h+var_68], r14
call _ZNSt6vectorIcSaIcEE17_M_realloc_insertIJRKcEEEvN9__gnu_cxx17__normal_iteratorIPcS1_EEDpOT_; std::vector<char>::_M_realloc_insert<char const&>(__gnu_cxx::__normal_iterator<char *,std::vector<char>>,char const&)
add rbx, 18h
cmp r12, rbx
jnz short loc_1DE8
nop word ptr [rax+rax+00h]
loc_1E18:
mov rbx, [r13+8]
mov rsi, [r13+10h]
cmp rbx, rsi
jz loc_1ED0
mov r12, [rsp+68h+src]
mov r14, [rsp+68h+src+8]
pxor xmm2, xmm2
mov qword ptr [rbx+10h], 0
movups xmmword ptr [rbx], xmm2
sub r14, r12
jz loc_1F30
js loc_1F8E
lea rax, [rsp+68h+src]
mov rdi, r14; unsigned __int64
mov [rsp+68h+var_68], rax
call __Znwm; operator new(ulong)
movq xmm0, rax
lea rcx, [rax+r14]
mov rdi, rax; dest
punpcklqdq xmm0, xmm0
mov [rbx+10h], rcx
movups xmmword ptr [rbx], xmm0
cmp r14, 1
jz loc_1FAC
mov rsi, r12; src
mov rdx, r14; n
mov [rsp+68h+var_68], rcx
call _memmove
mov rax, [r13+8]
mov rcx, [rsp+68h+var_68]
mov rsi, [rsp+68h+var_48]
add rax, 18h
mov [rbx+8], rcx
mov [r13+8], rax
sub rsi, r12; unsigned __int64
loc_1EAE:
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1EB6:
mov rax, [rsp+68h+var_60]
add rbp, 1
cmp rbp, rax
jz short loc_1F08
loc_1EC4:
mov r12, [r15+8]
mov rbx, [r15]
jmp loc_1DA0
loc_1ED0:
lea rdx, [rsp+68h+src]
mov rdi, r13
mov [rsp+68h+var_68], rdx
call _ZNSt6vectorIS_IcSaIcEESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<std::vector<char>>::_M_realloc_insert<std::vector<char> const&>(__gnu_cxx::__normal_iterator<std::vector<char>*,std::vector<std::vector<char>>>,std::vector<char> const&)
mov r12, [rsp+68h+src]
mov rsi, [rsp+68h+var_48]
sub rsi, r12
loc_1EEE:
test r12, r12
jnz short loc_1EAE
mov rax, [rsp+68h+var_60]
add rbp, 1
cmp rbp, rax
jnz short loc_1EC4
nop dword ptr [rax+00000000h]
loc_1F08:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz loc_1FD0
add rsp, 38h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1F30:
mov rsi, [rsp+68h+var_48]
mov qword ptr [rbx+10h], 0
add rbx, 18h
mov qword ptr [rbx-10h], 0
sub rsi, r12
mov [r13+8], rbx
jmp short loc_1EEE
loc_1F58:
mov rax, [r13+8]
mov rsi, [r13+10h]
cmp rax, rsi
jz loc_1ED0
pxor xmm3, xmm3
mov qword ptr [rax+10h], 0
add rax, 18h
movups xmmword ptr [rax-18h], xmm3
mov qword ptr [rax-10h], 0
mov [r13+8], rax
jmp loc_1EB6
loc_1F8E:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1FD0
lea rax, [rsp+68h+src]
mov [rsp+68h+var_68], rax
call __ZSt17__throw_bad_allocv; std::__throw_bad_alloc(void)
loc_1FAC:
movzx eax, byte ptr [r12]
mov rsi, [rsp+68h+var_48]
mov [rdi], al
mov rax, [r13+8]
sub rsi, r12
mov [rbx+8], rcx
add rax, 18h
mov [r13+8], rax
jmp loc_1EAE
loc_1FD0:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE_cold; func0(std::vector<std::vector<char>> const&) [clone] | long long func0(long long a1, long long a2)
{
_QWORD *v2; // r12
_QWORD *v3; // rbx
long long v5; // rbp
char *v6; // rax
char *v7; // rsi
char *v8; // rsi
char *v9; // rdx
long long v10; // rbx
_BYTE *v11; // r12
_BYTE *v12; // r14
signed long long v13; // r14
_BYTE *v14; // rax
_BYTE *v15; // rcx
char *v16; // rsi
long long v17; // rax
unsigned long long v18; // rsi
char *v20; // rsi
long long v21; // rbx
long long v22; // rax
long long v23; // rax
char *v24; // rsi
long long v25; // rax
_BYTE *v26; // [rsp+0h] [rbp-68h]
long long v27; // [rsp+8h] [rbp-60h]
void *src[2]; // [rsp+10h] [rbp-58h] BYREF
char *v29; // [rsp+20h] [rbp-48h]
unsigned long long v30; // [rsp+28h] [rbp-40h]
v30 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = *(_QWORD **)(a2 + 8);
v3 = *(_QWORD **)a2;
if ( v2 == *(_QWORD **)a2 )
return a1;
v27 = v3[1] - *v3;
if ( !v27 )
return a1;
v5 = 0LL;
while ( 2 )
{
v29 = 0LL;
*(_OWORD *)src = 0LL;
if ( v2 == v3 )
{
v22 = *(_QWORD *)(a1 + 8);
if ( v22 != *(_QWORD *)(a1 + 16) )
{
*(_QWORD *)(v22 + 16) = 0LL;
v23 = v22 + 24;
*(_OWORD *)(v23 - 24) = 0LL;
*(_QWORD *)(v23 - 16) = 0LL;
*(_QWORD *)(a1 + 8) = v23;
goto LABEL_16;
}
LABEL_18:
std::vector<std::vector<char>>::_M_realloc_insert<std::vector<char> const&>(a1);
v11 = src[0];
v18 = v29 - (char *)src[0];
goto LABEL_19;
}
v6 = 0LL;
v7 = 0LL;
while ( 1 )
{
v9 = (char *)(v5 + *v3);
if ( v7 == v6 )
break;
v8 = v7 + 1;
v3 += 3;
*(v8 - 1) = *v9;
src[1] = v8;
if ( v2 == v3 )
goto LABEL_10;
LABEL_7:
v7 = (char *)src[1];
v6 = v29;
}
std::vector<char>::_M_realloc_insert<char const&>(src, v7, v9);
v3 += 3;
if ( v2 != v3 )
goto LABEL_7;
LABEL_10:
v10 = *(_QWORD *)(a1 + 8);
if ( v10 == *(_QWORD *)(a1 + 16) )
goto LABEL_18;
v11 = src[0];
v12 = src[1];
*(_QWORD *)(v10 + 16) = 0LL;
*(_OWORD *)v10 = 0LL;
v13 = v12 - v11;
if ( v13 )
{
if ( v13 < 0 )
std::__throw_bad_alloc();
v14 = (_BYTE *)operator new(v13);
v15 = &v14[v13];
*(_QWORD *)(v10 + 16) = &v14[v13];
*(__m128i *)v10 = _mm_unpacklo_epi64((__m128i)(unsigned long long)v14, (__m128i)(unsigned long long)v14);
if ( v13 == 1 )
{
v24 = v29;
*v14 = *v11;
v25 = *(_QWORD *)(a1 + 8);
v18 = v24 - v11;
*(_QWORD *)(v10 + 8) = v15;
*(_QWORD *)(a1 + 8) = v25 + 24;
}
else
{
v26 = &v14[v13];
memmove(v14, v11, v13);
v16 = v29;
v17 = *(_QWORD *)(a1 + 8) + 24LL;
*(_QWORD *)(v10 + 8) = v26;
*(_QWORD *)(a1 + 8) = v17;
v18 = v16 - v11;
}
LABEL_15:
operator delete(v11, v18);
LABEL_16:
if ( ++v5 == v27 )
return a1;
LABEL_17:
v2 = *(_QWORD **)(a2 + 8);
v3 = *(_QWORD **)a2;
continue;
}
break;
}
v20 = v29;
*(_QWORD *)(v10 + 16) = 0LL;
v21 = v10 + 24;
*(_QWORD *)(v21 - 16) = 0LL;
v18 = v20 - v11;
*(_QWORD *)(a1 + 8) = v21;
LABEL_19:
if ( v11 )
goto LABEL_15;
if ( ++v5 != v27 )
goto LABEL_17;
return a1;
} | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV R12,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
CMP R12,RBX
JZ 0x00101f08
MOV RAX,qword ptr [RBX + 0x8]
SUB RAX,qword ptr [RBX]
MOV qword ptr [RSP + 0x8],RAX
JZ 0x00101f08
MOV R15,RSI
XOR EBP,EBP
NOP dword ptr [RAX + RAX*0x1]
LAB_00101da0:
MOV qword ptr [RSP + 0x20],0x0
PXOR XMM1,XMM1
MOVAPS xmmword ptr [RSP + 0x10],XMM1
CMP R12,RBX
JZ 0x00101f58
XOR EAX,EAX
XOR ESI,ESI
LEA R14,[RSP + 0x10]
JMP 0x00101df2
LAB_00101dd0:
MOVZX EAX,byte ptr [RDX]
ADD RSI,0x1
ADD RBX,0x18
MOV byte ptr [RSI + -0x1],AL
MOV qword ptr [RSP + 0x18],RSI
CMP R12,RBX
JZ 0x00101e18
LAB_00101de8:
MOV RSI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x20]
LAB_00101df2:
MOV RDX,qword ptr [RBX]
ADD RDX,RBP
CMP RSI,RAX
JNZ 0x00101dd0
MOV RDI,R14
MOV qword ptr [RSP],R14
LAB_00101e04:
CALL 0x00102320
ADD RBX,0x18
CMP R12,RBX
JNZ 0x00101de8
NOP word ptr [RAX + RAX*0x1]
LAB_00101e18:
MOV RBX,qword ptr [R13 + 0x8]
MOV RSI,qword ptr [R13 + 0x10]
CMP RBX,RSI
JZ 0x00101ed0
MOV R12,qword ptr [RSP + 0x10]
MOV R14,qword ptr [RSP + 0x18]
PXOR XMM2,XMM2
MOV qword ptr [RBX + 0x10],0x0
MOVUPS xmmword ptr [RBX],XMM2
SUB R14,R12
JZ 0x00101f30
JS 0x00101f8e
LEA RAX,[RSP + 0x10]
MOV RDI,R14
MOV qword ptr [RSP],RAX
CALL 0x00101170
MOVQ XMM0,RAX
LEA RCX,[RAX + R14*0x1]
MOV RDI,RAX
PUNPCKLQDQ XMM0,XMM0
MOV qword ptr [RBX + 0x10],RCX
MOVUPS xmmword ptr [RBX],XMM0
CMP R14,0x1
JZ 0x00101fac
MOV RSI,R12
MOV RDX,R14
MOV qword ptr [RSP],RCX
CALL 0x001011b0
MOV RAX,qword ptr [R13 + 0x8]
MOV RCX,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x20]
ADD RAX,0x18
MOV qword ptr [RBX + 0x8],RCX
MOV qword ptr [R13 + 0x8],RAX
SUB RSI,R12
LAB_00101eae:
MOV RDI,R12
CALL 0x00101180
LAB_00101eb6:
MOV RAX,qword ptr [RSP + 0x8]
ADD RBP,0x1
CMP RBP,RAX
JZ 0x00101f08
LAB_00101ec4:
MOV R12,qword ptr [R15 + 0x8]
MOV RBX,qword ptr [R15]
JMP 0x00101da0
LAB_00101ed0:
LEA RDX,[RSP + 0x10]
MOV RDI,R13
MOV qword ptr [RSP],RDX
CALL 0x00102470
MOV R12,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x20]
SUB RSI,R12
LAB_00101eee:
TEST R12,R12
JNZ 0x00101eae
MOV RAX,qword ptr [RSP + 0x8]
ADD RBP,0x1
CMP RBP,RAX
JNZ 0x00101ec4
NOP dword ptr [RAX]
LAB_00101f08:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101fd0
ADD RSP,0x38
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101f30:
MOV RSI,qword ptr [RSP + 0x20]
MOV qword ptr [RBX + 0x10],0x0
ADD RBX,0x18
MOV qword ptr [RBX + -0x10],0x0
SUB RSI,R12
MOV qword ptr [R13 + 0x8],RBX
JMP 0x00101eee
LAB_00101f58:
MOV RAX,qword ptr [R13 + 0x8]
MOV RSI,qword ptr [R13 + 0x10]
CMP RAX,RSI
JZ 0x00101ed0
PXOR XMM3,XMM3
MOV qword ptr [RAX + 0x10],0x0
ADD RAX,0x18
MOVUPS xmmword ptr [RAX + -0x18],XMM3
MOV qword ptr [RAX + -0x10],0x0
MOV qword ptr [R13 + 0x8],RAX
JMP 0x00101eb6
LAB_00101f8e:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101fd0
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
CALL 0x00101110
LAB_00101fac:
MOVZX EAX,byte ptr [R12]
MOV RSI,qword ptr [RSP + 0x20]
MOV byte ptr [RDI],AL
MOV RAX,qword ptr [R13 + 0x8]
SUB RSI,R12
MOV qword ptr [RBX + 0x8],RCX
ADD RAX,0x18
MOV qword ptr [R13 + 0x8],RAX
JMP 0x00101eae
LAB_00101fd0:
CALL 0x00101190 | /* func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char,
std::allocator<char> > > > const&) */
vector * func0(vector *param_1)
{
long lVar1;
long lVar2;
vector *pvVar3;
long lVar4;
char *pcVar5;
vector<char,std::allocator<char>> *__dest;
vector<char,std::allocator<char>> *in_RCX;
long *plVar6;
long lVar7;
long *in_RSI;
vector *pvVar8;
vector<char,std::allocator<char>> *__src;
long *plVar9;
ulong uVar10;
long in_FS_OFFSET;
int local_58 [16];
char *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
plVar9 = (long *)in_RSI[1];
plVar6 = (long *)*in_RSI;
if ((plVar9 != plVar6) && (lVar1 = plVar6[1], lVar2 = *plVar6, lVar1 != lVar2)) {
lVar7 = 0;
__dest = (vector<char,std::allocator<char>> *)param_1;
do {
local_48 = (char *)0x0;
local_58 = (int [16])0x0;
if (plVar9 == plVar6) {
pvVar3 = *(vector **)(param_1 + 8);
pvVar8 = *(vector **)(param_1 + 0x10);
if (pvVar3 == pvVar8) {
LAB_00101ed0:
__dest = (vector<char,std::allocator<char>> *)param_1;
std::
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
::_M_realloc_insert<std::vector<char,std::allocator<char>>const&>
((__normal_iterator)param_1,pvVar8);
uVar10 = (long)local_48 - local_58._0_8_;
LAB_00101eee:
__src = (vector<char,std::allocator<char>> *)local_58._0_8_;
if ((vector<char,std::allocator<char>> *)local_58._0_8_ !=
(vector<char,std::allocator<char>> *)0x0) goto LAB_00101eae;
}
else {
*(int8 *)(pvVar3 + 0x10) = 0;
*(int (*) [16])pvVar3 = (int [16])0x0;
*(int8 *)(pvVar3 + 8) = 0;
*(vector **)(param_1 + 8) = pvVar3 + 0x18;
}
}
else {
local_58._8_8_ = (char *)0x0;
while( true ) {
if ((char *)local_58._8_8_ == local_48) {
__dest = (vector<char,std::allocator<char>> *)local_58;
/* try { // try from 00101e04 to 00101fab has its CatchHandler @ 00101fd5 */
std::vector<char,std::allocator<char>>::_M_realloc_insert<char_const&>
((vector<char,std::allocator<char>> *)local_58,
(__normal_iterator)local_58._8_8_,(char *)(*plVar6 + lVar7));
}
else {
*(char *)local_58._8_8_ = *(char *)(*plVar6 + lVar7);
local_58._8_8_ = (char *)(local_58._8_8_ + 1);
}
if (plVar9 == plVar6 + 3) break;
plVar6 = plVar6 + 3;
}
pvVar3 = *(vector **)(param_1 + 8);
pvVar8 = *(vector **)(param_1 + 0x10);
if (pvVar3 == pvVar8) goto LAB_00101ed0;
__src = (vector<char,std::allocator<char>> *)local_58._0_8_;
*(int8 *)(pvVar3 + 0x10) = 0;
*(int (*) [16])pvVar3 = (int [16])0x0;
uVar10 = local_58._8_8_ - local_58._0_8_;
if (uVar10 == 0) {
*(int8 *)(pvVar3 + 0x10) = 0;
*(int8 *)(pvVar3 + 8) = 0;
uVar10 = (long)local_48 - local_58._0_8_;
*(vector **)(param_1 + 8) = pvVar3 + 0x18;
goto LAB_00101eee;
}
if ((long)uVar10 < 0) {
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_00101fd0;
std::__throw_bad_alloc();
}
else {
__dest = (vector<char,std::allocator<char>> *)operator_new(uVar10);
in_RCX = __dest + uVar10;
*(vector<char,std::allocator<char>> **)(pvVar3 + 0x10) = in_RCX;
*(vector<char,std::allocator<char>> **)pvVar3 = __dest;
*(vector<char,std::allocator<char>> **)(pvVar3 + 8) = __dest;
if (uVar10 != 1) {
memmove(__dest,__src,uVar10);
lVar4 = *(long *)(param_1 + 8);
*(vector<char,std::allocator<char>> **)(pvVar3 + 8) = in_RCX;
*(long *)(param_1 + 8) = lVar4 + 0x18;
uVar10 = (long)local_48 - (long)__src;
goto LAB_00101eae;
}
}
pcVar5 = local_48;
*__dest = *__src;
lVar4 = *(long *)(param_1 + 8);
uVar10 = (long)pcVar5 - (long)__src;
*(vector<char,std::allocator<char>> **)(pvVar3 + 8) = in_RCX;
*(long *)(param_1 + 8) = lVar4 + 0x18;
LAB_00101eae:
operator_delete(__src,uVar10);
__dest = __src;
}
if (lVar7 + 1 == lVar1 - lVar2) break;
lVar7 = lVar7 + 1;
plVar9 = (long *)in_RSI[1];
plVar6 = (long *)*in_RSI;
} while( true );
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
LAB_00101fd0:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,447 | func0 |
#include <vector>
#include <cassert>
| std::vector<std::vector<char>> func0(const std::vector<std::vector<char>>& lst) {
std::vector<std::vector<char>> result;
if (!lst.empty()) {
size_t numColumns = lst[0].size();
for (size_t i = 0; i < numColumns; ++i) {
std::vector<char> columnVector;
for (const auto& row : lst) {
columnVector.push_back(row[i]);
}
result.push_back(columnVector);
}
}
return result;
}
| int main() {
// Test case 1
std::vector<std::vector<char>> input1 = {{'x', 'y'}, {'a', 'b'}, {'m', 'n'}};
std::vector<std::vector<char>> expected1 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}};
assert(func0(input1) == expected1);
// Test case 2
std::vector<std::vector<char>> input2 = {{'1', '2'}, {'3', '4'}, {'5', '6'}, {'7', '8'}};
std::vector<std::vector<char>> expected2 = {{'1', '3', '5', '7'}, {'2', '4', '6', '8'}};
assert(func0(input2) == expected2);
// Test case 3
std::vector<std::vector<char>> input3 = {{'x', 'y', 'z'}, {'a', 'b', 'c'}, {'m', 'n', 'o'}};
std::vector<std::vector<char>> expected3 = {{'x', 'a', 'm'}, {'y', 'b', 'n'}, {'z', 'c', 'o'}};
assert(func0(input3) == expected3);
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,0x8(%rsp)
mov %rsi,0x28(%rsp)
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov 0x8(%rsi),%r14
mov (%rsi),%rbx
cmp %r14,%rbx
je 1d8b <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x26b>
mov 0x8(%rbx),%rax
sub (%rbx),%rax
mov %rax,0x20(%rsp)
je 1d8b <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x26b>
xor %r13d,%r13d
movq $0x0,0x40(%rsp)
pxor %xmm0,%xmm0
movaps %xmm0,0x30(%rsp)
cmp %rbx,%r14
je 1db8 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x298>
xor %r12d,%r12d
xor %r15d,%r15d
jmp 1bcf <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0xaf>
nopl 0x0(%rax,%rax,1)
movzbl 0x0(%rbp),%eax
add $0x18,%rbx
mov %al,(%r15)
mov 0x38(%rsp),%rax
lea 0x1(%rax),%r15
mov %r15,0x38(%rsp)
cmp %rbx,%r14
je 1c80 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x160>
mov 0x40(%rsp),%r12
mov (%rbx),%rbp
add %r13,%rbp
cmp %r15,%r12
jne 1ba8 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x88>
mov 0x30(%rsp),%rax
mov %rax,(%rsp)
sub %rax,%r12
movabs $0x7fffffffffffffff,%rax
cmp %rax,%r12
je 1e34 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x314>
mov $0x1,%r15d
test %r12,%r12
je 1c1b <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0xfb>
lea (%r12,%r12,1),%r15
cmp %r15,%r12
jbe 1d38 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x218>
movabs $0x7fffffffffffffff,%r15
mov %r15,%rdi
callq 1180 <_Znwm@plt>
mov %rax,%r8
lea (%rax,%r15,1),%rax
mov %rax,0x10(%rsp)
movzbl 0x0(%rbp),%eax
lea 0x1(%r8,%r12,1),%r15
mov %al,(%r8,%r12,1)
test %r12,%r12
jg 1d50 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x230>
cmpq $0x0,(%rsp)
jne 1d62 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x242>
mov 0x10(%rsp),%rax
movq %r8,%xmm0
movq %r15,%xmm1
add $0x18,%rbx
punpcklqdq %xmm1,%xmm0
mov %rax,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
cmp %rbx,%r14
jne 1bca <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0xaa>
nopw 0x0(%rax,%rax,1)
mov 0x8(%rsp),%rax
mov 0x8(%rax),%rbp
mov 0x10(%rax),%rsi
cmp %rsi,%rbp
je 1dd0 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x2b0>
sub 0x30(%rsp),%r15
pxor %xmm0,%xmm0
movq $0x0,0x10(%rbp)
movups %xmm0,0x0(%rbp)
je 1e10 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x2f0>
js 1e45 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x325>
mov %r15,%rdi
callq 1180 <_Znwm@plt>
mov %rax,%rcx
mov 0x8(%rsp),%rax
lea (%rcx,%r15,1),%rbx
mov 0x8(%rax),%r14
movq %rcx,%xmm0
mov %rbx,0x10(%rbp)
xor %ebx,%ebx
punpcklqdq %xmm0,%xmm0
movups %xmm0,0x0(%rbp)
mov 0x30(%rsp),%r12
mov 0x38(%rsp),%rax
sub %r12,%rax
jne 1df0 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x2d0>
mov 0x8(%rsp),%rax
add %rbx,%rcx
add $0x18,%r14
mov %rcx,0x8(%rbp)
mov %r14,0x8(%rax)
test %r12,%r12
je 1d80 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x260>
mov %r12,%rdi
add $0x1,%r13
callq 1170 <_ZdlPv@plt>
cmp %r13,0x20(%rsp)
je 1d8b <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x26b>
mov 0x28(%rsp),%rax
mov (%rax),%rbx
mov 0x8(%rax),%r14
jmpq 1b80 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x60>
nopw 0x0(%rax,%rax,1)
movabs $0x7fffffffffffffff,%rax
test %r15,%r15
cmovs %rax,%r15
jmpq 1c1b <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0xfb>
xchg %ax,%ax
mov (%rsp),%rsi
mov %r8,%rdi
mov %r12,%rdx
callq 11b0 <memmove@plt>
mov %rax,%r8
mov (%rsp),%rdi
mov %r8,0x18(%rsp)
callq 1170 <_ZdlPv@plt>
mov 0x18(%rsp),%r8
jmpq 1c50 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x130>
nopw 0x0(%rax,%rax,1)
add $0x1,%r13
cmp 0x20(%rsp),%r13
jne 1d21 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x201>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 1e40 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x320>
mov 0x8(%rsp),%rax
add $0x58,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov 0x8(%rsp),%rax
mov 0x8(%rax),%rbp
mov 0x10(%rax),%rsi
cmp %rsi,%rbp
jne 1e1c <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x2fc>
nopw 0x0(%rax,%rax,1)
mov 0x8(%rsp),%rdi
lea 0x30(%rsp),%rdx
callq 2100 <_ZNSt6vectorIS_IcSaIcEESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_>
mov 0x30(%rsp),%r12
jmpq 1d09 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1e9>
nopl 0x0(%rax)
mov %rcx,%rdi
mov %rax,%rdx
mov %r12,%rsi
mov %rax,%rbx
callq 11b0 <memmove@plt>
mov %rax,%rcx
jmpq 1cf5 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1d5>
nopl 0x0(%rax)
mov %rbp,%r14
xor %ebx,%ebx
xor %ecx,%ecx
jmpq 1ccf <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1af>
movq $0x0,0x10(%rbp)
mov %rbp,%r14
xor %ebx,%ebx
xor %ecx,%ecx
movups %xmm0,0x0(%rbp)
jmpq 1ccf <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE+0x1af>
lea 0x1247(%rip),%rdi
callq 1140 <_ZSt20__throw_length_errorPKc@plt>
callq 1190 <__stack_chk_fail@plt>
callq 1110 <_ZSt17__throw_bad_allocv@plt>
endbr64
mov %rax,%rbp
jmpq 11f5 <_Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE.cold>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov [rsp+98h+var_88], rdi
mov [rsp+98h+var_68], rsi
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov r14, [rsi+8]
mov rbx, [rsi]
cmp r14, rbx
jz loc_20D7
mov rax, [rbx+8]
sub rax, [rbx]
mov [rsp+98h+var_60], rax
jz loc_20D7
xor r13d, r13d
loc_1E50:
mov [rsp+98h+var_48], 0
pxor xmm0, xmm0
movaps xmmword ptr [rsp+98h+var_58], xmm0
cmp r14, rbx
jz loc_2120
xor ebp, ebp
xor ecx, ecx
jmp short loc_1E96
loc_1E78:
movzx eax, byte ptr [r12]
add rcx, 1
add rbx, 18h
mov [rcx-1], al
mov [rsp+98h+var_58+8], rcx
cmp r14, rbx
jz loc_1F90
loc_1E96:
mov r12, [rbx]
add r12, r13
cmp rcx, rbp
jnz short loc_1E78
mov rax, [rsp+98h+var_58]
sub rcx, rax
mov [rsp+98h+src], rax
mov rax, 7FFFFFFFFFFFFFFFh
mov r15, rcx
cmp rcx, rax
jz loc_2198
test rcx, rcx
jz loc_2050
mov rax, 7FFFFFFFFFFFFFFFh
lea rdx, [rcx+rcx]
cmp rdx, rax
cmovbe rax, rdx
cmp rdx, rcx
mov rdx, 7FFFFFFFFFFFFFFFh
cmovb rax, rdx
lea rdx, [rsp+98h+var_58]
mov [rsp+98h+var_78], rdx
mov rdi, rax; unsigned __int64
mov [rsp+98h+var_80], rax
call __Znwm; operator new(ulong)
mov r8, rax
movzx eax, byte ptr [r12]
mov [r8+r15], al
test r15, r15
jle loc_2078
mov rsi, [rsp+98h+src]; src
lea rcx, [r8+r15+1]
mov rdi, r8; dest
mov rdx, r15; n
mov [rsp+98h+var_78], rcx
sub rbp, rsi
call _memmove
mov rcx, [rsp+98h+var_78]
mov r8, rax
loc_1F44:
mov rdi, [rsp+98h+src]; void *
mov rsi, rbp; unsigned __int64
mov [rsp+98h+var_70], rcx
mov [rsp+98h+var_78], r8
call __ZdlPvm; operator delete(void *,ulong)
mov rcx, [rsp+98h+var_70]
mov r8, [rsp+98h+var_78]
loc_1F65:
mov rbp, [rsp+98h+var_80]
add rbx, 18h
mov [rsp+98h+var_58], r8
mov [rsp+98h+var_58+8], rcx
add rbp, r8
mov [rsp+98h+var_48], rbp
cmp r14, rbx
jnz loc_1E96
nop dword ptr [rax+00000000h]
loc_1F90:
mov rax, [rsp+98h+var_88]
mov rbx, [rax+8]
mov rsi, [rax+10h]
cmp rbx, rsi
jz loc_20A0
mov r12, [rsp+98h+var_58]
pxor xmm0, xmm0
mov qword ptr [rbx+10h], 0
movups xmmword ptr [rbx], xmm0
sub rcx, r12
mov r14, rcx
jz loc_2100
js loc_2155
lea rax, [rsp+98h+var_58]
mov rdi, rcx; unsigned __int64
mov [rsp+98h+var_78], rax
call __Znwm; operator new(ulong)
movq xmm0, rax
lea r15, [rax+r14]
mov rdi, rax; dest
punpcklqdq xmm0, xmm0
mov [rbx+10h], r15
movups xmmword ptr [rbx], xmm0
cmp r14, 1
jz loc_2174
mov rsi, r12; src
mov rdx, r14; n
sub rbp, r12
call _memcpy
mov rsi, [rsp+98h+var_88]
mov rax, [rsi+8]
mov [rbx+8], r15
add rax, 18h
mov [rsi+8], rax
loc_2022:
mov rsi, rbp; unsigned __int64
mov rdi, r12; void *
add r13, 1
call __ZdlPvm; operator delete(void *,ulong)
cmp [rsp+98h+var_60], r13
jz loc_20D7
loc_203C:
mov rax, [rsp+98h+var_68]
mov r14, [rax+8]
mov rbx, [rax]
jmp loc_1E50
loc_2050:
lea rax, [rsp+98h+var_58]
mov edi, 1; unsigned __int64
mov [rsp+98h+var_78], rax
call __Znwm; operator new(ulong)
mov [rsp+98h+var_80], 1
mov r8, rax
movzx eax, byte ptr [r12]
mov [r8], al
loc_2078:
cmp [rsp+98h+src], 0
lea rcx, [r8+r15+1]
jz loc_1F65
mov rax, [rsp+98h+src]
sub rbp, rax
jmp loc_1F44
loc_20A0:
mov rdi, [rsp+98h+var_88]
lea rdx, [rsp+98h+var_58]
mov [rsp+98h+var_78], rdx
call _ZNSt6vectorIS_IcSaIcEESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<std::vector<char>>::_M_realloc_insert<std::vector<char> const&>(__gnu_cxx::__normal_iterator<std::vector<char>*,std::vector<std::vector<char>>>,std::vector<char> const&)
mov r12, [rsp+98h+var_58]
sub rbp, r12
loc_20BC:
test r12, r12
jnz loc_2022
loc_20C5:
mov rax, [rsp+98h+var_60]
add r13, 1
cmp r13, rax
jnz loc_203C
loc_20D7:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz loc_21BE
mov rax, [rsp+98h+var_88]
add rsp, 68h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_2100:
mov qword ptr [rbx+10h], 0
add rbx, 18h
sub rbp, r12
mov qword ptr [rbx-10h], 0
mov [rax+8], rbx
jmp short loc_20BC
loc_2120:
mov rax, [rsp+98h+var_88]
xor ebp, ebp
mov rsi, [rax+8]
cmp [rax+10h], rsi
jz loc_20A0
movups xmmword ptr [rsi], xmm0
add rsi, 18h
mov qword ptr [rsi-8], 0
mov qword ptr [rsi-10h], 0
mov [rax+8], rsi
jmp loc_20C5
loc_2155:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz short loc_21BE
lea rax, [rsp+98h+var_58]
mov [rsp+98h+var_78], rax
call __ZSt17__throw_bad_allocv; std::__throw_bad_alloc(void)
loc_2174:
movzx eax, byte ptr [r12]
mov rdx, [rsp+98h+var_88]
sub rbp, r12
mov [rdi], al
mov rax, [rdx+8]
mov [rbx+8], r15
add rax, 18h
mov [rdx+8], rax
jmp loc_2022
loc_2198:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz short loc_21BE
lea rax, [rsp+98h+var_58]
lea rdi, aVectorMRealloc; "vector::_M_realloc_insert"
mov [rsp+98h+var_78], rax
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_21BE:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIS_IcSaIcEESaIS1_EE_cold; func0(std::vector<std::vector<char>> const&) [clone] | long long func0(long long a1, long long a2)
{
_QWORD *v2; // r14
_QWORD *v3; // rbx
long long v4; // r13
_BYTE *v5; // rbp
long long v6; // rcx
_BYTE *v7; // r12
unsigned long long v8; // rcx
signed long long v9; // r15
unsigned long long v10; // rax
_BYTE *v11; // r8
unsigned long long v12; // rbp
_BYTE *v13; // rax
long long v14; // rbx
void *v15; // r12
signed long long v16; // rcx
size_t v17; // r14
_BYTE *v18; // rax
_BYTE *v19; // r15
unsigned long long v20; // rbp
long long v21; // rax
long long v23; // rbx
_OWORD *v24; // rsi
char *v25; // rsi
long long v26; // [rsp+10h] [rbp-80h]
long long v27; // [rsp+18h] [rbp-78h]
_BYTE *v28; // [rsp+18h] [rbp-78h]
long long v29; // [rsp+20h] [rbp-70h]
long long v31; // [rsp+30h] [rbp-60h]
_BYTE *v32; // [rsp+38h] [rbp-58h]
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = *(_QWORD **)(a2 + 8);
v3 = *(_QWORD **)a2;
if ( v2 == *(_QWORD **)a2 )
return a1;
v31 = v3[1] - *v3;
if ( !v31 )
return a1;
v4 = 0LL;
while ( 2 )
{
v32 = 0LL;
if ( v2 == v3 )
{
v5 = 0LL;
v24 = *(_OWORD **)(a1 + 8);
if ( *(_OWORD **)(a1 + 16) != v24 )
{
*v24 = 0LL;
v25 = (char *)v24 + 24;
*((_QWORD *)v25 - 1) = 0LL;
*((_QWORD *)v25 - 2) = 0LL;
*(_QWORD *)(a1 + 8) = v25;
goto LABEL_31;
}
LABEL_29:
std::vector<std::vector<char>>::_M_realloc_insert<std::vector<char> const&>(a1);
v15 = v32;
v20 = v5 - v32;
goto LABEL_30;
}
v5 = 0LL;
v6 = 0LL;
do
{
while ( 1 )
{
v7 = (_BYTE *)(v4 + *v3);
if ( (_BYTE *)v6 == v5 )
break;
++v6;
v3 += 3;
*(_BYTE *)(v6 - 1) = *v7;
if ( v2 == v3 )
goto LABEL_18;
}
v8 = v6 - (_QWORD)v32;
v9 = v8;
if ( v8 == 0x7FFFFFFFFFFFFFFFLL )
std::__throw_length_error("vector::_M_realloc_insert");
if ( v8 )
{
v10 = 0x7FFFFFFFFFFFFFFFLL;
if ( 2 * v8 <= 0x7FFFFFFFFFFFFFFFLL )
v10 = 2 * v8;
if ( 2 * v8 < v8 )
v10 = 0x7FFFFFFFFFFFFFFFLL;
v26 = v10;
v11 = (_BYTE *)operator new(v10);
v11[v9] = *v7;
if ( v9 > 0 )
{
v27 = (long long)&v11[v9 + 1];
v12 = v5 - v32;
v13 = memmove(v11, v32, v9);
v6 = v27;
v11 = v13;
LABEL_16:
v29 = v6;
v28 = v11;
operator delete(v32, v12);
v6 = v29;
v11 = v28;
goto LABEL_17;
}
}
else
{
v26 = 1LL;
v11 = (_BYTE *)operator new(1uLL);
*v11 = *v7;
}
v6 = (long long)&v11[v9 + 1];
if ( v32 )
{
v12 = v5 - v32;
goto LABEL_16;
}
LABEL_17:
v3 += 3;
v32 = v11;
v5 = &v11[v26];
}
while ( v2 != v3 );
LABEL_18:
v14 = *(_QWORD *)(a1 + 8);
if ( v14 == *(_QWORD *)(a1 + 16) )
goto LABEL_29;
v15 = v32;
*(_QWORD *)(v14 + 16) = 0LL;
*(_OWORD *)v14 = 0LL;
v16 = v6 - (_QWORD)v32;
v17 = v16;
if ( v16 )
{
if ( v16 < 0 )
std::__throw_bad_alloc();
v18 = (_BYTE *)operator new(v16);
v19 = &v18[v17];
*(_QWORD *)(v14 + 16) = &v18[v17];
*(__m128i *)v14 = _mm_unpacklo_epi64((__m128i)(unsigned long long)v18, (__m128i)(unsigned long long)v18);
v20 = v5 - v32;
if ( v17 == 1 )
*v18 = *v32;
else
memcpy(v18, v32, v17);
v21 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(v14 + 8) = v19;
*(_QWORD *)(a1 + 8) = v21 + 24;
LABEL_24:
++v4;
operator delete(v15, v20);
if ( v31 == v4 )
return a1;
LABEL_25:
v2 = *(_QWORD **)(a2 + 8);
v3 = *(_QWORD **)a2;
continue;
}
break;
}
*(_QWORD *)(v14 + 16) = 0LL;
v23 = v14 + 24;
v20 = v5 - v32;
*(_QWORD *)(v23 - 16) = 0LL;
*(_QWORD *)(a1 + 8) = v23;
LABEL_30:
if ( v15 )
goto LABEL_24;
LABEL_31:
if ( ++v4 != v31 )
goto LABEL_25;
return a1;
} | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x30],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV R14,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
CMP R14,RBX
JZ 0x001020d7
MOV RAX,qword ptr [RBX + 0x8]
SUB RAX,qword ptr [RBX]
MOV qword ptr [RSP + 0x38],RAX
JZ 0x001020d7
XOR R13D,R13D
LAB_00101e50:
MOV qword ptr [RSP + 0x50],0x0
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
CMP R14,RBX
JZ 0x00102120
XOR EBP,EBP
XOR ECX,ECX
JMP 0x00101e96
LAB_00101e78:
MOVZX EAX,byte ptr [R12]
ADD RCX,0x1
ADD RBX,0x18
MOV byte ptr [RCX + -0x1],AL
MOV qword ptr [RSP + 0x48],RCX
CMP R14,RBX
JZ 0x00101f90
LAB_00101e96:
MOV R12,qword ptr [RBX]
ADD R12,R13
CMP RCX,RBP
JNZ 0x00101e78
MOV RAX,qword ptr [RSP + 0x40]
SUB RCX,RAX
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,0x7fffffffffffffff
MOV R15,RCX
CMP RCX,RAX
JZ 0x00102198
TEST RCX,RCX
JZ 0x00102050
MOV RAX,0x7fffffffffffffff
LEA RDX,[RCX + RCX*0x1]
CMP RDX,RAX
CMOVBE RAX,RDX
CMP RDX,RCX
MOV RDX,0x7fffffffffffffff
CMOVC RAX,RDX
LEA RDX,[RSP + 0x40]
MOV qword ptr [RSP + 0x20],RDX
MOV RDI,RAX
MOV qword ptr [RSP + 0x18],RAX
LAB_00101f05:
CALL 0x00101170
MOV R8,RAX
MOVZX EAX,byte ptr [R12]
MOV byte ptr [R8 + R15*0x1],AL
TEST R15,R15
JLE 0x00102078
MOV RSI,qword ptr [RSP + 0x8]
LEA RCX,[R8 + R15*0x1 + 0x1]
MOV RDI,R8
MOV RDX,R15
MOV qword ptr [RSP + 0x20],RCX
SUB RBP,RSI
CALL 0x001011b0
MOV RCX,qword ptr [RSP + 0x20]
MOV R8,RAX
LAB_00101f44:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RBP
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x20],R8
CALL 0x00101180
MOV RCX,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x20]
LAB_00101f65:
MOV RBP,qword ptr [RSP + 0x18]
ADD RBX,0x18
MOV qword ptr [RSP + 0x40],R8
MOV qword ptr [RSP + 0x48],RCX
ADD RBP,R8
MOV qword ptr [RSP + 0x50],RBP
CMP R14,RBX
JNZ 0x00101e96
NOP dword ptr [RAX]
LAB_00101f90:
MOV RAX,qword ptr [RSP + 0x10]
MOV RBX,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RAX + 0x10]
CMP RBX,RSI
JZ 0x001020a0
MOV R12,qword ptr [RSP + 0x40]
PXOR XMM0,XMM0
MOV qword ptr [RBX + 0x10],0x0
MOVUPS xmmword ptr [RBX],XMM0
SUB RCX,R12
MOV R14,RCX
JZ 0x00102100
JS 0x00102155
LEA RAX,[RSP + 0x40]
MOV RDI,RCX
MOV qword ptr [RSP + 0x20],RAX
CALL 0x00101170
MOVQ XMM0,RAX
LEA R15,[RAX + R14*0x1]
MOV RDI,RAX
PUNPCKLQDQ XMM0,XMM0
MOV qword ptr [RBX + 0x10],R15
MOVUPS xmmword ptr [RBX],XMM0
CMP R14,0x1
JZ 0x00102174
MOV RSI,R12
MOV RDX,R14
SUB RBP,R12
CALL 0x00101160
MOV RSI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RBX + 0x8],R15
ADD RAX,0x18
MOV qword ptr [RSI + 0x8],RAX
LAB_00102022:
MOV RSI,RBP
MOV RDI,R12
ADD R13,0x1
CALL 0x00101180
CMP qword ptr [RSP + 0x38],R13
JZ 0x001020d7
LAB_0010203c:
MOV RAX,qword ptr [RSP + 0x30]
MOV R14,qword ptr [RAX + 0x8]
MOV RBX,qword ptr [RAX]
JMP 0x00101e50
LAB_00102050:
LEA RAX,[RSP + 0x40]
MOV EDI,0x1
MOV qword ptr [RSP + 0x20],RAX
CALL 0x00101170
MOV qword ptr [RSP + 0x18],0x1
MOV R8,RAX
MOVZX EAX,byte ptr [R12]
MOV byte ptr [R8],AL
LAB_00102078:
CMP qword ptr [RSP + 0x8],0x0
LEA RCX,[R8 + R15*0x1 + 0x1]
JZ 0x00101f65
MOV RAX,qword ptr [RSP + 0x8]
SUB RBP,RAX
JMP 0x00101f44
LAB_001020a0:
MOV RDI,qword ptr [RSP + 0x10]
LEA RDX,[RSP + 0x40]
MOV qword ptr [RSP + 0x20],RDX
CALL 0x00102440
MOV R12,qword ptr [RSP + 0x40]
SUB RBP,R12
LAB_001020bc:
TEST R12,R12
JNZ 0x00102022
LAB_001020c5:
MOV RAX,qword ptr [RSP + 0x38]
ADD R13,0x1
CMP R13,RAX
JNZ 0x0010203c
LAB_001020d7:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001021be
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x68
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00102100:
MOV qword ptr [RBX + 0x10],0x0
ADD RBX,0x18
SUB RBP,R12
MOV qword ptr [RBX + -0x10],0x0
MOV qword ptr [RAX + 0x8],RBX
JMP 0x001020bc
LAB_00102120:
MOV RAX,qword ptr [RSP + 0x10]
XOR EBP,EBP
MOV RSI,qword ptr [RAX + 0x8]
CMP qword ptr [RAX + 0x10],RSI
JZ 0x001020a0
MOVUPS xmmword ptr [RSI],XMM0
ADD RSI,0x18
MOV qword ptr [RSI + -0x8],0x0
MOV qword ptr [RSI + -0x10],0x0
MOV qword ptr [RAX + 0x8],RSI
JMP 0x001020c5
LAB_00102155:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001021be
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x20],RAX
CALL 0x00101110
LAB_00102174:
MOVZX EAX,byte ptr [R12]
MOV RDX,qword ptr [RSP + 0x10]
SUB RBP,R12
MOV byte ptr [RDI],AL
MOV RAX,qword ptr [RDX + 0x8]
MOV qword ptr [RBX + 0x8],R15
ADD RAX,0x18
MOV qword ptr [RDX + 0x8],RAX
JMP 0x00102022
LAB_00102198:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001021be
LEA RAX,[RSP + 0x40]
LEA RDI,[0x103061]
MOV qword ptr [RSP + 0x20],RAX
CALL 0x00101140
LAB_001021be:
CALL 0x00101190 | /* func0(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char,
std::allocator<char> > > > const&) */
vector * func0(vector *param_1)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
vector *__dest;
vector *pvVar5;
vector *pvVar6;
ulong __n;
long *plVar7;
vector *pvVar8;
ulong uVar9;
long *in_RSI;
vector *pvVar10;
long lVar11;
long *plVar12;
vector *unaff_R15;
long in_FS_OFFSET;
vector *local_80;
int local_58 [40];
lVar1 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
plVar12 = (long *)in_RSI[1];
plVar7 = (long *)*in_RSI;
if ((plVar12 != plVar7) && (lVar2 = plVar7[1], lVar3 = *plVar7, lVar2 != lVar3)) {
lVar11 = 0;
pvVar5 = param_1;
do {
local_58._0_16_ = (int [16])0x0;
local_58._0_8_ = (vector *)0x0;
if (plVar12 == plVar7) {
pvVar8 = (vector *)0x0;
pvVar6 = *(vector **)(param_1 + 8);
if (*(vector **)(param_1 + 0x10) == pvVar6) goto LAB_001020a0;
*(int (*) [16])pvVar6 = (int [16])0x0;
*(int8 *)(pvVar6 + 0x10) = 0;
*(int8 *)(pvVar6 + 8) = 0;
*(vector **)(param_1 + 8) = pvVar6 + 0x18;
}
else {
pvVar8 = (vector *)0x0;
pvVar6 = (vector *)0x0;
do {
while( true ) {
pvVar10 = (vector *)(*plVar7 + lVar11);
if (pvVar6 == pvVar8) break;
local_58._8_8_ = pvVar6 + 1;
plVar7 = plVar7 + 3;
*pvVar6 = *pvVar10;
pvVar6 = (vector *)local_58._8_8_;
__dest = (vector *)local_58._0_8_;
if (plVar12 == plVar7) goto LAB_00101f90;
}
unaff_R15 = pvVar6 + -local_58._0_8_;
if (unaff_R15 == (vector *)0x7fffffffffffffff) {
if (lVar1 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("vector::_M_realloc_insert");
}
goto LAB_001021be;
}
if (unaff_R15 == (vector *)0x0) {
pvVar5 = (vector *)0x1;
__dest = (vector *)operator_new(1);
local_80 = (vector *)0x1;
*__dest = *pvVar10;
LAB_00102078:
local_58._8_8_ = __dest + 1 + (long)unaff_R15;
if ((vector *)local_58._0_8_ != (vector *)0x0) goto LAB_00101f44;
}
else {
pvVar5 = (vector *)((long)unaff_R15 * 2);
local_80 = (vector *)0x7fffffffffffffff;
if (pvVar5 < (vector *)0x8000000000000000) {
local_80 = pvVar5;
}
if (pvVar5 < unaff_R15) {
local_80 = (vector *)0x7fffffffffffffff;
}
pvVar5 = local_80;
/* try { // try from 00101f05 to 001021bd has its CatchHandler @ 001021c3 */
__dest = (vector *)operator_new((ulong)local_80);
__dest[(long)unaff_R15] = *pvVar10;
if ((long)unaff_R15 < 1) goto LAB_00102078;
local_58._8_8_ = __dest + 1 + (long)unaff_R15;
__dest = (vector *)memmove(__dest,(void *)local_58._0_8_,(size_t)unaff_R15);
LAB_00101f44:
operator_delete((void *)local_58._0_8_,(long)pvVar8 - local_58._0_8_);
pvVar5 = (vector *)local_58._0_8_;
}
plVar7 = plVar7 + 3;
local_58._0_8_ = __dest;
pvVar8 = local_80 + (long)__dest;
pvVar6 = (vector *)local_58._8_8_;
} while (plVar12 != plVar7);
LAB_00101f90:
local_58._0_8_ = __dest;
pvVar10 = *(vector **)(param_1 + 8);
pvVar6 = *(vector **)(param_1 + 0x10);
if (pvVar10 == pvVar6) {
LAB_001020a0:
pvVar5 = param_1;
std::
vector<std::vector<char,std::allocator<char>>,std::allocator<std::vector<char,std::allocator<char>>>>
::_M_realloc_insert<std::vector<char,std::allocator<char>>const&>
((__normal_iterator)param_1,pvVar6);
uVar9 = (long)pvVar8 - local_58._0_8_;
LAB_001020bc:
if ((vector *)local_58._0_8_ == (vector *)0x0) goto joined_r0x001020d1;
}
else {
*(int8 *)(pvVar10 + 0x10) = 0;
*(int (*) [16])pvVar10 = (int [16])0x0;
__n = local_58._8_8_ - local_58._0_8_;
if (__n == 0) {
*(int8 *)(pvVar10 + 0x10) = 0;
uVar9 = (long)pvVar8 - local_58._0_8_;
*(int8 *)(pvVar10 + 8) = 0;
*(vector **)(param_1 + 8) = pvVar10 + 0x18;
goto LAB_001020bc;
}
if ((long)__n < 0) {
if (lVar1 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_001021be;
std::__throw_bad_alloc();
LAB_00102174:
uVar9 = (long)pvVar8 - local_58._0_8_;
*pvVar5 = *(vector *)local_58._0_8_;
lVar4 = *(long *)(param_1 + 8);
*(vector **)(pvVar10 + 8) = unaff_R15;
*(long *)(param_1 + 8) = lVar4 + 0x18;
}
else {
pvVar5 = (vector *)operator_new(__n);
unaff_R15 = pvVar5 + __n;
*(vector **)(pvVar10 + 0x10) = unaff_R15;
*(vector **)pvVar10 = pvVar5;
*(vector **)(pvVar10 + 8) = pvVar5;
if (__n == 1) goto LAB_00102174;
uVar9 = (long)pvVar8 - local_58._0_8_;
memcpy(pvVar5,(void *)local_58._0_8_,__n);
lVar4 = *(long *)(param_1 + 8);
*(vector **)(pvVar10 + 8) = unaff_R15;
*(long *)(param_1 + 8) = lVar4 + 0x18;
}
}
operator_delete((void *)local_58._0_8_,uVar9);
pvVar5 = (vector *)local_58._0_8_;
}
joined_r0x001020d1:
if (lVar11 + 1 == lVar2 - lVar3) break;
lVar11 = lVar11 + 1;
plVar12 = (long *)in_RSI[1];
plVar7 = (long *)*in_RSI;
} while( true );
}
if (lVar1 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
LAB_001021be:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,448 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
| vector<pair<string, int>> func0(const vector<pair<string, vector<int>>>& test_list) {
vector<pair<string, int>> res;
for (const auto &p : test_list) {
int max_val = *max_element(p.second.begin(), p.second.end());
res.push_back({p.first, max_val});
}
return res;
}
| int main() {
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {3, 4, 5}},
{"key2", {1, 4, 2}},
{"key3", {9, 3}}
};
vector<pair<string, int>> expected = {
{"key1", 5},
{"key2", 4},
{"key3", 9}
};
assert(func0(test_list) == expected);
}
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {4, 5, 6}},
{"key2", {2, 5, 3}},
{"key3", {10, 4}}
};
vector<pair<string, int>> expected = {
{"key1", 6},
{"key2", 5},
{"key3", 10}
};
assert(func0(test_list) == expected);
}
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {5, 6, 7}},
{"key2", {3, 6, 4}},
{"key3", {11, 5}}
};
vector<pair<string, int>> expected = {
{"key1", 7},
{"key2", 6},
{"key3", 11}
};
assert(func0(test_list) == expected);
}
return 0;
}
| O0 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %rsi,-0x80(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq 39b0 <_ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EEC1Ev>
mov -0x80(%rbp),%rax
mov %rax,-0x50(%rbp)
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 3cc0 <_ZNKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE5beginEv>
mov %rax,-0x68(%rbp)
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 3d18 <_ZNKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE3endEv>
mov %rax,-0x60(%rbp)
lea -0x60(%rbp),%rdx
lea -0x68(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 3d70 <_ZN9__gnu_cxxneIPKSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIiSaIiEEES8_ISB_SaISB_EEEEbRKNS_17__normal_iteratorIT_T0_EESL_>
test %al,%al
je 262c <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x143>
lea -0x68(%rbp),%rax
mov %rax,%rdi
callq 3dd4 <_ZNK9__gnu_cxx17__normal_iteratorIPKSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIiSaIiEEES8_ISB_SaISB_EEEdeEv>
mov %rax,-0x48(%rbp)
mov -0x48(%rbp),%rax
add $0x20,%rax
mov %rax,%rdi
callq 3e42 <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x48(%rbp),%rax
add $0x20,%rax
mov %rax,%rdi
callq 3dea <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rbx,%rsi
mov %rax,%rdi
callq 3e9a <_ZSt11max_elementIN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEEET_S8_S8_>
mov %rax,-0x58(%rbp)
lea -0x58(%rbp),%rax
mov %rax,%rdi
callq 3ec8 <_ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%eax
mov %eax,-0x6c(%rbp)
mov -0x48(%rbp),%rcx
lea -0x6c(%rbp),%rdx
lea -0x40(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 3ede <_ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEC1IRiLb1EEERKS5_OT_>
lea -0x40(%rbp),%rdx
mov -0x78(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 3f22 <_ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EE9push_backEOS7_>
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 39d0 <_ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiED1Ev>
lea -0x68(%rbp),%rax
mov %rax,%rdi
callq 3db0 <_ZN9__gnu_cxx17__normal_iteratorIPKSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIiSaIiEEES8_ISB_SaISB_EEEppEv>
jmpq 2541 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x58>
endbr64
mov %rax,%rbx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 39d0 <_ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiED1Ev>
mov %rbx,%rax
jmp 2612 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x129>
endbr64
mov %rax,%rbx
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq 3c78 <_ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 23c0 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 2641 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x158>
callq 2360 <__stack_chk_fail@plt>
mov -0x78(%rbp),%rax
add $0x78,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_78]
mov rdi, rax
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EEC2Ev; std::vector<std::pair<std::string,int>>::vector(void)
mov rax, [rbp+var_80]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov rdi, rax
call _ZNKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE5beginEv; std::vector<std::pair<std::string,std::vector<int>>>::begin(void)
mov [rbp+var_68], rax
mov rax, [rbp+var_50]
mov rdi, rax
call _ZNKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE3endEv; std::vector<std::pair<std::string,std::vector<int>>>::end(void)
mov [rbp+var_60], rax
jmp loc_25BB
loc_2526:
lea rax, [rbp+var_68]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIiSaIiEEES8_ISB_SaISB_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<std::string,std::vector<int>> const*,std::vector<std::pair<std::string,std::vector<int>>>>::operator*(void)
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
add rax, 20h ; ' '
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [rbp+var_48]
add rax, 20h ; ' '
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov rsi, rbx
mov rdi, rax
call _ZSt11max_elementIN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEEET_S8_S8_; std::max_element<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>)
mov [rbp+var_58], rax
lea rax, [rbp+var_58]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEdeEv; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator*(void)
mov eax, [rax]
mov [rbp+var_6C], eax
mov rcx, [rbp+var_48]
lea rdx, [rbp+var_6C]
lea rax, [rbp+var_40]
mov rsi, rcx
mov rdi, rax
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEC2IRKS5_RiLb1EEEOT_OT0_; std::pair<std::string,int>::pair<std::string const&,int &,true>(std::string const&,int &)
lea rdx, [rbp+var_40]
mov rax, [rbp+var_78]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EE9push_backEOS7_; std::vector<std::pair<std::string,int>>::push_back(std::pair<std::string,int>&&)
lea rax, [rbp+var_40]
mov rdi, rax
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiED2Ev; std::pair<std::string,int>::~pair()
lea rax, [rbp+var_68]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIiSaIiEEES8_ISB_SaISB_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string,std::vector<int>> const*,std::vector<std::pair<std::string,std::vector<int>>>>::operator++(void)
loc_25BB:
lea rdx, [rbp+var_60]
lea rax, [rbp+var_68]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPKSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIiSaIiEEES8_ISB_SaISB_EEEEbRKNS_17__normal_iteratorIT_T0_EESL_; __gnu_cxx::operator!=<std::pair<std::string,std::vector<int>> const*,std::vector<std::pair<std::string,std::vector<int>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string,std::vector<int>> const*,std::vector<std::pair<std::string,std::vector<int>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string,std::vector<int>> const*,std::vector<std::pair<std::string,std::vector<int>>>> const&)
test al, al
jnz loc_2526
jmp short loc_261F
endbr64
mov rbx, rax
lea rax, [rbp+var_40]
mov rdi, rax
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiED2Ev; std::pair<std::string,int>::~pair()
jmp short loc_25F4
endbr64
mov rbx, rax
loc_25F4:
mov rax, [rbp+var_78]
mov rdi, rax
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EED2Ev; std::vector<std::pair<std::string,int>>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_2617
call ___stack_chk_fail
loc_2617:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_261F:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_2633
call ___stack_chk_fail
loc_2633:
mov rax, [rbp+var_78]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
int v5; // [rsp+14h] [rbp-6Ch] BYREF
long long v6; // [rsp+18h] [rbp-68h] BYREF
long long v7; // [rsp+20h] [rbp-60h] BYREF
_QWORD v8[2]; // [rsp+28h] [rbp-58h] BYREF
long long v9; // [rsp+38h] [rbp-48h]
_BYTE v10[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v11; // [rsp+68h] [rbp-18h]
v11 = __readfsqword(0x28u);
std::vector<std::pair<std::string,int>>::vector(a1);
v8[1] = a2;
v6 = std::vector<std::pair<std::string,std::vector<int>>>::begin(a2);
v7 = std::vector<std::pair<std::string,std::vector<int>>>::end(a2);
while ( (unsigned __int8)__gnu_cxx::operator!=<std::pair<std::string,std::vector<int>> const*,std::vector<std::pair<std::string,std::vector<int>>>>(
&v6,
&v7) )
{
v9 = __gnu_cxx::__normal_iterator<std::pair<std::string,std::vector<int>> const*,std::vector<std::pair<std::string,std::vector<int>>>>::operator*(&v6);
v2 = std::vector<int>::end(v9 + 32);
v3 = std::vector<int>::begin(v9 + 32);
v8[0] = std::max_element<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(v3, v2);
v5 = *(_DWORD *)__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator*(v8);
std::pair<std::string,int>::pair<std::string const&,int &,true>(v10, v9, &v5);
std::vector<std::pair<std::string,int>>::push_back(a1, v10);
std::pair<std::string,int>::~pair(v10);
__gnu_cxx::__normal_iterator<std::pair<std::string,std::vector<int>> const*,std::vector<std::pair<std::string,std::vector<int>>>>::operator++(&v6);
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDI,RAX
CALL 0x00103d42
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00103ffa
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00104046
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001025bb
LAB_00102526:
LEA RAX,[RBP + -0x68]
MOV RDI,RAX
CALL 0x001040fa
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x20
MOV RDI,RAX
CALL 0x0010415c
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x20
MOV RDI,RAX
CALL 0x00104110
MOV RSI,RBX
MOV RDI,RAX
LAB_0010255f:
CALL 0x001041ac
MOV qword ptr [RBP + -0x58],RAX
LEA RAX,[RBP + -0x58]
MOV RDI,RAX
CALL 0x001041da
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x6c],EAX
MOV RCX,qword ptr [RBP + -0x48]
LEA RDX,[RBP + -0x6c]
LEA RAX,[RBP + -0x40]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001041f0
LEA RDX,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x78]
MOV RSI,RDX
MOV RDI,RAX
LAB_0010259e:
CALL 0x00104240
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00103d62
LEA RAX,[RBP + -0x68]
MOV RDI,RAX
CALL 0x001040d6
LAB_001025bb:
LEA RDX,[RBP + -0x60]
LEA RAX,[RBP + -0x68]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00104096
TEST AL,AL
JNZ 0x00102526
JMP 0x0010261f
LAB_0010261f:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00102633
CALL 0x00102350
LAB_00102633:
MOV RAX,qword ptr [RBP + -0x78]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<std::pair<std::string, std::vector<int, std::allocator<int> > >,
std::allocator<std::pair<std::string, std::vector<int, std::allocator<int> > > > > const&) */
vector * func0(vector *param_1)
{
bool bVar1;
int8 uVar2;
int8 uVar3;
int *piVar4;
vector<std::pair<std::string,std::vector<int,std::allocator<int>>>,std::allocator<std::pair<std::string,std::vector<int,std::allocator<int>>>>>
*in_RSI;
long in_FS_OFFSET;
int local_74;
int8 local_70;
int8 local_68;
int8 local_60;
vector<std::pair<std::string,std::vector<int,std::allocator<int>>>,std::allocator<std::pair<std::string,std::vector<int,std::allocator<int>>>>>
*local_58;
string *local_50;
pair<std::string,int> local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>>::vector
((vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>> *)
param_1);
local_58 = in_RSI;
local_70 = std::
vector<std::pair<std::string,std::vector<int,std::allocator<int>>>,std::allocator<std::pair<std::string,std::vector<int,std::allocator<int>>>>>
::begin(in_RSI);
local_68 = std::
vector<std::pair<std::string,std::vector<int,std::allocator<int>>>,std::allocator<std::pair<std::string,std::vector<int,std::allocator<int>>>>>
::end(local_58);
while( true ) {
bVar1 = operator!=((__normal_iterator *)&local_70,(__normal_iterator *)&local_68);
if (!bVar1) break;
local_50 = (string *)
__normal_iterator<std::pair<std::string,std::vector<int,std::allocator<int>>>const*,std::vector<std::pair<std::string,std::vector<int,std::allocator<int>>>,std::allocator<std::pair<std::string,std::vector<int,std::allocator<int>>>>>>
::operator*((__normal_iterator<std::pair<std::string,std::vector<int,std::allocator<int>>>const*,std::vector<std::pair<std::string,std::vector<int,std::allocator<int>>>,std::allocator<std::pair<std::string,std::vector<int,std::allocator<int>>>>>>
*)&local_70);
uVar2 = std::vector<int,std::allocator<int>>::end
((vector<int,std::allocator<int>> *)(local_50 + 0x20));
uVar3 = std::vector<int,std::allocator<int>>::begin
((vector<int,std::allocator<int>> *)(local_50 + 0x20));
/* try { // try from 0010255f to 0010258f has its CatchHandler @ 001025ed */
local_60 = std::max_element<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>>
(uVar3,uVar2);
piVar4 = (int *)__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *
)&local_60);
local_74 = *piVar4;
std::pair<std::string,int>::pair<std::string_const&,int&,true>(local_48,local_50,&local_74);
/* try { // try from 0010259e to 001025a2 has its CatchHandler @ 001025d8 */
std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>>::push_back
((vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>> *)
param_1,(pair *)local_48);
std::pair<std::string,int>::~pair(local_48);
__normal_iterator<std::pair<std::string,std::vector<int,std::allocator<int>>>const*,std::vector<std::pair<std::string,std::vector<int,std::allocator<int>>>,std::allocator<std::pair<std::string,std::vector<int,std::allocator<int>>>>>>
::operator++((__normal_iterator<std::pair<std::string,std::vector<int,std::allocator<int>>>const*,std::vector<std::pair<std::string,std::vector<int,std::allocator<int>>>,std::allocator<std::pair<std::string,std::vector<int,std::allocator<int>>>>>>
*)&local_70);
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,449 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
| vector<pair<string, int>> func0(const vector<pair<string, vector<int>>>& test_list) {
vector<pair<string, int>> res;
for (const auto &p : test_list) {
int max_val = *max_element(p.second.begin(), p.second.end());
res.push_back({p.first, max_val});
}
return res;
}
| int main() {
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {3, 4, 5}},
{"key2", {1, 4, 2}},
{"key3", {9, 3}}
};
vector<pair<string, int>> expected = {
{"key1", 5},
{"key2", 4},
{"key3", 9}
};
assert(func0(test_list) == expected);
}
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {4, 5, 6}},
{"key2", {2, 5, 3}},
{"key3", {10, 4}}
};
vector<pair<string, int>> expected = {
{"key1", 6},
{"key2", 5},
{"key3", 10}
};
assert(func0(test_list) == expected);
}
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {5, 6, 7}},
{"key2", {3, 6, 4}},
{"key3", {11, 5}}
};
vector<pair<string, int>> expected = {
{"key1", 7},
{"key2", 6},
{"key3", 11}
};
assert(func0(test_list) == expected);
}
return 0;
}
| O1 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > > > > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbx
mov 0x8(%rsi),%r13
cmp %r13,%rbx
je 1465 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x15c>
mov %rsp,%r12
jmp 13b6 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xad>
mov %rcx,%rdx
jmpq 13e0 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xd7>
mov %r14d,0x20(%rsp)
mov 0x8(%rbp),%rsi
cmp 0x10(%rbp),%rsi
je 140f <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x106>
lea 0x10(%rsi),%rax
mov %rax,(%rsi)
mov (%rsp),%rax
lea 0x10(%rsp),%rdx
cmp %rdx,%rax
je 1403 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xfa>
mov %rax,(%rsi)
mov 0x10(%rsp),%rax
mov %rax,0x10(%rsi)
mov 0x8(%rsp),%rax
mov %rax,0x8(%rsi)
mov 0x20(%rsp),%eax
mov %eax,0x20(%rsi)
addq $0x28,0x8(%rbp)
add $0x38,%rbx
cmp %rbx,%r13
je 1465 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x15c>
mov %rbx,%rdi
mov 0x28(%rbx),%rcx
mov 0x20(%rbx),%rdx
cmp %rcx,%rdx
je 1358 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x4f>
lea 0x4(%rdx),%rax
cmp %rax,%rcx
je 13e0 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xd7>
mov (%rax),%esi
cmp %esi,(%rdx)
cmovl %rax,%rdx
add $0x4,%rax
cmp %rax,%rcx
jne 13cf <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xc6>
mov (%rdx),%r14d
lea 0x10(%rsp),%rax
mov %rax,(%rsp)
mov (%rdi),%rsi
mov %rsi,%rdx
add 0x8(%rdi),%rdx
mov %r12,%rdi
callq 2608 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag>
jmpq 1360 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x57>
movdqa 0x10(%rsp),%xmm0
movups %xmm0,0x10(%rsi)
jmp 1394 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x8b>
mov %r12,%rdx
mov %rbp,%rdi
callq 2178 <_ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EE17_M_realloc_insertIJS7_EEEvN9__gnu_cxx17__normal_iteratorIPS7_S9_EEDpOT_>
mov (%rsp),%rdi
lea 0x10(%rsp),%rax
cmp %rax,%rdi
je 13a9 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xa0>
callq 11a0 <_ZdlPv@plt>
jmpq 13a9 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xa0>
endbr64
mov %rax,%rbx
mov (%rsp),%rdi
lea 0x10(%rsp),%rax
cmp %rax,%rdi
je 144c <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x143>
callq 11a0 <_ZdlPv@plt>
mov %rbp,%rdi
callq 1f9a <_ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EED1Ev>
mov %rbx,%rdi
callq 1200 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbx
jmp 144c <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x143>
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 1485 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x17c>
mov %rbp,%rax
add $0x30,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 11c0 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 30h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rbx, [rsi]
mov r13, [rsi+8]
cmp r13, rbx
jz loc_1546
mov r12, rsp
jmp loc_14B8
loc_139B:
mov rdx, rcx
jmp loc_14E6
loc_13A3:
mov [rsp+58h+var_38], r14d
mov rsi, [rbp+8]
cmp rsi, [rbp+10h]
jz loc_1484
lea rdx, [rsi+10h]
mov [rsi], rdx
mov rax, [rsp+58h+var_58]
lea rcx, [rsp+58h+var_48]
cmp rax, rcx
jz short loc_13F1
mov [rsi], rax
mov rax, [rsp+58h+var_48]
mov [rsi+10h], rax
loc_13D7:
mov rax, [rsp+58h+var_50]
mov [rsi+8], rax
mov eax, [rsp+58h+var_38]
mov [rsi+20h], eax
add qword ptr [rbp+8], 28h ; '('
jmp loc_14AB
loc_13F1:
mov rax, [rsp+58h+var_50]
add rax, 1
cmp eax, 8
jnb short loc_1435
test al, 4
jnz short loc_1422
test eax, eax
jz short loc_13D7
movzx edi, byte ptr [rsp+58h+var_48]
mov [rsi+10h], dil
test al, 2
jz short loc_13D7
mov eax, eax
movzx ecx, word ptr [rcx+rax-2]
mov [rdx+rax-2], cx
jmp short loc_13D7
loc_1422:
mov edi, dword ptr [rsp+58h+var_48]
mov [rsi+10h], edi
mov eax, eax
mov ecx, [rcx+rax-4]
mov [rdx+rax-4], ecx
jmp short loc_13D7
loc_1435:
mov rdi, [rsp+58h+var_48]
mov [rsi+10h], rdi
mov edi, eax
mov r8, [rcx+rdi-8]
mov [rdx+rdi-8], r8
lea r9, [rdx+8]
and r9, 0FFFFFFFFFFFFFFF8h
sub rdx, r9
sub rcx, rdx
add eax, edx
and eax, 0FFFFFFF8h
cmp eax, 8
jb loc_13D7
and eax, 0FFFFFFF8h
mov edx, 0
loc_146E:
mov edi, edx
mov r8, [rcx+rdi]
mov [r9+rdi], r8
add edx, 8
cmp edx, eax
jb short loc_146E
jmp loc_13D7
loc_1484:
mov rdx, r12
mov rdi, rbp
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EE17_M_realloc_insertIJS7_EEEvN9__gnu_cxx17__normal_iteratorIPS7_S9_EEDpOT_; std::vector<std::pair<std::string,int>>::_M_realloc_insert<std::pair<std::string,int>>(__gnu_cxx::__normal_iterator<std::pair<std::string,int>*,std::vector<std::pair<std::string,int>>>,std::pair<std::string,int> &&)
mov rdi, [rsp+58h+var_58]; void *
lea rax, [rsp+58h+var_48]
cmp rdi, rax
jz short loc_14AB
mov rax, [rsp+58h+var_48]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_14AB:
add rbx, 38h ; '8'
cmp r13, rbx
jz loc_1546
loc_14B8:
mov rdi, rbx
mov rcx, [rbx+28h]
mov rdx, [rbx+20h]
cmp rdx, rcx
jz loc_139B
lea rax, [rdx+4]
cmp rcx, rax
jz short loc_14E6
loc_14D5:
mov esi, [rax]
cmp [rdx], esi
cmovl rdx, rax
add rax, 4
cmp rax, rcx
jnz short loc_14D5
loc_14E6:
mov r14d, [rdx]
lea rax, [rsp+58h+var_48]
mov [rsp+58h+var_58], rax
mov rsi, [rdi]
mov rdx, rsi
add rdx, [rdi+8]
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
jmp loc_13A3
endbr64
mov rbx, rax
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
loc_1518:
mov rdi, rbp
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EED2Ev; std::vector<std::pair<std::string,int>>::~vector()
mov rax, [rsp+arg_20]
sub rax, fs:28h
jz short loc_153E
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp short loc_1518
loc_153E:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1546:
mov rax, [rsp+58h+var_30]
sub rax, fs:28h
jnz short loc_1566
mov rax, rbp
add rsp, 30h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1566:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r13
int *v4; // rdx
long long v5; // rsi
long long v6; // rdx
unsigned int v7; // eax
unsigned long long v8; // r9
long long v9; // rdx
char *v10; // rcx
unsigned int v11; // eax
unsigned int v12; // eax
unsigned int v13; // edx
int *v14; // rcx
int *i; // rax
int v16; // r14d
void *v18; // [rsp+0h] [rbp-58h] BYREF
long long v19; // [rsp+8h] [rbp-50h]
_QWORD v20[2]; // [rsp+10h] [rbp-48h] BYREF
int v21; // [rsp+20h] [rbp-38h]
unsigned long long v22; // [rsp+28h] [rbp-30h]
v22 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v2 = (_QWORD *)*a2;
v3 = (_QWORD *)a2[1];
if ( v3 != (_QWORD *)*a2 )
{
do
{
v14 = (int *)v2[5];
v4 = (int *)v2[4];
if ( v4 == v14 )
{
v4 = (int *)v2[5];
}
else
{
for ( i = v4 + 1; i != v14; ++i )
{
if ( *v4 < *i )
v4 = i;
}
}
v16 = *v4;
v18 = v20;
std::string::_M_construct<char *>(&v18, *v2, v2[1] + *v2);
v21 = v16;
v5 = a1[1];
if ( v5 == a1[2] )
{
std::vector<std::pair<std::string,int>>::_M_realloc_insert<std::pair<std::string,int>>(a1, v5, &v18);
if ( v18 != v20 )
operator delete(v18, v20[0] + 1LL);
}
else
{
v6 = v5 + 16;
*(_QWORD *)v5 = v5 + 16;
if ( v18 == v20 )
{
v7 = v19 + 1;
if ( (unsigned int)(v19 + 1) >= 8 )
{
*(_QWORD *)(v5 + 16) = v20[0];
*(_QWORD *)(v6 + v7 - 8) = *(_QWORD *)((char *)&v20[-1] + v7);
v8 = (v5 + 24) & 0xFFFFFFFFFFFFFFF8LL;
v9 = v6 - v8;
v10 = (char *)v20 - v9;
v11 = (v9 + v7) & 0xFFFFFFF8;
if ( v11 >= 8 )
{
v12 = v11 & 0xFFFFFFF8;
v13 = 0;
do
{
*(_QWORD *)(v8 + v13) = *(_QWORD *)&v10[v13];
v13 += 8;
}
while ( v13 < v12 );
}
}
else if ( (v7 & 4) != 0 )
{
*(_DWORD *)(v5 + 16) = v20[0];
*(_DWORD *)(v6 + v7 - 4) = *(_DWORD *)((char *)&v19 + v7 + 4);
}
else if ( (_DWORD)v19 != -1 )
{
*(_BYTE *)(v5 + 16) = v20[0];
if ( (v7 & 2) != 0 )
*(_WORD *)(v6 + v7 - 2) = *(_WORD *)((char *)&v19 + v7 + 6);
}
}
else
{
*(_QWORD *)v5 = v18;
*(_QWORD *)(v5 + 16) = v20[0];
}
*(_QWORD *)(v5 + 8) = v19;
*(_DWORD *)(v5 + 32) = v21;
a1[1] += 40LL;
}
v2 += 7;
}
while ( v3 != v2 );
}
return a1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],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 R13,qword ptr [RSI + 0x8]
CMP R13,RBX
JZ 0x00101546
MOV R12,RSP
JMP 0x001014b8
LAB_0010139b:
MOV RDX,RCX
JMP 0x001014e6
LAB_001013a3:
MOV dword ptr [RSP + 0x20],R14D
MOV RSI,qword ptr [RBP + 0x8]
CMP RSI,qword ptr [RBP + 0x10]
JZ 0x00101484
LEA RDX,[RSI + 0x10]
MOV qword ptr [RSI],RDX
MOV RAX,qword ptr [RSP]
LEA RCX,[RSP + 0x10]
CMP RAX,RCX
JZ 0x001013f1
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSI + 0x10],RAX
LAB_001013d7:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSI + 0x8],RAX
MOV EAX,dword ptr [RSP + 0x20]
MOV dword ptr [RSI + 0x20],EAX
ADD qword ptr [RBP + 0x8],0x28
JMP 0x001014ab
LAB_001013f1:
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x1
CMP EAX,0x8
JNC 0x00101435
TEST AL,0x4
JNZ 0x00101422
TEST EAX,EAX
JZ 0x001013d7
MOVZX EDI,byte ptr [RSP + 0x10]
MOV byte ptr [RSI + 0x10],DIL
TEST AL,0x2
JZ 0x001013d7
MOV EAX,EAX
MOVZX ECX,word ptr [RCX + RAX*0x1 + -0x2]
MOV word ptr [RDX + RAX*0x1 + -0x2],CX
JMP 0x001013d7
LAB_00101422:
MOV EDI,dword ptr [RSP + 0x10]
MOV dword ptr [RSI + 0x10],EDI
MOV EAX,EAX
MOV ECX,dword ptr [RCX + RAX*0x1 + -0x4]
MOV dword ptr [RDX + RAX*0x1 + -0x4],ECX
JMP 0x001013d7
LAB_00101435:
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSI + 0x10],RDI
MOV EDI,EAX
MOV R8,qword ptr [RCX + RDI*0x1 + -0x8]
MOV qword ptr [RDX + RDI*0x1 + -0x8],R8
LEA R9,[RDX + 0x8]
AND R9,-0x8
SUB RDX,R9
SUB RCX,RDX
ADD EAX,EDX
AND EAX,0xfffffff8
CMP EAX,0x8
JC 0x001013d7
AND EAX,0xfffffff8
MOV EDX,0x0
LAB_0010146e:
MOV EDI,EDX
MOV R8,qword ptr [RCX + RDI*0x1]
MOV qword ptr [R9 + RDI*0x1],R8
ADD EDX,0x8
CMP EDX,EAX
JC 0x0010146e
JMP 0x001013d7
LAB_00101484:
MOV RDX,R12
MOV RDI,RBP
LAB_0010148a:
CALL 0x00102b7a
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x001014ab
MOV RAX,qword ptr [RSP + 0x10]
LEA RSI,[RAX + 0x1]
CALL 0x001011e0
LAB_001014ab:
ADD RBX,0x38
CMP R13,RBX
JZ 0x00101546
LAB_001014b8:
MOV RDI,RBX
MOV RCX,qword ptr [RBX + 0x28]
MOV RDX,qword ptr [RBX + 0x20]
CMP RDX,RCX
JZ 0x0010139b
LEA RAX,[RDX + 0x4]
CMP RCX,RAX
JZ 0x001014e6
LAB_001014d5:
MOV ESI,dword ptr [RAX]
CMP dword ptr [RDX],ESI
CMOVL RDX,RAX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001014d5
LAB_001014e6:
MOV R14D,dword ptr [RDX]
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV RSI,qword ptr [RDI]
MOV RDX,RSI
ADD RDX,qword ptr [RDI + 0x8]
MOV RDI,R12
LAB_001014ff:
CALL 0x001028d8
JMP 0x001013a3
LAB_00101546:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101566
MOV RAX,RBP
ADD RSP,0x30
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101566:
CALL 0x001011f0 | /* func0(std::vector<std::pair<std::string, std::vector<int, std::allocator<int> > >,
std::allocator<std::pair<std::string, std::vector<int, std::allocator<int> > > > > const&) */
vector * func0(vector *param_1)
{
int iVar1;
int8 *puVar2;
long *plVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar7;
ulong uVar8;
uint uVar9;
long lVar10;
int *piVar11;
int8 *puVar12;
int8 *in_RSI;
long in_FS_OFFSET;
int8 *local_58;
int8 local_50;
int8 local_48;
int local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
puVar2 = (int8 *)in_RSI[1];
for (puVar12 = (int8 *)*in_RSI; puVar2 != puVar12; puVar12 = puVar12 + 7) {
piVar4 = (int *)puVar12[5];
piVar5 = (int *)puVar12[4];
piVar11 = piVar4;
piVar6 = piVar5;
if (piVar5 != piVar4) {
while (piVar5 = piVar5 + 1, piVar11 = piVar6, piVar4 != piVar5) {
if (*piVar6 < *piVar5) {
piVar6 = piVar5;
}
}
}
iVar1 = *piVar11;
local_58 = &local_48;
/* try { // try from 001014ff to 00101503 has its CatchHandler @ 00101535 */
std::string::_M_construct<char*>
((char *)&local_58,(char *)*puVar12,(int)(char *)*puVar12 + (int)puVar12[1]);
local_38 = iVar1;
plVar3 = *(long **)(param_1 + 8);
if (plVar3 == *(long **)(param_1 + 0x10)) {
/* try { // try from 0010148a to 0010148e has its CatchHandler @ 00101509 */
std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>>::
_M_realloc_insert<std::pair<std::string,int>>
((vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>> *)
param_1,(__normal_iterator)plVar3,(pair *)&local_58);
if (local_58 != &local_48) {
operator_delete(local_58,CONCAT44(local_48._4_4_,(int4)local_48) + 1);
}
}
else {
*plVar3 = (long)(plVar3 + 2);
if (local_58 == &local_48) {
uVar8 = local_50 + 1;
uVar7 = (uint)uVar8;
if (uVar7 < 8) {
if ((uVar8 & 4) == 0) {
if (uVar7 != 0) {
*(int *)(plVar3 + 2) = (int)local_48;
if ((uVar8 & 2) != 0) {
*(int2 *)((long)plVar3 + (uVar8 & 0xffffffff) + 0xe) =
*(int2 *)((long)&local_50 + (uVar8 & 0xffffffff) + 6);
}
}
}
else {
*(int4 *)(plVar3 + 2) = (int4)local_48;
*(int4 *)((long)plVar3 + (uVar8 & 0xffffffff) + 0xc) =
*(int4 *)((long)&local_50 + (uVar8 & 0xffffffff) + 4);
}
}
else {
plVar3[2] = CONCAT44(local_48._4_4_,(int4)local_48);
*(int8 *)((long)plVar3 + (uVar8 & 0xffffffff) + 8) =
*(int8 *)((long)&local_50 + (uVar8 & 0xffffffff));
lVar10 = (long)(plVar3 + 2) - ((ulong)(plVar3 + 3) & 0xfffffffffffffff8);
uVar7 = uVar7 + (int)lVar10 & 0xfffffff8;
if (7 < uVar7) {
uVar9 = 0;
do {
*(int8 *)(((ulong)(plVar3 + 3) & 0xfffffffffffffff8) + (ulong)uVar9) =
*(int8 *)((long)&local_48 + ((ulong)uVar9 - lVar10));
uVar9 = uVar9 + 8;
} while (uVar9 < uVar7);
}
}
}
else {
*plVar3 = (long)local_58;
plVar3[2] = CONCAT44(local_48._4_4_,(int4)local_48);
}
plVar3[1] = local_50;
*(int *)(plVar3 + 4) = iVar1;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x28;
}
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,450 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
| vector<pair<string, int>> func0(const vector<pair<string, vector<int>>>& test_list) {
vector<pair<string, int>> res;
for (const auto &p : test_list) {
int max_val = *max_element(p.second.begin(), p.second.end());
res.push_back({p.first, max_val});
}
return res;
}
| int main() {
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {3, 4, 5}},
{"key2", {1, 4, 2}},
{"key3", {9, 3}}
};
vector<pair<string, int>> expected = {
{"key1", 5},
{"key2", 4},
{"key3", 9}
};
assert(func0(test_list) == expected);
}
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {4, 5, 6}},
{"key2", {2, 5, 3}},
{"key3", {10, 4}}
};
vector<pair<string, int>> expected = {
{"key1", 6},
{"key2", 5},
{"key3", 10}
};
assert(func0(test_list) == expected);
}
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {5, 6, 7}},
{"key2", {3, 6, 4}},
{"key3", {11, 5}}
};
vector<pair<string, int>> expected = {
{"key1", 7},
{"key2", 6},
{"key3", 11}
};
assert(func0(test_list) == expected);
}
return 0;
}
| O2 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x38,%rsp
mov 0x8(%rsi),%r15
mov (%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
cmp %r15,%rbp
je 1e36 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xe6>
mov %rsp,%r14
lea 0x10(%rsp),%r13
nopl 0x0(%rax)
mov 0x20(%rbp),%rax
mov 0x28(%rbp),%rcx
mov (%rax),%ebx
cmp %rax,%rcx
jne 1dc7 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x77>
jmp 1dd0 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x80>
nopl 0x0(%rax)
mov (%rax),%edx
cmp %edx,%ebx
cmovl %edx,%ebx
add $0x4,%rax
cmp %rax,%rcx
jne 1dc0 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x70>
mov %r13,(%rsp)
mov 0x8(%rbp),%rdx
mov %r14,%rdi
mov 0x0(%rbp),%rsi
add %rsi,%rdx
callq 25c0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag>
mov %ebx,0x20(%rsp)
mov 0x8(%r12),%rsi
cmp 0x10(%r12),%rsi
je 1e70 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x120>
lea 0x10(%rsi),%rax
mov %rax,(%rsi)
mov (%rsp),%rax
cmp %r13,%rax
je 1e60 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x110>
mov %rax,(%rsi)
mov 0x10(%rsp),%rax
mov %rax,0x10(%rsi)
mov 0x8(%rsp),%rax
mov %rax,0x8(%rsi)
mov 0x20(%rsp),%eax
mov %eax,0x20(%rsi)
addq $0x28,0x8(%r12)
add $0x38,%rbp
cmp %rbp,%r15
jne 1da8 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x58>
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 1e8b <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x13b>
add $0x38,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
movdqa 0x10(%rsp),%xmm0
movups %xmm0,0x10(%rsi)
jmp 1e13 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xc3>
nopl 0x0(%rax)
mov %r14,%rdx
mov %r12,%rdi
callq 2380 <_ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EE17_M_realloc_insertIJS7_EEEvN9__gnu_cxx17__normal_iteratorIPS7_S9_EEDpOT_>
mov (%rsp),%rdi
cmp %r13,%rdi
je 1e29 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xd9>
callq 11c0 <_ZdlPv@plt>
jmp 1e29 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xd9>
callq 11e0 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 124e <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE.cold+0xe>
endbr64
mov %rax,%rbp
jmpq 1240 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE.cold>
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 38h
mov r15, [rsi+8]
mov rbp, [rsi]
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
cmp r15, rbp
jz loc_2542
mov r14, rsp
lea r13, [rsp+68h+var_58]
nop dword ptr [rax+00h]
loc_2480:
mov rcx, [rbp+28h]
mov rdx, [rbp+20h]
cmp rdx, rcx
jz loc_2598
lea rax, [rdx+4]
mov ebx, [rdx]
cmp rcx, rax
jz short loc_24D8
mov rsi, rcx
sub rsi, rax
and esi, 4
jz short loc_24C0
mov eax, [rdx+4]
cmp ebx, eax
cmovl ebx, eax
lea rax, [rdx+8]
cmp rcx, rax
jz short loc_24D8
nop dword ptr [rax+rax+00000000h]
loc_24C0:
mov edx, [rax]
cmp ebx, edx
cmovl ebx, edx
mov edx, [rax+4]
cmp ebx, edx
cmovl ebx, edx
add rax, 8
cmp rcx, rax
jnz short loc_24C0
loc_24D8:
mov [rsp+68h+var_68], r13
mov rdx, [rbp+8]
mov rdi, r14
mov rsi, [rbp+0]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag_isra_0; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag) [clone]
mov [rsp+68h+var_48], ebx
mov rsi, [r12+8]
cmp rsi, [r12+10h]
jz short loc_2570
lea rdx, [rsi+10h]
mov [rsi], rdx
mov rax, [rsp+68h+var_68]
cmp rax, r13
jz loc_25A0
mov [rsi], rax
mov rax, [rsp+68h+var_58]
mov [rsi+10h], rax
mov rax, [rsp+68h+var_60]
loc_2524:
mov [rsi+8], rax
mov eax, [rsp+68h+var_48]
mov [rsi+20h], eax
add qword ptr [r12+8], 28h ; '('
loc_2535:
add rbp, 38h ; '8'
cmp r15, rbp
jnz loc_2480
loc_2542:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz loc_2645
add rsp, 38h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_2570:
mov rdx, r14
mov rdi, r12
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EE17_M_realloc_insertIJS7_EEEvN9__gnu_cxx17__normal_iteratorIPS7_S9_EEDpOT_; std::vector<std::pair<std::string,int>>::_M_realloc_insert<std::pair<std::string,int>>(__gnu_cxx::__normal_iterator<std::pair<std::string,int>*,std::vector<std::pair<std::string,int>>>,std::pair<std::string,int> &&)
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r13
jz short loc_2535
mov rax, [rsp+68h+var_58]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2535
loc_2598:
mov ebx, [rdx]
jmp loc_24D8
loc_25A0:
mov rax, [rsp+68h+var_60]
lea rcx, [rax+1]
cmp ecx, 8
jnb short loc_25E0
test cl, 4
jnz short loc_262E
test ecx, ecx
jz loc_2524
movzx edi, byte ptr [r13+0]
mov [rsi+10h], dil
test cl, 2
jz loc_2524
mov ecx, ecx
movzx edi, word ptr [r13+rcx-2]
mov [rdx+rcx-2], di
jmp loc_2524
loc_25E0:
mov rdi, [r13+0]
mov r9, r13
mov [rsi+10h], rdi
mov edi, ecx
mov r8, [r13+rdi-8]
mov [rdx+rdi-8], r8
lea r8, [rsi+18h]
and r8, 0FFFFFFFFFFFFFFF8h
sub rdx, r8
add ecx, edx
sub r9, rdx
and ecx, 0FFFFFFF8h
cmp ecx, 8
jb loc_2524
and ecx, 0FFFFFFF8h
xor edx, edx
loc_2618:
mov edi, edx
add edx, 8
mov r10, [r9+rdi]
mov [r8+rdi], r10
cmp edx, ecx
jb short loc_2618
jmp loc_2524
loc_262E:
mov edi, [r13+0]
mov ecx, ecx
mov [rsi+10h], edi
mov edi, [r13+rcx-4]
mov [rdx+rcx-4], edi
jmp loc_2524
loc_2645:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE_cold; func0(std::vector<std::pair<std::string,std::vector<int>>> const&) [clone]
endbr64
mov rbx, rax
jmp loc_12A8 | long long func0(long long a1, _QWORD *a2)
{
_QWORD *v3; // r15
_QWORD *v4; // rbp
int *v5; // rcx
int *v6; // rdx
int *v7; // rax
int v8; // ebx
long long v9; // rsi
long long v10; // rdx
long long v11; // rax
unsigned int v13; // ecx
unsigned long long v14; // r8
long long v15; // rdx
char *v16; // r9
unsigned int v17; // ecx
unsigned int v18; // ecx
unsigned int v19; // edx
long long v20; // rdi
void *v21; // [rsp+0h] [rbp-68h] BYREF
long long v22; // [rsp+8h] [rbp-60h]
_QWORD v23[2]; // [rsp+10h] [rbp-58h] BYREF
int v24; // [rsp+20h] [rbp-48h]
unsigned long long v25; // [rsp+28h] [rbp-40h]
v3 = (_QWORD *)a2[1];
v4 = (_QWORD *)*a2;
v25 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
for ( *(_OWORD *)a1 = 0LL; v3 != v4; v4 += 7 )
{
v5 = (int *)v4[5];
v6 = (int *)v4[4];
if ( v6 == v5 )
{
v8 = *v6;
}
else
{
v7 = v6 + 1;
v8 = *v6;
if ( v5 != v6 + 1 )
{
if ( (((_BYTE)v5 - (_BYTE)v7) & 4) == 0 )
goto LABEL_34;
if ( v8 < v6[1] )
v8 = v6[1];
v7 = v6 + 2;
if ( v5 != v6 + 2 )
{
LABEL_34:
do
{
if ( v8 < *v7 )
v8 = *v7;
if ( v8 < v7[1] )
v8 = v7[1];
v7 += 2;
}
while ( v5 != v7 );
}
}
}
v21 = v23;
std::string::_M_construct<char *>(&v21, *v4, *v4 + v4[1]);
v24 = v8;
v9 = *(_QWORD *)(a1 + 8);
if ( v9 == *(_QWORD *)(a1 + 16) )
{
std::vector<std::pair<std::string,int>>::_M_realloc_insert<std::pair<std::string,int>>(a1, v9, &v21);
if ( v21 != v23 )
operator delete(v21, v23[0] + 1LL);
}
else
{
v10 = v9 + 16;
*(_QWORD *)v9 = v9 + 16;
if ( v21 == v23 )
{
v11 = v22;
v13 = v22 + 1;
if ( (unsigned int)(v22 + 1) >= 8 )
{
*(_QWORD *)(v9 + 16) = v23[0];
*(_QWORD *)(v10 + v13 - 8) = *(_QWORD *)((char *)&v23[-1] + v13);
v14 = (v9 + 24) & 0xFFFFFFFFFFFFFFF8LL;
v15 = v10 - v14;
v16 = (char *)v23 - v15;
v17 = (v15 + v13) & 0xFFFFFFF8;
if ( v17 >= 8 )
{
v18 = v17 & 0xFFFFFFF8;
v19 = 0;
do
{
v20 = v19;
v19 += 8;
*(_QWORD *)(v14 + v20) = *(_QWORD *)&v16[v20];
}
while ( v19 < v18 );
}
}
else if ( (v13 & 4) != 0 )
{
*(_DWORD *)(v9 + 16) = v23[0];
*(_DWORD *)(v10 + v13 - 4) = *(_DWORD *)((char *)&v22 + v13 + 4);
}
else if ( (_DWORD)v22 != -1 )
{
*(_BYTE *)(v9 + 16) = v23[0];
if ( (v13 & 2) != 0 )
*(_WORD *)(v10 + v13 - 2) = *(_WORD *)((char *)&v22 + v13 + 6);
}
}
else
{
*(_QWORD *)v9 = v21;
*(_QWORD *)(v9 + 16) = v23[0];
v11 = v22;
}
*(_QWORD *)(v9 + 8) = v11;
*(_DWORD *)(v9 + 32) = v24;
*(_QWORD *)(a1 + 8) += 40LL;
}
}
return a1;
} | func0:
MOV RDI,R14
CALL 0x00101240
LAB_001012a8:
MOV RDI,R12
CALL 0x00102670
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012c8
MOV RDI,RBX
LAB_001012c3:
CALL 0x00101280
LAB_001012c8:
CALL 0x00101230 | /* func0(std::vector<std::pair<std::string, std::vector<int, std::allocator<int> > >,
std::allocator<std::pair<std::string, std::vector<int, std::allocator<int> > > > > const&) [clone
.cold] */
void func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,int param_10
,long param_11)
{
vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>> *unaff_R12;
long in_FS_OFFSET;
std::string::_M_dispose();
std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>>::~vector
(unaff_R12);
if (param_11 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume();
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,451 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
| vector<pair<string, int>> func0(const vector<pair<string, vector<int>>>& test_list) {
vector<pair<string, int>> res;
for (const auto &p : test_list) {
int max_val = *max_element(p.second.begin(), p.second.end());
res.push_back({p.first, max_val});
}
return res;
}
| int main() {
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {3, 4, 5}},
{"key2", {1, 4, 2}},
{"key3", {9, 3}}
};
vector<pair<string, int>> expected = {
{"key1", 5},
{"key2", 4},
{"key3", 9}
};
assert(func0(test_list) == expected);
}
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {4, 5, 6}},
{"key2", {2, 5, 3}},
{"key3", {10, 4}}
};
vector<pair<string, int>> expected = {
{"key1", 6},
{"key2", 5},
{"key3", 10}
};
assert(func0(test_list) == expected);
}
{
vector<pair<string, vector<int>>> test_list = {
{"key1", {5, 6, 7}},
{"key2", {3, 6, 4}},
{"key3", {11, 5}}
};
vector<pair<string, int>> expected = {
{"key1", 7},
{"key2", 6},
{"key3", 11}
};
assert(func0(test_list) == expected);
}
return 0;
}
| O3 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<int, std::allocator<int> > > > > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov (%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov 0x8(%rsi),%rax
lea 0x18(%rsp),%rcx
movups %xmm0,(%rdi)
movq $0x0,0x10(%rdi)
mov %rax,(%rsp)
mov %rcx,0x8(%rsp)
cmp %rax,%rbp
je 2107 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x1f7>
lea 0x30(%rsp),%r14
nopw 0x0(%rax,%rax,1)
mov 0x20(%rbp),%rax
mov 0x28(%rbp),%rsi
mov (%rax),%ebx
cmp %rax,%rsi
je 2065 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x155>
lea 0x4(%rax),%rcx
cmp %rcx,%rsi
je 2065 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x155>
lea -0x8(%rsi),%rdx
sub %rax,%rdx
mov %rdx,%rdi
shr $0x2,%rdi
add $0x1,%rdi
cmp $0x8,%rdx
jbe 203c <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x12c>
mov %rdi,%rdx
movd %ebx,%xmm3
shr $0x2,%rdx
pshufd $0x0,%xmm3,%xmm2
shl $0x4,%rdx
add %rax,%rdx
nopl 0x0(%rax,%rax,1)
movdqu 0x4(%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rdx,%rax
jne 1fc8 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0xb8>
movdqa %xmm2,%xmm0
mov %rdi,%rax
psrldq $0x8,%xmm0
and $0xfffffffffffffffc,%rax
movdqa %xmm0,%xmm1
lea (%rcx,%rax,4),%rcx
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
por %xmm1,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,%ebx
cmp %rax,%rdi
je 2065 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x155>
mov (%rcx),%eax
cmp %eax,%ebx
cmovl %eax,%ebx
lea 0x4(%rcx),%rax
cmp %rax,%rsi
je 2065 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x155>
mov 0x4(%rcx),%eax
cmp %eax,%ebx
cmovl %eax,%ebx
lea 0x8(%rcx),%rax
cmp %rax,%rsi
je 2065 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x155>
mov 0x8(%rcx),%eax
cmp %eax,%ebx
cmovl %eax,%ebx
mov %r14,0x20(%rsp)
mov 0x0(%rbp),%r15
mov 0x8(%rbp),%r12
mov %r15,%rax
add %r12,%rax
je 2083 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x173>
test %r15,%r15
je 21c5 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x2b5>
mov %r12,0x18(%rsp)
cmp $0xf,%r12
ja 2148 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x238>
cmp $0x1,%r12
jne 2130 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x220>
movzbl (%r15),%eax
mov %al,0x30(%rsp)
mov %r14,%rax
mov %r12,0x28(%rsp)
movb $0x0,(%rax,%r12,1)
mov 0x8(%r13),%rsi
mov %ebx,0x40(%rsp)
cmp 0x10(%r13),%rsi
je 21a0 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x290>
lea 0x10(%rsi),%rax
mov %rax,(%rsi)
mov 0x20(%rsp),%rax
cmp %r14,%rax
je 2188 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x278>
mov %rax,(%rsi)
mov 0x30(%rsp),%rax
mov %rax,0x10(%rsi)
mov 0x28(%rsp),%rax
mov %rax,0x8(%rsi)
mov 0x40(%rsp),%eax
mov %eax,0x20(%rsi)
addq $0x28,0x8(%r13)
add $0x38,%rbp
cmp %rbp,(%rsp)
jne 1f70 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x60>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 21d6 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x2c6>
add $0x58,%rsp
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
test %r12,%r12
jne 21d1 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x2c1>
mov %r14,%rax
jmpq 20a7 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x197>
nopl 0x0(%rax)
mov 0x8(%rsp),%rsi
lea 0x20(%rsp),%rdi
xor %edx,%edx
callq 1230 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,0x20(%rsp)
mov %rax,%rdi
mov 0x18(%rsp),%rax
mov %rax,0x30(%rsp)
mov %r12,%rdx
mov %r15,%rsi
callq 11b0 <memcpy@plt>
mov 0x18(%rsp),%r12
mov 0x20(%rsp),%rax
jmpq 20a7 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x197>
nopl (%rax)
movdqa 0x30(%rsp),%xmm4
movups %xmm4,0x10(%rsi)
jmpq 20e4 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x1d4>
nopw 0x0(%rax,%rax,1)
lea 0x20(%rsp),%rdx
mov %r13,%rdi
callq 2a30 <_ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EE17_M_realloc_insertIJS7_EEEvN9__gnu_cxx17__normal_iteratorIPS7_S9_EEDpOT_>
mov 0x20(%rsp),%rdi
cmp %r14,%rdi
je 20f9 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x1e9>
callq 11c0 <_ZdlPv@plt>
jmpq 20f9 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x1e9>
lea 0xe3c(%rip),%rdi
callq 11a0 <_ZSt19__throw_logic_errorPKc@plt>
mov %r14,%rdi
jmp 216b <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE+0x25b>
callq 11e0 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1255 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE.cold>
endbr64
mov %rax,%rbp
jmpq 1264 <_Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE.cold+0xf>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 68h
mov rbp, [rsi]
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
lea rcx, [rsp+98h+var_68]
mov rax, [rsi+8]
movups xmmword ptr [rdi], xmm0
mov [rsp+98h+var_88], rcx
lea rcx, [rsp+98h+var_70]
mov qword ptr [rdi+10h], 0
mov [rsp+98h+var_90], rax
mov [rsp+98h+var_80], rcx
cmp rax, rbp
jz loc_249F
lea r14, [rsp+98h+var_58]
nop word ptr [rax+rax+00h]
loc_2318:
mov rsi, [rbp+28h]
mov rax, [rbp+20h]
cmp rax, rsi
jz loc_2520
lea rcx, [rax+4]
mov ebx, [rax]
cmp rsi, rcx
jz loc_240D
lea rdx, [rsi-8]
sub rdx, rax
mov rdi, rdx
shr rdi, 2
add rdi, 1
cmp rdx, 8
jbe loc_23E4
mov rdx, rdi
movd xmm3, ebx
shr rdx, 2
pshufd xmm2, xmm3, 0
shl rdx, 4
add rdx, rax
nop dword ptr [rax+rax+00h]
loc_2370:
movdqu xmm0, xmmword ptr [rax+4]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rax, rdx
jnz short loc_2370
movdqa xmm1, xmm2
mov rax, rdi
psrldq xmm1, 8
and rax, 0FFFFFFFFFFFFFFFCh
and edi, 3
movdqa xmm0, xmm1
lea rcx, [rcx+rax*4]
pcmpgtd xmm0, xmm2
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd ebx, xmm1
jz short loc_240D
loc_23E4:
mov eax, [rcx]
cmp ebx, eax
cmovl ebx, eax
lea rax, [rcx+4]
cmp rsi, rax
jz short loc_240D
mov eax, [rcx+4]
cmp ebx, eax
cmovl ebx, eax
lea rax, [rcx+8]
cmp rsi, rax
jz short loc_240D
mov eax, [rcx+8]
cmp ebx, eax
cmovl ebx, eax
loc_240D:
mov r12, [rbp+8]
mov [rsp+98h+var_68], r14
mov r15, [rbp+0]
mov [rsp+98h+var_70], r12
cmp r12, 0Fh
ja loc_24E0
cmp r12, 1
jnz loc_24C8
movzx eax, byte ptr [r15]
mov byte ptr [rsp+98h+var_58], al
loc_243B:
mov rax, r14
loc_243E:
mov [rsp+98h+var_60], r12
mov byte ptr [rax+r12], 0
mov rsi, [r13+8]
mov [rsp+98h+var_48], ebx
cmp rsi, [r13+10h]
jz loc_2530
lea rdx, [rsi+10h]
mov [rsi], rdx
mov rax, [rsp+98h+var_68]
cmp rax, r14
jz loc_2560
mov [rsi], rax
mov rax, [rsp+98h+var_58]
mov [rsi+10h], rax
mov rax, [rsp+98h+var_60]
loc_2480:
mov [rsi+8], rax
mov eax, [rsp+98h+var_48]
mov [rsi+20h], eax
add qword ptr [r13+8], 28h ; '('
loc_2490:
add rbp, 38h ; '8'
cmp [rsp+98h+var_90], rbp
jnz loc_2318
loc_249F:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz loc_2604
add rsp, 68h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_24C8:
test r12, r12
jz loc_243B
mov rdi, r14
jmp short loc_2503
loc_24E0:
mov rsi, [rsp+98h+var_80]
mov rdi, [rsp+98h+var_88]
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rsp+98h+var_68], rax
mov rdi, rax; dest
mov rax, [rsp+98h+var_70]
mov [rsp+98h+var_58], rax
loc_2503:
mov rdx, r12; n
mov rsi, r15; src
call _memcpy
mov r12, [rsp+98h+var_70]
mov rax, [rsp+98h+var_68]
jmp loc_243E
loc_2520:
mov ebx, [rax]
jmp loc_240D
loc_2530:
mov rdx, [rsp+98h+var_88]
mov rdi, r13
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESaIS7_EE17_M_realloc_insertIJS7_EEEvN9__gnu_cxx17__normal_iteratorIPS7_S9_EEDpOT_; std::vector<std::pair<std::string,int>>::_M_realloc_insert<std::pair<std::string,int>>(__gnu_cxx::__normal_iterator<std::pair<std::string,int>*,std::vector<std::pair<std::string,int>>>,std::pair<std::string,int> &&)
mov rdi, [rsp+98h+var_68]; void *
cmp rdi, r14
jz loc_2490
mov rax, [rsp+98h+var_58]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_2490
loc_2560:
mov rax, [rsp+98h+var_60]
lea rcx, [rax+1]
cmp ecx, 8
jnb short loc_25A0
test cl, 4
jnz short loc_25EE
test ecx, ecx
jz loc_2480
movzx edi, byte ptr [r14]
mov [rsi+10h], dil
test cl, 2
jz loc_2480
mov ecx, ecx
movzx edi, word ptr [r14+rcx-2]
mov [rdx+rcx-2], di
jmp loc_2480
loc_25A0:
mov rdi, [r14]
mov [rsi+10h], rdi
mov edi, ecx
mov r8, [r14+rdi-8]
mov [rdx+rdi-8], r8
lea rdi, [rsi+18h]
mov r8, r14
and rdi, 0FFFFFFFFFFFFFFF8h
sub rdx, rdi
add ecx, edx
sub r8, rdx
and ecx, 0FFFFFFF8h
cmp ecx, 8
jb loc_2480
and ecx, 0FFFFFFF8h
xor edx, edx
loc_25D7:
mov r9d, edx
add edx, 8
mov r10, [r8+r9]
mov [rdi+r9], r10
cmp edx, ecx
jb short loc_25D7
jmp loc_2480
loc_25EE:
mov edi, [r14]
mov ecx, ecx
mov [rsi+10h], edi
mov edi, [r14+rcx-4]
mov [rdx+rcx-4], edi
jmp loc_2480
loc_2604:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES_IiSaIiEEESaIS9_EE_cold; func0(std::vector<std::pair<std::string,std::vector<int>>> const&) [clone]
endbr64
mov rbx, rax
jmp loc_128A | long long func0(long long a1, long long *a2)
{
long long v3; // rbp
long long v4; // rax
signed int *v5; // rsi
long long v6; // rax
signed int *v7; // rcx
signed int v8; // ebx
unsigned long long v9; // rdi
__m128i v10; // xmm2
long long v11; // rdx
__m128i v12; // xmm0
__m128i v13; // xmm1
__m128i v14; // xmm1
__m128i v15; // xmm0
__m128i v16; // xmm0
__m128i v17; // xmm2
__m128i v18; // xmm1
size_t v19; // r12
_BYTE *v20; // r15
_QWORD *v21; // rax
long long v22; // rsi
long long v23; // rdx
size_t v24; // rax
_QWORD *v26; // rdi
unsigned int v27; // ecx
unsigned long long v28; // rdi
long long v29; // rdx
char *v30; // r8
unsigned int v31; // ecx
unsigned int v32; // ecx
unsigned int v33; // edx
long long v34; // r9
long long v35; // [rsp+0h] [rbp-90h]
size_t v36; // [rsp+20h] [rbp-70h] BYREF
void *v37; // [rsp+28h] [rbp-68h] BYREF
size_t v38; // [rsp+30h] [rbp-60h]
_QWORD v39[2]; // [rsp+38h] [rbp-58h] BYREF
signed int v40; // [rsp+48h] [rbp-48h]
unsigned long long v41; // [rsp+50h] [rbp-40h]
v3 = *a2;
v41 = __readfsqword(0x28u);
v4 = a2[1];
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v35 = v4;
if ( v4 != v3 )
{
while ( 1 )
{
v5 = *(signed int **)(v3 + 40);
v6 = *(_QWORD *)(v3 + 32);
if ( (signed int *)v6 == v5 )
{
v8 = *(_DWORD *)v6;
}
else
{
v7 = (signed int *)(v6 + 4);
v8 = *(_DWORD *)v6;
if ( v5 != (signed int *)(v6 + 4) )
{
v9 = (((unsigned long long)v5 - v6 - 8) >> 2) + 1;
if ( (unsigned long long)v5 - v6 - 8 <= 8 )
goto LABEL_8;
v10 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v8), 0);
v11 = v6 + 16 * (v9 >> 2);
do
{
v12 = _mm_loadu_si128((const __m128i *)(v6 + 4));
v6 += 16LL;
v13 = _mm_cmpgt_epi32(v12, v10);
v10 = _mm_or_si128(_mm_andnot_si128(v13, v10), _mm_and_si128(v12, v13));
}
while ( v6 != v11 );
v14 = _mm_srli_si128(v10, 8);
v7 += v9 & 0xFFFFFFFFFFFFFFFCLL;
v15 = _mm_cmpgt_epi32(v14, v10);
v16 = _mm_or_si128(_mm_andnot_si128(v15, v10), _mm_and_si128(v14, v15));
v17 = _mm_srli_si128(v16, 4);
v18 = _mm_cmpgt_epi32(v17, v16);
v8 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v18, v16), _mm_and_si128(v17, v18)));
if ( (v9 & 3) != 0 )
{
LABEL_8:
if ( v8 < *v7 )
v8 = *v7;
if ( v5 != v7 + 1 )
{
if ( v8 < v7[1] )
v8 = v7[1];
if ( v5 != v7 + 2 && v8 < v7[2] )
v8 = v7[2];
}
}
}
}
v19 = *(_QWORD *)(v3 + 8);
v37 = v39;
v20 = *(_BYTE **)v3;
v36 = v19;
if ( v19 > 0xF )
break;
if ( v19 == 1 )
{
LOBYTE(v39[0]) = *v20;
}
else if ( v19 )
{
v26 = v39;
LABEL_29:
memcpy(v26, v20, v19);
v19 = v36;
v21 = v37;
goto LABEL_20;
}
v21 = v39;
LABEL_20:
v38 = v19;
*((_BYTE *)v21 + v19) = 0;
v22 = *(_QWORD *)(a1 + 8);
v40 = v8;
if ( v22 == *(_QWORD *)(a1 + 16) )
{
std::vector<std::pair<std::string,int>>::_M_realloc_insert<std::pair<std::string,int>>(a1, v22, &v37);
if ( v37 != v39 )
operator delete(v37, v39[0] + 1LL);
}
else
{
v23 = v22 + 16;
*(_QWORD *)v22 = v22 + 16;
if ( v37 == v39 )
{
v24 = v38;
v27 = v38 + 1;
if ( (unsigned int)(v38 + 1) >= 8 )
{
*(_QWORD *)(v22 + 16) = v39[0];
*(_QWORD *)(v23 + v27 - 8) = *(_QWORD *)((char *)&v39[-1] + v27);
v28 = (v22 + 24) & 0xFFFFFFFFFFFFFFF8LL;
v29 = v23 - v28;
v30 = (char *)v39 - v29;
v31 = (v29 + v27) & 0xFFFFFFF8;
if ( v31 >= 8 )
{
v32 = v31 & 0xFFFFFFF8;
v33 = 0;
do
{
v34 = v33;
v33 += 8;
*(_QWORD *)(v28 + v34) = *(_QWORD *)&v30[v34];
}
while ( v33 < v32 );
}
}
else if ( (v27 & 4) != 0 )
{
*(_DWORD *)(v22 + 16) = v39[0];
*(_DWORD *)(v23 + v27 - 4) = *(_DWORD *)((char *)&v38 + v27 + 4);
}
else if ( (_DWORD)v38 != -1 )
{
*(_BYTE *)(v22 + 16) = v39[0];
if ( (v27 & 2) != 0 )
*(_WORD *)(v23 + v27 - 2) = *(_WORD *)((char *)&v38 + v27 + 6);
}
}
else
{
*(_QWORD *)v22 = v37;
*(_QWORD *)(v22 + 16) = v39[0];
v24 = v38;
}
*(_QWORD *)(v22 + 8) = v24;
*(_DWORD *)(v22 + 32) = v40;
*(_QWORD *)(a1 + 8) += 40LL;
}
v3 += 56LL;
if ( v35 == v3 )
return a1;
}
v37 = (void *)std::string::_M_create(&v37, &v36, 0LL);
v26 = v37;
v39[0] = v36;
goto LABEL_29;
}
return a1;
} | func0:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00101220
LAB_0010128a:
MOV RDI,R13
CALL 0x00102630
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012aa
MOV RDI,RBX
LAB_001012a5:
CALL 0x00101260
LAB_001012aa:
CALL 0x00101210 | /* func0(std::vector<std::pair<std::string, std::vector<int, std::allocator<int> > >,
std::allocator<std::pair<std::string, std::vector<int, std::allocator<int> > > > > const&) [clone
.cold] */
void func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int8 param_8,int param_9,
int param_10,long param_11)
{
vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>> *unaff_R13;
long in_FS_OFFSET;
std::string::_M_dispose();
std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>>::~vector
(unaff_R13);
if (param_11 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume();
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,452 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<std::vector<int>>& test_list) {
int res = 0;
for (const auto& sublist : test_list) {
res += std::accumulate(sublist.begin(), sublist.end(), 0);
}
return res;
}
| int main() {
assert(func0({{1, 3}, {5, 6, 7}, {2, 6}}) == 30);
assert(func0({{2, 4}, {6, 7, 8}, {3, 7}}) == 37);
assert(func0({{3, 5}, {7, 8, 9}, {4, 8}}) == 44);
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
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x3c(%rbp)
mov -0x48(%rbp),%rax
mov %rax,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1c3e <_ZNKSt6vectorIS_IiSaIiEESaIS1_EE5beginEv>
mov %rax,-0x38(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1c96 <_ZNKSt6vectorIS_IiSaIiEESaIS1_EE3endEv>
mov %rax,-0x30(%rbp)
lea -0x30(%rbp),%rdx
lea -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1cee <_ZN9__gnu_cxxneIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESD_>
test %al,%al
je 133b <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xb2>
lea -0x38(%rbp),%rax
mov %rax,%rdi
callq 1d52 <_ZNK9__gnu_cxx17__normal_iteratorIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEdeEv>
mov %rax,-0x20(%rbp)
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1dc0 <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1d68 <_ZNKSt6vectorIiSaIiEE5beginEv>
mov $0x0,%edx
mov %rbx,%rsi
mov %rax,%rdi
callq 1e18 <_ZSt10accumulateIN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEEiET0_T_S9_S8_>
add %eax,-0x3c(%rbp)
lea -0x38(%rbp),%rax
mov %rax,%rdi
callq 1d2e <_ZN9__gnu_cxx17__normal_iteratorIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEppEv>
jmp 12d8 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x4f>
mov -0x3c(%rbp),%eax
mov -0x18(%rbp),%rcx
xor %fs:0x28,%rcx
je 1352 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xc9>
callq 1150 <__stack_chk_fail@plt>
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_3C], 0
mov rax, [rbp+var_48]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EE5beginEv; std::vector<std::vector<int>>::begin(void)
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EE3endEv; std::vector<std::vector<int>>::end(void)
mov [rbp+var_30], rax
jmp short loc_1344
loc_12FA:
lea rax, [rbp+var_38]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEdeEv; __gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>>::operator*(void)
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [rbp+var_20]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov edx, 0
mov rsi, rbx
mov rdi, rax
call _ZSt10accumulateIN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEEiET0_T_S9_S8_; std::accumulate<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,int>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,int)
add [rbp+var_3C], eax
lea rax, [rbp+var_38]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEppEv; __gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>>::operator++(void)
loc_1344:
lea rdx, [rbp+var_30]
lea rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESD_; __gnu_cxx::operator!=<std::vector<int> const*,std::vector<std::vector<int>>>(__gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>> const&,__gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>> const&)
test al, al
jnz short loc_12FA
mov eax, [rbp+var_3C]
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1372
call ___stack_chk_fail
loc_1372:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1)
{
long long v1; // rbx
long long v2; // rax
unsigned int v4; // [rsp+14h] [rbp-3Ch]
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);
v4 = 0;
v6[1] = a1;
v5 = std::vector<std::vector<int>>::begin(a1);
v6[0] = std::vector<std::vector<int>>::end(a1);
while ( (unsigned __int8)__gnu_cxx::operator!=<std::vector<int> const*,std::vector<std::vector<int>>>(&v5, v6) )
{
v7 = __gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>>::operator*(&v5);
v1 = std::vector<int>::end(v7);
v2 = std::vector<int>::begin(v7);
v4 += std::accumulate<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,int>(v2, v1, 0LL);
__gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>>::operator++(&v5);
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101c82
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101cce
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00101344
LAB_001012fa:
LEA RAX,[RBP + -0x38]
MOV RDI,RAX
CALL 0x00101d82
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101de4
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101d98
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00101e34
ADD dword ptr [RBP + -0x3c],EAX
LEA RAX,[RBP + -0x38]
MOV RDI,RAX
CALL 0x00101d5e
LAB_00101344:
LEA RDX,[RBP + -0x30]
LEA RAX,[RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101d1e
TEST AL,AL
JNZ 0x001012fa
MOV EAX,dword ptr [RBP + -0x3c]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101372
CALL 0x00101170
LAB_00101372:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
bool bVar1;
int iVar2;
int8 uVar3;
int8 uVar4;
long in_FS_OFFSET;
int local_44;
int8 local_40;
int8 local_38;
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*local_30;
vector<int,std::allocator<int>> *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_44 = 0;
local_30 = (vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)param_1;
local_40 = std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::begin((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)param_1);
local_38 = std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::end(local_30);
while( true ) {
bVar1 = operator!=((__normal_iterator *)&local_40,(__normal_iterator *)&local_38);
if (!bVar1) break;
local_28 = (vector<int,std::allocator<int>> *)
__normal_iterator<std::vector<int,std::allocator<int>>const*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
::operator*((__normal_iterator<std::vector<int,std::allocator<int>>const*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
*)&local_40);
uVar3 = std::vector<int,std::allocator<int>>::end(local_28);
uVar4 = std::vector<int,std::allocator<int>>::begin(local_28);
iVar2 = std::accumulate<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>,int>
(uVar4,uVar3,0);
local_44 = local_44 + iVar2;
__normal_iterator<std::vector<int,std::allocator<int>>const*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
::operator++((__normal_iterator<std::vector<int,std::allocator<int>>const*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>
*)&local_40);
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_44;
} |
2,453 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<std::vector<int>>& test_list) {
int res = 0;
for (const auto& sublist : test_list) {
res += std::accumulate(sublist.begin(), sublist.end(), 0);
}
return res;
}
| int main() {
assert(func0({{1, 3}, {5, 6, 7}, {2, 6}}) == 30);
assert(func0({{2, 4}, {6, 7, 8}, {3, 7}}) == 37);
assert(func0({{3, 5}, {7, 8, 9}, {4, 8}}) == 44);
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),%rsi
mov 0x8(%rdi),%r8
cmp %r8,%rsi
je 12f0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x47>
mov $0x0,%edi
mov $0x0,%r9d
jmp 12d4 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x2b>
mov %r9d,%edx
add %edx,%edi
add $0x18,%rsi
cmp %rsi,%r8
je 12f5 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x4c>
mov 0x8(%rsi),%rcx
mov (%rsi),%rax
cmp %rcx,%rax
je 12c6 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x1d>
mov %r9d,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rax,%rcx
jne 12e3 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x3a>
jmp 12c9 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x20>
mov $0x0,%edi
mov %edi,%eax
retq
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rsi, [rdi]
mov r8, [rdi+8]
cmp r8, rsi
jz short loc_12F1
mov edi, 0
mov r9d, 0
loc_12C4:
mov rcx, [rsi+8]
mov rax, [rsi]
cmp rax, rcx
jz short loc_12EC
mov edx, r9d
loc_12D3:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_12D3
loc_12DE:
add edi, edx
add rsi, 18h
cmp r8, rsi
jnz short loc_12C4
loc_12E9:
mov eax, edi
retn
loc_12EC:
mov edx, r9d
jmp short loc_12DE
loc_12F1:
mov edi, 0
jmp short loc_12E9 | long long func0(long long *a1)
{
long long v1; // rsi
long long v2; // r8
unsigned int v3; // edi
_DWORD *v4; // rcx
_DWORD *v5; // rax
int v6; // edx
v1 = *a1;
v2 = a1[1];
if ( v2 == *a1 )
{
return 0;
}
else
{
v3 = 0;
do
{
v4 = *(_DWORD **)(v1 + 8);
v5 = *(_DWORD **)v1;
if ( *(_DWORD **)v1 == v4 )
{
v6 = 0;
}
else
{
v6 = 0;
do
v6 += *v5++;
while ( v5 != v4 );
}
v3 += v6;
v1 += 24LL;
}
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
MOV RSI,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
CMP R8,RSI
JZ 0x001012f1
MOV EDI,0x0
MOV R9D,0x0
LAB_001012c4:
MOV RCX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RSI]
CMP RAX,RCX
JZ 0x001012ec
MOV EDX,R9D
LAB_001012d3:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001012d3
LAB_001012de:
ADD EDI,EDX
ADD RSI,0x18
CMP R8,RSI
JNZ 0x001012c4
LAB_001012e9:
MOV EAX,EDI
RET
LAB_001012ec:
MOV EDX,R9D
JMP 0x001012de
LAB_001012f1:
MOV EDI,0x0
JMP 0x001012e9 | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
int *piVar1;
int iVar2;
int8 *puVar3;
int iVar4;
puVar3 = *(int8 **)param_1;
if (*(int8 **)(param_1 + 8) == puVar3) {
iVar4 = 0;
}
else {
iVar4 = 0;
do {
piVar1 = (int *)*puVar3;
iVar2 = 0;
if (piVar1 != (int *)puVar3[1]) {
iVar2 = 0;
do {
iVar2 = iVar2 + *piVar1;
piVar1 = piVar1 + 1;
} while (piVar1 != (int *)puVar3[1]);
}
iVar4 = iVar4 + iVar2;
puVar3 = puVar3 + 3;
} while (*(int8 **)(param_1 + 8) != puVar3);
}
return iVar4;
} |
2,454 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<std::vector<int>>& test_list) {
int res = 0;
for (const auto& sublist : test_list) {
res += std::accumulate(sublist.begin(), sublist.end(), 0);
}
return res;
}
| int main() {
assert(func0({{1, 3}, {5, 6, 7}, {2, 6}}) == 30);
assert(func0({{2, 4}, {6, 7, 8}, {3, 7}}) == 37);
assert(func0({{3, 5}, {7, 8, 9}, {4, 8}}) == 44);
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),%rsi
mov 0x8(%rdi),%rdi
xor %r8d,%r8d
cmp %rdi,%rsi
je 17b7 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x47>
nopl 0x0(%rax,%rax,1)
mov 0x8(%rsi),%rcx
mov (%rsi),%rax
cmp %rax,%rcx
je 17ae <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x3e>
xor %edx,%edx
nopw %cs:0x0(%rax,%rax,1)
add (%rax),%edx
add $0x4,%rax
cmp %rax,%rcx
jne 17a0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x30>
add %edx,%r8d
add $0x18,%rsi
cmp %rsi,%rdi
jne 1788 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x18>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rsi, [rdi]
mov r8, [rdi+8]
xor edi, edi
cmp r8, rsi
jz short loc_17F6
nop word ptr [rax+rax+00h]
loc_17C8:
mov rcx, [rsi+8]
mov rax, [rsi]
cmp rax, rcx
jz short loc_17ED
xor edx, edx
nop word ptr [rax+rax+00000000h]
loc_17E0:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_17E0
add edi, edx
loc_17ED:
add rsi, 18h
cmp r8, rsi
jnz short loc_17C8
loc_17F6:
mov eax, edi
retn | long long func0(long long *a1)
{
long long v1; // rsi
long long v2; // r8
unsigned int i; // edi
_DWORD *v4; // rcx
_DWORD *v5; // rax
int v6; // edx
v1 = *a1;
v2 = a1[1];
for ( i = 0; v2 != v1; v1 += 24LL )
{
v4 = *(_DWORD **)(v1 + 8);
v5 = *(_DWORD **)v1;
if ( *(_DWORD **)v1 != v4 )
{
v6 = 0;
do
v6 += *v5++;
while ( v5 != v4 );
i += v6;
}
}
return i;
} | func0:
ENDBR64
MOV RSI,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
XOR EDI,EDI
CMP R8,RSI
JZ 0x001017f6
NOP word ptr [RAX + RAX*0x1]
LAB_001017c8:
MOV RCX,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RSI]
CMP RAX,RCX
JZ 0x001017ed
XOR EDX,EDX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001017e0:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001017e0
ADD EDI,EDX
LAB_001017ed:
ADD RSI,0x18
CMP R8,RSI
JNZ 0x001017c8
LAB_001017f6:
MOV EAX,EDI
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
int *piVar1;
int iVar2;
int8 *puVar3;
int iVar4;
iVar4 = 0;
for (puVar3 = *(int8 **)param_1; *(int8 **)(param_1 + 8) != puVar3;
puVar3 = puVar3 + 3) {
piVar1 = (int *)*puVar3;
if (piVar1 != (int *)puVar3[1]) {
iVar2 = 0;
do {
iVar2 = iVar2 + *piVar1;
piVar1 = piVar1 + 1;
} while (piVar1 != (int *)puVar3[1]);
iVar4 = iVar4 + iVar2;
}
}
return iVar4;
} |
2,455 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<std::vector<int>>& test_list) {
int res = 0;
for (const auto& sublist : test_list) {
res += std::accumulate(sublist.begin(), sublist.end(), 0);
}
return res;
}
| int main() {
assert(func0({{1, 3}, {5, 6, 7}, {2, 6}}) == 30);
assert(func0({{2, 4}, {6, 7, 8}, {3, 7}}) == 37);
assert(func0({{3, 5}, {7, 8, 9}, {4, 8}}) == 44);
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),%rsi
mov 0x8(%rdi),%r10
xor %r9d,%r9d
cmp %r10,%rsi
je 1acd <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xdd>
movabs $0x3ffffffffffffffc,%r11
nopl 0x0(%rax)
mov 0x8(%rsi),%rdi
mov (%rsi),%rdx
cmp %rdx,%rdi
je 1ac0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xd0>
lea -0x4(%rdi),%rcx
mov %rdx,%rax
sub %rdx,%rcx
shr $0x2,%rcx
lea 0x1(%rcx),%r8
test %r11,%rcx
je 1ad1 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xe1>
mov %r8,%rcx
pxor %xmm0,%xmm0
shr $0x2,%rcx
shl $0x4,%rcx
add %rdx,%rcx
nopl (%rax)
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rax,%rcx
jne 1a58 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x68>
movdqa %xmm0,%xmm1
mov %r8,%rcx
psrldq $0x8,%xmm1
and $0xfffffffffffffffc,%rcx
paddd %xmm1,%xmm0
lea (%rdx,%rcx,4),%rdx
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
cmp %rcx,%r8
je 1abd <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xcd>
lea 0x4(%rdx),%rcx
add (%rdx),%eax
cmp %rcx,%rdi
je 1abd <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xcd>
lea 0x8(%rdx),%rcx
add 0x4(%rdx),%eax
cmp %rcx,%rdi
je 1abd <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xcd>
lea 0xc(%rdx),%rcx
add 0x8(%rdx),%eax
cmp %rcx,%rdi
je 1abd <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xcd>
add 0xc(%rdx),%eax
add %eax,%r9d
add $0x18,%rsi
cmp %rsi,%r10
jne 1a18 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x28>
mov %r9d,%eax
retq
xor %eax,%eax
jmp 1a97 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xa7>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
mov rax, rdi
mov rdi, [rdi]
xor r9d, r9d
mov r10, [rax+8]
cmp r10, rdi
jz loc_1B1F
nop word ptr [rax+rax+00h]
loc_1A70:
mov r8, [rdi+8]
mov rdx, [rdi]
cmp rdx, r8
jz loc_1B12
lea rcx, [r8-4]
mov rax, rdx
sub rcx, rdx
mov rsi, rcx
shr rsi, 2
add rsi, 1
cmp rcx, 8
jbe loc_1B23
mov rcx, rsi
pxor xmm0, xmm0
shr rcx, 2
shl rcx, 4
add rcx, rdx
nop dword ptr [rax+00000000h]
loc_1AB8:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp rcx, rax
jnz short loc_1AB8
movdqa xmm1, xmm0
psrldq xmm1, 8
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test sil, 3
jz short loc_1B0F
and rsi, 0FFFFFFFFFFFFFFFCh
lea rdx, [rdx+rsi*4]
loc_1AF5:
lea rcx, [rdx+4]
add eax, [rdx]
cmp r8, rcx
jz short loc_1B0F
lea rcx, [rdx+8]
add eax, [rdx+4]
cmp r8, rcx
jz short loc_1B0F
add eax, [rdx+8]
loc_1B0F:
add r9d, eax
loc_1B12:
add rdi, 18h
cmp r10, rdi
jnz loc_1A70
loc_1B1F:
mov eax, r9d
retn
loc_1B23:
xor eax, eax
jmp short loc_1AF5 | long long func0(long long *a1)
{
long long v2; // rdi
unsigned int v3; // r9d
long long v4; // r10
unsigned long long *v5; // r8
const __m128i *v6; // rdx
const __m128i *v7; // rax
unsigned long long v8; // rsi
__m128i v9; // xmm0
__m128i v10; // xmm2
__m128i v11; // xmm0
int v12; // eax
v2 = *a1;
v3 = 0;
v4 = a1[1];
if ( v4 != v2 )
{
while ( 1 )
{
v5 = *(unsigned long long **)(v2 + 8);
v6 = *(const __m128i **)v2;
if ( *(unsigned long long **)v2 != v5 )
break;
LABEL_12:
v2 += 24LL;
if ( v4 == v2 )
return v3;
}
v7 = *(const __m128i **)v2;
v8 = ((unsigned long long)((char *)v5 - 4 - (char *)v6) >> 2) + 1;
if ( (unsigned long long)((char *)v5 - 4 - (char *)v6) <= 8 )
{
v12 = 0;
}
else
{
v9 = 0LL;
do
{
v10 = _mm_loadu_si128(v7++);
v9 = _mm_add_epi32(v9, v10);
}
while ( &v6[v8 >> 2] != v7 );
v11 = _mm_add_epi32(v9, _mm_srli_si128(v9, 8));
v12 = _mm_cvtsi128_si32(_mm_add_epi32(v11, _mm_srli_si128(v11, 4)));
if ( (v8 & 3) == 0 )
{
LABEL_11:
v3 += v12;
goto LABEL_12;
}
v6 = (const __m128i *)((char *)v6 + 4 * (v8 & 0xFFFFFFFFFFFFFFFCLL));
}
v12 += v6->m128i_i32[0];
if ( v5 != (unsigned long long *)((char *)v6->m128i_i64 + 4) )
{
v12 += v6->m128i_i32[1];
if ( v5 != &v6->m128i_u64[1] )
v12 += v6->m128i_i32[2];
}
goto LABEL_11;
}
return v3;
} | func0:
ENDBR64
MOV RAX,RDI
MOV RDI,qword ptr [RDI]
XOR R9D,R9D
MOV R10,qword ptr [RAX + 0x8]
CMP R10,RDI
JZ 0x00101b1f
NOP word ptr [RAX + RAX*0x1]
LAB_00101a70:
MOV R8,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI]
CMP RDX,R8
JZ 0x00101b12
LEA RCX,[R8 + -0x4]
MOV RAX,RDX
SUB RCX,RDX
MOV RSI,RCX
SHR RSI,0x2
ADD RSI,0x1
CMP RCX,0x8
JBE 0x00101b23
MOV RCX,RSI
PXOR XMM0,XMM0
SHR RCX,0x2
SHL RCX,0x4
ADD RCX,RDX
NOP dword ptr [RAX]
LAB_00101ab8:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RCX,RAX
JNZ 0x00101ab8
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST SIL,0x3
JZ 0x00101b0f
AND RSI,-0x4
LEA RDX,[RDX + RSI*0x4]
LAB_00101af5:
LEA RCX,[RDX + 0x4]
ADD EAX,dword ptr [RDX]
CMP R8,RCX
JZ 0x00101b0f
LEA RCX,[RDX + 0x8]
ADD EAX,dword ptr [RDX + 0x4]
CMP R8,RCX
JZ 0x00101b0f
ADD EAX,dword ptr [RDX + 0x8]
LAB_00101b0f:
ADD R9D,EAX
LAB_00101b12:
ADD RDI,0x18
CMP R10,RDI
JNZ 0x00101a70
LAB_00101b1f:
MOV EAX,R9D
RET
LAB_00101b23:
XOR EAX,EAX
JMP 0x00101af5 | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
int func0(vector *param_1)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
ulong uVar7;
int *piVar8;
ulong uVar9;
int8 *puVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
puVar10 = *(int8 **)param_1;
iVar11 = 0;
do {
if (*(int8 **)(param_1 + 8) == puVar10) {
return iVar11;
}
piVar1 = (int *)puVar10[1];
piVar8 = (int *)*puVar10;
if (piVar8 != piVar1) {
uVar7 = (long)piVar1 + (-4 - (long)piVar8);
uVar9 = (uVar7 >> 2) + 1;
if (uVar7 < 9) {
iVar12 = 0;
LAB_00101af5:
iVar12 = iVar12 + *piVar8;
if ((piVar1 != piVar8 + 1) && (iVar12 = iVar12 + piVar8[1], piVar1 != piVar8 + 2)) {
iVar12 = iVar12 + piVar8[2];
}
}
else {
iVar12 = 0;
iVar13 = 0;
iVar14 = 0;
iVar15 = 0;
piVar6 = piVar8;
do {
iVar2 = *piVar6;
piVar3 = piVar6 + 1;
piVar4 = piVar6 + 2;
piVar5 = piVar6 + 3;
piVar6 = piVar6 + 4;
iVar12 = iVar12 + iVar2;
iVar13 = iVar13 + *piVar3;
iVar14 = iVar14 + *piVar4;
iVar15 = iVar15 + *piVar5;
} while (piVar8 + (uVar9 & 0xfffffffffffffffc) != piVar6);
iVar12 = iVar12 + iVar14 + iVar13 + iVar15;
if ((uVar9 & 3) != 0) {
piVar8 = piVar8 + (uVar9 & 0xfffffffffffffffc);
goto LAB_00101af5;
}
}
iVar11 = iVar11 + iVar12;
}
puVar10 = puVar10 + 3;
} while( true );
} |
2,456 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<std::vector<int>>& nums) {
int tupleSize = nums.size();
int elementCount = nums[0].size();
std::vector<double> result(elementCount, 0.0);
for (int i = 0; i < elementCount; ++i) {
double sum = 0;
for (int j = 0; j < tupleSize; ++j) {
sum += nums[j][i];
}
result[i] = sum / tupleSize;
}
return result;
}
| int main() {
assert(func0({{10, 10, 10, 12}, {30, 45, 56, 45}, {81, 80, 39, 32}, {1, 2, 3, 4}}) == std::vector<double>({30.5, 34.25, 27.0, 23.25}));
assert(func0({{1, 1, -5}, {30, -15, 56}, {81, -60, -39}, {-10, 2, 3}}) == std::vector<double>({25.5, -18.0, 3.75}));
assert(func0({{100, 100, 100, 120}, {300, 450, 560, 450}, {810, 800, 390, 320}, {10, 20, 30, 40}}) == std::vector<double>({305.0, 342.5, 270.0, 232.5}));
std::cout << "All tests passed!" << std::endl;
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
push %rbx
sub $0x58,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 247e <_ZNKSt6vectorIS_IiSaIiEESaIS1_EE4sizeEv>
mov %eax,-0x30(%rbp)
mov -0x50(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 24b6 <_ZNKSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdi
callq 24e4 <_ZNKSt6vectorIiSaIiEE4sizeEv>
mov %eax,-0x2c(%rbp)
lea -0x39(%rbp),%rax
mov %rax,%rdi
callq 250c <_ZNSaIdEC1Ev>
pxor %xmm0,%xmm0
movsd %xmm0,-0x28(%rbp)
mov -0x2c(%rbp),%eax
movslq %eax,%rsi
lea -0x39(%rbp),%rcx
lea -0x28(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 254c <_ZNSt6vectorIdSaIdEEC1EmRKdRKS0_>
lea -0x39(%rbp),%rax
mov %rax,%rdi
callq 252c <_ZNSaIdED1Ev>
movl $0x0,-0x38(%rbp)
mov -0x38(%rbp),%eax
cmp -0x2c(%rbp),%eax
jge 1458 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x14f>
pxor %xmm0,%xmm0
movsd %xmm0,-0x20(%rbp)
movl $0x0,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x30(%rbp),%eax
jge 1400 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xf7>
mov -0x34(%rbp),%eax
movslq %eax,%rdx
mov -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 24b6 <_ZNKSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x38(%rbp),%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 261c <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
cvtsi2sd %eax,%xmm0
movsd -0x20(%rbp),%xmm1
addsd %xmm1,%xmm0
movsd %xmm0,-0x20(%rbp)
addl $0x1,-0x34(%rbp)
jmp 13b6 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xad>
cvtsi2sdl -0x30(%rbp),%xmm1
movsd -0x20(%rbp),%xmm0
divsd %xmm1,%xmm0
movsd %xmm0,-0x58(%rbp)
mov -0x38(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2640 <_ZNSt6vectorIdSaIdEEixEm>
movsd -0x58(%rbp),%xmm0
movsd %xmm0,(%rax)
addl $0x1,-0x38(%rbp)
jmpq 139a <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x91>
endbr64
mov %rax,%rbx
lea -0x39(%rbp),%rax
mov %rax,%rdi
callq 252c <_ZNSaIdED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1210 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 146d <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x164>
callq 11c0 <__stack_chk_fail@plt>
mov -0x48(%rbp),%rax
add $0x58,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_60]
mov rdi, rax
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EE4sizeEv; std::vector<std::vector<int>>::size(void)
mov [rbp+var_38], eax
mov rax, [rbp+var_60]
mov esi, 0
mov rdi, rax
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov [rbp+var_34], eax
lea rax, [rbp+var_41]
mov [rbp+var_20], rax
nop
nop
pxor xmm0, xmm0
movsd [rbp+var_30], xmm0
mov eax, [rbp+var_34]
movsxd rsi, eax
lea rcx, [rbp+var_41]
lea rdx, [rbp+var_30]
mov rax, [rbp+var_58]
mov rdi, rax
call _ZNSt6vectorIdSaIdEEC2EmRKdRKS0_; std::vector<double>::vector(ulong,double const&,std::allocator<double> const&)
lea rax, [rbp+var_41]
mov rdi, rax
call _ZNSt15__new_allocatorIdED2Ev; std::__new_allocator<double>::~__new_allocator()
nop
mov [rbp+var_40], 0
jmp loc_1415
loc_137E:
pxor xmm0, xmm0
movsd [rbp+var_28], xmm0
mov [rbp+var_3C], 0
jmp short loc_13D4
loc_1390:
mov eax, [rbp+var_3C]
movsxd rdx, eax
mov rax, [rbp+var_60]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_40]
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
movsd xmm1, [rbp+var_28]
addsd xmm0, xmm1
movsd [rbp+var_28], xmm0
add [rbp+var_3C], 1
loc_13D4:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_38]
jl short loc_1390
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_38]
movsd xmm0, [rbp+var_28]
divsd xmm0, xmm1
movsd [rbp+var_68], xmm0
mov eax, [rbp+var_40]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, [rbp+var_68]
movsd qword ptr [rax], xmm0
add [rbp+var_40], 1
loc_1415:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_34]
jl loc_137E
jmp short loc_1456
endbr64
mov rbx, rax
lea rax, [rbp+var_41]
mov rdi, rax
call _ZNSt15__new_allocatorIdED2Ev; std::__new_allocator<double>::~__new_allocator()
nop
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_144E
call ___stack_chk_fail
loc_144E:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1456:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_146A
call ___stack_chk_fail
loc_146A:
mov rax, [rbp+var_58]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
int *v4; // rax
double v6; // [rsp+8h] [rbp-68h]
char v7; // [rsp+2Fh] [rbp-41h] BYREF
int i; // [rsp+30h] [rbp-40h]
int j; // [rsp+34h] [rbp-3Ch]
int v10; // [rsp+38h] [rbp-38h]
int v11; // [rsp+3Ch] [rbp-34h]
long long v12; // [rsp+40h] [rbp-30h] BYREF
double v13; // [rsp+48h] [rbp-28h]
char *v14; // [rsp+50h] [rbp-20h]
unsigned long long v15; // [rsp+58h] [rbp-18h]
v15 = __readfsqword(0x28u);
v10 = std::vector<std::vector<int>>::size(a2);
v2 = std::vector<std::vector<int>>::operator[](a2, 0LL);
v11 = std::vector<int>::size(v2);
v14 = &v7;
v12 = 0LL;
std::vector<double>::vector(a1, v11, &v12, &v7);
std::__new_allocator<double>::~__new_allocator(&v7);
for ( i = 0; i < v11; ++i )
{
v13 = 0.0;
for ( j = 0; j < v10; ++j )
{
v3 = std::vector<std::vector<int>>::operator[](a2, j);
v4 = (int *)std::vector<int>::operator[](v3, i);
v13 = (double)*v4 + v13;
}
v6 = v13 / (double)v10;
*(double *)std::vector<double>::operator[](a1, i) = v6;
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,RAX
CALL 0x001023da
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x0010240c
MOV RDI,RAX
CALL 0x0010243a
MOV dword ptr [RBP + -0x34],EAX
LEA RAX,[RBP + -0x41]
MOV qword ptr [RBP + -0x20],RAX
NOP
NOP
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x30],XMM0
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RSI,EAX
LEA RCX,[RBP + -0x41]
LEA RDX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
LAB_00101360:
CALL 0x00102462
LEA RAX,[RBP + -0x41]
MOV RDI,RAX
CALL 0x0010296a
NOP
MOV dword ptr [RBP + -0x40],0x0
JMP 0x00101415
LAB_0010137e:
PXOR XMM0,XMM0
MOVSD qword ptr [RBP + -0x28],XMM0
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x001013d4
LAB_00101390:
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010240c
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x40]
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00102542
MOV EAX,dword ptr [RAX]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD XMM1,qword ptr [RBP + -0x28]
ADDSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x28],XMM0
ADD dword ptr [RBP + -0x3c],0x1
LAB_001013d4:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x38]
JL 0x00101390
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x38]
MOVSD XMM0,qword ptr [RBP + -0x28]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x68],XMM0
MOV EAX,dword ptr [RBP + -0x40]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102566
MOVSD XMM0,qword ptr [RBP + -0x68]
MOVSD qword ptr [RAX],XMM0
ADD dword ptr [RBP + -0x40],0x1
LAB_00101415:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x34]
JL 0x0010137e
JMP 0x00101456
LAB_00101456:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010146a
CALL 0x001011b0
LAB_0010146a:
MOV RAX,qword ptr [RBP + -0x58]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
vector<int,std::allocator<int>> *pvVar1;
int *piVar2;
double *pdVar3;
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*in_RSI;
long in_FS_OFFSET;
double dVar4;
allocator local_49;
int local_48;
int local_44;
int local_40;
int local_3c;
double local_38;
double local_30;
allocator *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::size(in_RSI);
pvVar1 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](in_RSI,0);
local_3c = std::vector<int,std::allocator<int>>::size(pvVar1);
local_28 = &local_49;
local_38 = 0.0;
/* try { // try from 00101360 to 00101364 has its CatchHandler @ 00101423 */
std::vector<double,std::allocator<double>>::vector
((vector<double,std::allocator<double>> *)param_1,(long)local_3c,&local_38,&local_49);
std::__new_allocator<double>::~__new_allocator((__new_allocator<double> *)&local_49);
for (local_48 = 0; local_48 < local_3c; local_48 = local_48 + 1) {
local_30 = 0.0;
for (local_44 = 0; local_44 < local_40; local_44 = local_44 + 1) {
pvVar1 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](in_RSI,(long)local_44);
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar1,(long)local_48);
local_30 = (double)*piVar2 + local_30;
}
dVar4 = local_30 / (double)local_40;
pdVar3 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)param_1,(long)local_48);
*pdVar3 = dVar4;
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,457 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<std::vector<int>>& nums) {
int tupleSize = nums.size();
int elementCount = nums[0].size();
std::vector<double> result(elementCount, 0.0);
for (int i = 0; i < elementCount; ++i) {
double sum = 0;
for (int j = 0; j < tupleSize; ++j) {
sum += nums[j][i];
}
result[i] = sum / tupleSize;
}
return result;
}
| int main() {
assert(func0({{10, 10, 10, 12}, {30, 45, 56, 45}, {81, 80, 39, 32}, {1, 2, 3, 4}}) == std::vector<double>({30.5, 34.25, 27.0, 23.25}));
assert(func0({{1, 1, -5}, {30, -15, 56}, {81, -60, -39}, {-10, 2, 3}}) == std::vector<double>({25.5, -18.0, 3.75}));
assert(func0({{100, 100, 100, 120}, {300, 450, 560, 450}, {810, 800, 390, 320}, {10, 20, 30, 40}}) == std::vector<double>({305.0, 342.5, 270.0, 232.5}));
std::cout << "All tests passed!" << std::endl;
return 0;
}
| 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 $0x8,%rsp
mov (%rsi),%rax
mov 0x8(%rsi),%r14
sub %rax,%r14
sar $0x3,%r14
movabs $0xaaaaaaaaaaaaaaab,%rdx
imul %rdx,%r14
mov 0x8(%rax),%r15
sub (%rax),%r15
sar $0x2,%r15
movslq %r15d,%r13
movabs $0xfffffffffffffff,%rax
cmp %rax,%r13
ja 13ef <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xc6>
mov %rdi,%rbx
mov %rsi,%r12
mov %r14d,%ebp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
test %r13,%r13
je 1448 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x11f>
shl $0x3,%r13
mov %r13,%rdi
callq 11c0 <_Znwm@plt>
mov %rax,(%rbx)
add %rax,%r13
mov %r13,0x10(%rbx)
movq $0x0,(%rax)
add $0x8,%rax
cmp %rax,%r13
jne 13b3 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x8a>
mov %r13,0x8(%rbx)
test %r15d,%r15d
jle 145f <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x136>
lea -0x1(%r15),%eax
lea 0x4(,%rax,4),%r8
lea -0x1(%r14),%eax
lea (%rax,%rax,2),%rdi
shl $0x3,%rdi
mov $0x0,%ecx
jmp 141c <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xf3>
lea 0x1c12(%rip),%rdi
callq 1170 <_ZSt20__throw_length_errorPKc@plt>
pxor %xmm0,%xmm0
mov (%rbx),%rax
pxor %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,(%rax,%rcx,2)
add $0x4,%rcx
cmp %r8,%rcx
je 145f <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x136>
test %ebp,%ebp
jle 13fb <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xd2>
mov (%r12),%rax
lea 0x18(%rdi,%rax,1),%rsi
pxor %xmm0,%xmm0
mov (%rax),%rdx
pxor %xmm1,%xmm1
cvtsi2sdl (%rdx,%rcx,1),%xmm1
addsd %xmm1,%xmm0
add $0x18,%rax
cmp %rax,%rsi
jne 142d <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x104>
jmp 13ff <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xd6>
movq $0x0,(%rdi)
movq $0x0,0x10(%rdi)
movq $0x0,0x8(%rdi)
mov %rbx,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rax, [rsi]
mov r14, [rsi+8]
sub r14, rax
sar r14, 3
mov rdx, 0AAAAAAAAAAAAAAABh
imul r14, rdx
mov r15, [rax+8]
sub r15, [rax]
sar r15, 2
movsxd r13, r15d
mov rax, r13
shr rax, 3Ch
jnz short loc_13A0
mov rbx, rdi
mov r12, rsi
mov ebp, r14d
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
test r13, r13
jz loc_13F9
shl r13, 3
mov rdi, r13; unsigned __int64
call __Znwm; operator new(ulong)
mov [rbx], rax
add r13, rax
mov [rbx+10h], r13
loc_136D:
mov qword ptr [rax], 0
add rax, 8
cmp rax, r13
jnz short loc_136D
mov [rbx+8], r13
lea eax, [r15-1]
lea r8, ds:4[rax*4]
lea eax, [r14-1]
lea rdi, [rax+rax*2]
shl rdi, 3
mov ecx, 0
jmp short loc_13EF
loc_13A0:
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_13AC:
mov rax, [r12]
lea rsi, [rax+rdi+18h]
pxor xmm0, xmm0
loc_13B9:
mov rdx, [rax]
pxor xmm1, xmm1
cvtsi2sd xmm1, dword ptr [rdx+rcx]
addsd xmm0, xmm1
add rax, 18h
cmp rax, rsi
jnz short loc_13B9
loc_13D2:
mov rax, [rbx]
pxor xmm1, xmm1
cvtsi2sd xmm1, ebp
divsd xmm0, xmm1
movsd qword ptr [rax+rcx*2], xmm0
add rcx, 4
cmp rcx, r8
jz short loc_1410
loc_13EF:
pxor xmm0, xmm0
test ebp, ebp
jg short loc_13AC
jmp short loc_13D2
loc_13F9:
mov qword ptr [rdi], 0
mov qword ptr [rdi+10h], 0
mov qword ptr [rdi+8], 0
loc_1410:
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
unsigned long long v2; // r14
long long v3; // r15
_QWORD *v4; // rax
_QWORD *v5; // r13
long long v6; // rcx
_QWORD *v7; // rax
double v8; // xmm0_8
v2 = 0xAAAAAAAAAAAAAAABLL * ((long long)(a2[1] - *a2) >> 3);
v3 = (long long)(*(_QWORD *)(*a2 + 8LL) - *(_QWORD *)*a2) >> 2;
if ( (unsigned long long)(int)v3 >> 60 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
if ( (_DWORD)v3 )
{
v4 = (_QWORD *)operator new(8LL * (int)v3);
*a1 = v4;
v5 = &v4[(int)v3];
a1[2] = v5;
do
*v4++ = 0LL;
while ( v4 != v5 );
a1[1] = v5;
v6 = 0LL;
do
{
v8 = 0.0;
if ( (int)v2 > 0 )
{
v7 = (_QWORD *)*a2;
v8 = 0.0;
do
{
v8 = v8 + (double)*(int *)(*v7 + v6);
v7 += 3;
}
while ( v7 != (_QWORD *)(*a2 + 24LL * (unsigned int)(v2 - 1) + 24) );
}
*(double *)(*a1 + 2 * v6) = v8 / (double)(int)v2;
v6 += 4LL;
}
while ( v6 != 4LL * (unsigned int)(v3 - 1) + 4 );
}
else
{
*a1 = 0LL;
a1[2] = 0LL;
a1[1] = 0LL;
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RAX,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
SUB R14,RAX
SAR R14,0x3
MOV RDX,-0x5555555555555555
IMUL R14,RDX
MOV R15,qword ptr [RAX + 0x8]
SUB R15,qword ptr [RAX]
SAR R15,0x2
MOVSXD R13,R15D
MOV RAX,R13
SHR RAX,0x3c
JNZ 0x001013a0
MOV RBX,RDI
MOV R12,RSI
MOV EBP,R14D
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
TEST R13,R13
JZ 0x001013f9
SHL R13,0x3
MOV RDI,R13
CALL 0x00101190
MOV qword ptr [RBX],RAX
ADD R13,RAX
MOV qword ptr [RBX + 0x10],R13
LAB_0010136d:
MOV qword ptr [RAX],0x0
ADD RAX,0x8
CMP RAX,R13
JNZ 0x0010136d
MOV qword ptr [RBX + 0x8],R13
LEA EAX,[R15 + -0x1]
LEA R8,[0x4 + RAX*0x4]
LEA EAX,[R14 + -0x1]
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x3
MOV ECX,0x0
JMP 0x001013ef
LAB_001013a0:
LEA RDI,[0x103008]
CALL 0x00101140
LAB_001013ac:
MOV RAX,qword ptr [R12]
LEA RSI,[RAX + RDI*0x1 + 0x18]
PXOR XMM0,XMM0
LAB_001013b9:
MOV RDX,qword ptr [RAX]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RDX + RCX*0x1]
ADDSD XMM0,XMM1
ADD RAX,0x18
CMP RAX,RSI
JNZ 0x001013b9
LAB_001013d2:
MOV RAX,qword ptr [RBX]
PXOR XMM1,XMM1
CVTSI2SD XMM1,EBP
DIVSD XMM0,XMM1
MOVSD qword ptr [RAX + RCX*0x2],XMM0
ADD RCX,0x4
CMP RCX,R8
JZ 0x00101410
LAB_001013ef:
PXOR XMM0,XMM0
TEST EBP,EBP
JG 0x001013ac
JMP 0x001013d2
LAB_001013f9:
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x8],0x0
LAB_00101410:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
long *plVar1;
int8 *puVar2;
long *plVar3;
long in_RCX;
vector *unaff_RBX;
ulong unaff_RBP;
long *in_RSI;
char *pcVar4;
long in_R8;
long *unaff_R12;
ulong uVar5;
int8 *puVar6;
ulong uVar7;
int iVar8;
double dVar9;
plVar1 = (long *)*in_RSI;
uVar7 = (in_RSI[1] - (long)plVar1 >> 3) * -0x5555555555555555;
iVar8 = (int)(plVar1[1] - *plVar1 >> 2);
uVar5 = (ulong)iVar8;
if (uVar5 >> 0x3c != 0) {
pcVar4 = "cannot create std::vector larger than max_size()";
std::__throw_length_error("cannot create std::vector larger than max_size()");
goto LAB_001013ac;
}
unaff_RBP = uVar7 & 0xffffffff;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
if (uVar5 == 0) {
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 8) = 0;
return param_1;
}
puVar2 = (int8 *)operator_new(uVar5 * 8);
*(int8 **)param_1 = puVar2;
puVar6 = puVar2 + uVar5;
*(int8 **)(param_1 + 0x10) = puVar6;
do {
*puVar2 = 0;
puVar2 = puVar2 + 1;
} while (puVar2 != puVar6);
*(int8 **)(param_1 + 8) = puVar6;
in_R8 = (ulong)(iVar8 - 1) * 4 + 4;
pcVar4 = (char *)((ulong)((int)uVar7 - 1) * 0x18);
in_RCX = 0;
do {
dVar9 = 0.0;
unaff_RBX = param_1;
unaff_R12 = in_RSI;
if (0 < (int)unaff_RBP) {
LAB_001013ac:
plVar3 = (long *)*unaff_R12;
plVar1 = (long *)((long)plVar3 + (long)(pcVar4 + 0x18));
dVar9 = 0.0;
do {
dVar9 = dVar9 + (double)*(int *)(*plVar3 + in_RCX);
plVar3 = plVar3 + 3;
param_1 = unaff_RBX;
in_RSI = unaff_R12;
} while (plVar3 != plVar1);
}
*(double *)(*(long *)param_1 + in_RCX * 2) = dVar9 / (double)(int)unaff_RBP;
in_RCX = in_RCX + 4;
} while (in_RCX != in_R8);
return param_1;
} |
2,458 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<std::vector<int>>& nums) {
int tupleSize = nums.size();
int elementCount = nums[0].size();
std::vector<double> result(elementCount, 0.0);
for (int i = 0; i < elementCount; ++i) {
double sum = 0;
for (int j = 0; j < tupleSize; ++j) {
sum += nums[j][i];
}
result[i] = sum / tupleSize;
}
return result;
}
| int main() {
assert(func0({{10, 10, 10, 12}, {30, 45, 56, 45}, {81, 80, 39, 32}, {1, 2, 3, 4}}) == std::vector<double>({30.5, 34.25, 27.0, 23.25}));
assert(func0({{1, 1, -5}, {30, -15, 56}, {81, -60, -39}, {-10, 2, 3}}) == std::vector<double>({25.5, -18.0, 3.75}));
assert(func0({{100, 100, 100, 120}, {300, 450, 560, 450}, {810, 800, 390, 320}, {10, 20, 30, 40}}) == std::vector<double>({305.0, 342.5, 270.0, 232.5}));
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
movabs $0xaaaaaaaaaaaaaaab,%rdx
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov (%rsi),%rax
mov 0x8(%rsi),%r14
mov 0x8(%rax),%r15
sub %rax,%r14
sub (%rax),%r15
sar $0x3,%r14
sar $0x2,%r15
imul %rdx,%r14
movslq %r15d,%rax
movabs $0xfffffffffffffff,%rdx
cmp %rdx,%rax
ja 1cf6 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x146>
movq $0x0,(%rdi)
mov %rdi,%r12
lea 0x0(,%rax,8),%rbx
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
test %rax,%rax
je 1cde <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x12e>
mov %rbx,%rdi
mov %rsi,%rbp
mov %r14d,%r13d
callq 11c0 <_Znwm@plt>
lea (%rax,%rbx,1),%rcx
mov %rax,(%r12)
mov %rax,%rdx
mov %rcx,0x10(%r12)
nopl 0x0(%rax,%rax,1)
movq $0x0,(%rdx)
add $0x8,%rdx
cmp %rcx,%rdx
jne 1c50 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xa0>
mov %rdx,0x8(%r12)
test %r15d,%r15d
jle 1cde <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x12e>
pxor %xmm3,%xmm3
lea -0x1(%r15),%edx
pxor %xmm2,%xmm2
xor %edi,%edi
cvtsi2sd %r14d,%xmm3
lea 0x4(,%rdx,4),%r9
lea -0x1(%r14),%edx
lea (%rdx,%rdx,2),%rsi
shl $0x3,%rsi
nopl 0x0(%rax)
test %r13d,%r13d
jle 1cf0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x140>
mov 0x0(%rbp),%rcx
movapd %xmm2,%xmm0
lea 0x18(%rcx),%rdx
lea (%rdx,%rsi,1),%r8
jmp 1cb4 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x104>
add $0x18,%rdx
mov (%rcx),%rcx
pxor %xmm1,%xmm1
cvtsi2sdl (%rcx,%rdi,1),%xmm1
mov %rdx,%rcx
addsd %xmm1,%xmm0
cmp %r8,%rdx
jne 1cb0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x100>
divsd %xmm3,%xmm0
movsd %xmm0,(%rax,%rdi,2)
add $0x4,%rdi
cmp %rdi,%r9
jne 1c98 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xe8>
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movapd %xmm2,%xmm0
jmp 1ccc <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x11c>
lea 0x130b(%rip),%rdi
callq 1170 <_ZSt20__throw_length_errorPKc@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov r15, [rsi]
mov r14, [rsi+8]
mov rax, [r15+8]
sub rax, [r15]
sar rax, 2
mov ebx, eax
cdqe
mov rdi, rax
shr rdi, 3Ch
jnz loc_1D56
pxor xmm0, xmm0
mov qword ptr [rbp+10h], 0
movups xmmword ptr [rbp+0], xmm0
test rax, rax
jz loc_1D4C
lea r12, ds:0[rax*8]
mov r13, rsi
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, r12; n
xor esi, esi; c
lea rcx, [rax+r12]
mov [rbp+0], rax
mov rdi, rax; s
mov [rbp+10h], rcx
mov [rsp+48h+var_40], rcx
call _memset
mov rcx, [rsp+48h+var_40]
pxor xmm2, xmm2
xor edi, edi
mov r9, rax
mov rax, r14
pxor xmm1, xmm1
mov rdx, 0AAAAAAAAAAAAAAABh
sub rax, r15
mov [rbp+8], rcx
sar rax, 3
imul rax, rdx
cvtsi2sd xmm2, eax
mov edx, eax
sub eax, 1
lea r10, [rax+rax*2]
shl r10, 3
loc_1CC1:
test edx, edx
jle short loc_1D30
mov r8, [r13+0]
nop dword ptr [rax+00000000h]
loc_1CD0:
lea rax, [r8+18h]
lea rsi, ds:0[rdi*4]
pxor xmm0, xmm0
mov rdx, r8
lea rcx, [rax+r10]
jmp short loc_1CF4
loc_1CF0:
add rax, 18h
loc_1CF4:
mov rdx, [rdx]
pxor xmm1, xmm1
cvtsi2sd xmm1, dword ptr [rdx+rsi]
mov rdx, rax
addsd xmm0, xmm1
cmp rax, rcx
jnz short loc_1CF0
divsd xmm0, xmm2
movsd qword ptr [r9+rdi*8], xmm0
add rdi, 1
cmp ebx, edi
jg short loc_1CD0
loc_1D1E:
add rsp, 18h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1D30:
movapd xmm0, xmm1
divsd xmm0, xmm2
movsd qword ptr [r9+rdi*8], xmm0
add rdi, 1
cmp ebx, edi
jg loc_1CC1
jmp short loc_1D1E
loc_1D4C:
mov qword ptr [rbp+10h], 0
jmp short loc_1D1E
loc_1D56:
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*) | long long func0(long long a1, _QWORD *a2)
{
long long v3; // r15
long long v4; // r14
int v5; // ebx
unsigned long long v6; // r12
char *v7; // rax
long long v8; // rdi
double *v9; // r9
int v10; // eax
double v11; // xmm2_8
long long v12; // r10
_QWORD *v13; // r8
_QWORD *v14; // rax
double v15; // xmm0_8
_QWORD *v16; // rdx
double v17; // xmm1_8
char *v19; // [rsp+8h] [rbp-40h]
v3 = *a2;
v4 = a2[1];
v5 = (long long)(*(_QWORD *)(*a2 + 8LL) - *(_QWORD *)*a2) >> 2;
if ( (unsigned long long)v5 >> 60 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
if ( v5 )
{
v6 = 8LL * v5;
v7 = (char *)operator new(v6);
*(_QWORD *)a1 = v7;
*(_QWORD *)(a1 + 16) = &v7[v6];
v19 = &v7[v6];
v8 = 0LL;
v9 = (double *)memset(v7, 0, v6);
*(_QWORD *)(a1 + 8) = v19;
v10 = -1431655765 * ((v4 - v3) >> 3);
v11 = (double)v10;
v12 = 3LL * (unsigned int)(v10 - 1);
while ( (int)(-1431655765 * ((v4 - v3) >> 3)) <= 0 )
{
v9[v8++] = 0.0 / v11;
if ( v5 <= (int)v8 )
return a1;
}
v13 = (_QWORD *)*a2;
do
{
v14 = v13 + 3;
v15 = 0.0;
v16 = v13;
while ( 1 )
{
v17 = (double)*(int *)(*v16 + 4 * v8);
v16 = v14;
v15 = v15 + v17;
if ( v14 == &v13[v12 + 3] )
break;
v14 += 3;
}
v9[v8++] = v15 / v11;
}
while ( v5 > (int)v8 );
}
else
{
*(_QWORD *)(a1 + 16) = 0LL;
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV R15,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [R15 + 0x8]
SUB RAX,qword ptr [R15]
SAR RAX,0x2
MOV EBX,EAX
CDQE
MOV RDI,RAX
SHR RDI,0x3c
JNZ 0x00101d56
PXOR XMM0,XMM0
MOV qword ptr [RBP + 0x10],0x0
MOVUPS xmmword ptr [RBP],XMM0
TEST RAX,RAX
JZ 0x00101d4c
LEA R12,[RAX*0x8]
MOV R13,RSI
MOV RDI,R12
CALL 0x00101210
MOV RDX,R12
XOR ESI,ESI
LEA RCX,[RAX + R12*0x1]
MOV qword ptr [RBP],RAX
MOV RDI,RAX
MOV qword ptr [RBP + 0x10],RCX
MOV qword ptr [RSP + 0x8],RCX
CALL 0x001011b0
MOV RCX,qword ptr [RSP + 0x8]
PXOR XMM2,XMM2
XOR EDI,EDI
MOV R9,RAX
MOV RAX,R14
PXOR XMM1,XMM1
MOV RDX,-0x5555555555555555
SUB RAX,R15
MOV qword ptr [RBP + 0x8],RCX
SAR RAX,0x3
IMUL RAX,RDX
CVTSI2SD XMM2,EAX
MOV EDX,EAX
SUB EAX,0x1
LEA R10,[RAX + RAX*0x2]
SHL R10,0x3
LAB_00101cc1:
TEST EDX,EDX
JLE 0x00101d30
MOV R8,qword ptr [R13]
NOP dword ptr [RAX]
LAB_00101cd0:
LEA RAX,[R8 + 0x18]
LEA RSI,[RDI*0x4]
PXOR XMM0,XMM0
MOV RDX,R8
LEA RCX,[RAX + R10*0x1]
JMP 0x00101cf4
LAB_00101cf0:
ADD RAX,0x18
LAB_00101cf4:
MOV RDX,qword ptr [RDX]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RDX + RSI*0x1]
MOV RDX,RAX
ADDSD XMM0,XMM1
CMP RAX,RCX
JNZ 0x00101cf0
DIVSD XMM0,XMM2
MOVSD qword ptr [R9 + RDI*0x8],XMM0
ADD RDI,0x1
CMP EBX,EDI
JG 0x00101cd0
LAB_00101d1e:
ADD RSP,0x18
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101d30:
MOVAPD XMM0,XMM1
DIVSD XMM0,XMM2
MOVSD qword ptr [R9 + RDI*0x8],XMM0
ADD RDI,0x1
CMP EBX,EDI
JG 0x00101cc1
JMP 0x00101d1e
LAB_00101d4c:
MOV qword ptr [RBP + 0x10],0x0
JMP 0x00101d1e
LAB_00101d56:
LEA RDI,[0x103008]
CALL 0x001011a0
NOP word ptr CS:[RAX + RAX*0x1]
NOP dword ptr [RAX] | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
long *plVar1;
long *plVar2;
long lVar3;
long *plVar4;
int iVar5;
int iVar6;
ulong uVar7;
void *__s;
void *pvVar8;
long *plVar9;
long *plVar10;
long *in_RSI;
long lVar11;
double dVar12;
plVar2 = (long *)*in_RSI;
lVar3 = in_RSI[1];
iVar5 = (int)(plVar2[1] - *plVar2 >> 2);
uVar7 = (ulong)iVar5;
if (uVar7 >> 0x3c != 0) {
std::__throw_length_error("cannot create std::vector larger than max_size()");
return (vector *)((ulong)in_RSI & 0xffffffff);
}
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
if (uVar7 == 0) {
*(int8 *)(param_1 + 0x10) = 0;
}
else {
uVar7 = uVar7 * 8;
__s = operator_new(uVar7);
*(void **)param_1 = __s;
*(void **)(param_1 + 0x10) = (void *)((long)__s + uVar7);
pvVar8 = memset(__s,0,uVar7);
lVar11 = 0;
*(void **)(param_1 + 8) = (void *)((long)__s + uVar7);
iVar6 = (int)(lVar3 - (long)plVar2 >> 3) * -0x55555555;
do {
if (0 < iVar6) {
plVar2 = (long *)*in_RSI;
do {
plVar1 = plVar2 + 3;
dVar12 = 0.0;
plVar4 = plVar1;
plVar10 = plVar2;
while (plVar9 = plVar4, dVar12 = dVar12 + (double)*(int *)(*plVar10 + lVar11 * 4),
plVar9 != plVar1 + (ulong)(iVar6 - 1) * 3) {
plVar10 = plVar9;
plVar4 = plVar9 + 3;
}
*(double *)((long)pvVar8 + lVar11 * 8) = dVar12 / (double)iVar6;
lVar11 = lVar11 + 1;
} while ((int)lVar11 < iVar5);
return param_1;
}
*(double *)((long)pvVar8 + lVar11 * 8) = 0.0 / (double)iVar6;
lVar11 = lVar11 + 1;
} while ((int)lVar11 < iVar5);
}
return param_1;
} |
2,459 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<std::vector<int>>& nums) {
int tupleSize = nums.size();
int elementCount = nums[0].size();
std::vector<double> result(elementCount, 0.0);
for (int i = 0; i < elementCount; ++i) {
double sum = 0;
for (int j = 0; j < tupleSize; ++j) {
sum += nums[j][i];
}
result[i] = sum / tupleSize;
}
return result;
}
| int main() {
assert(func0({{10, 10, 10, 12}, {30, 45, 56, 45}, {81, 80, 39, 32}, {1, 2, 3, 4}}) == std::vector<double>({30.5, 34.25, 27.0, 23.25}));
assert(func0({{1, 1, -5}, {30, -15, 56}, {81, -60, -39}, {-10, 2, 3}}) == std::vector<double>({25.5, -18.0, 3.75}));
assert(func0({{100, 100, 100, 120}, {300, 450, 560, 450}, {810, 800, 390, 320}, {10, 20, 30, 40}}) == std::vector<double>({305.0, 342.5, 270.0, 232.5}));
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
movabs $0xaaaaaaaaaaaaaaab,%rdx
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov (%rsi),%rax
mov 0x8(%rsi),%r13
mov 0x8(%rax),%r14
sub %rax,%r13
sub (%rax),%r14
sar $0x3,%r13
sar $0x2,%r14
imul %rdx,%r13
movslq %r14d,%rax
movabs $0xfffffffffffffff,%rdx
cmp %rdx,%rax
ja 1c66 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x146>
pxor %xmm0,%xmm0
movq $0x0,0x10(%rdi)
mov %rdi,%r12
lea 0x0(,%rax,8),%r15
movups %xmm0,(%rdi)
test %rax,%rax
je 1c46 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x126>
mov %r15,%rdi
mov %rsi,%rbx
callq 11e0 <_Znwm@plt>
mov %r15,%rdx
xor %esi,%esi
lea (%rax,%r15,1),%rcx
mov %rax,(%r12)
mov %rax,%rdi
mov %rcx,0x10(%r12)
mov %rcx,0x8(%rsp)
callq 1190 <memset@plt>
mov 0x8(%rsp),%rcx
mov %rax,%rdi
mov %rcx,0x8(%r12)
test %r14d,%r14d
jle 1c46 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x126>
pxor %xmm3,%xmm3
lea -0x1(%r14),%eax
mov %r13d,%ebp
xor %ecx,%ecx
cvtsi2sd %r13d,%xmm3
lea 0x4(,%rax,4),%r9
pxor %xmm2,%xmm2
lea -0x1(%r13),%eax
lea (%rax,%rax,2),%r8
shl $0x3,%r8
nopl 0x0(%rax,%rax,1)
test %ebp,%ebp
jle 1c60 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x140>
mov (%rbx),%rdx
movapd %xmm2,%xmm0
lea 0x18(%rdx),%rax
lea (%rax,%r8,1),%rsi
jmp 1c1c <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xfc>
nopl (%rax)
add $0x18,%rax
mov (%rdx),%rdx
pxor %xmm1,%xmm1
cvtsi2sdl (%rdx,%rcx,1),%xmm1
mov %rax,%rdx
addsd %xmm1,%xmm0
cmp %rax,%rsi
jne 1c18 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xf8>
divsd %xmm3,%xmm0
movsd %xmm0,(%rdi,%rcx,2)
add $0x4,%rcx
cmp %rcx,%r9
jne 1c00 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0xe0>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
movapd %xmm2,%xmm0
jmp 1c34 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE+0x114>
lea 0x139b(%rip),%rdi
callq 1180 <_ZSt20__throw_length_errorPKc@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov r15, [rsi]
mov r14, [rsi+8]
mov rax, [r15+8]
sub rax, [r15]
sar rax, 2
mov ebx, eax
cdqe
mov rdi, rax
shr rdi, 3Ch
jnz loc_1D36
pxor xmm0, xmm0
mov qword ptr [rbp+10h], 0
movups xmmword ptr [rbp+0], xmm0
test rax, rax
jz loc_1D2C
lea r12, ds:0[rax*8]
mov r13, rsi
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, r12; n
xor esi, esi; c
lea rcx, [rax+r12]
mov [rbp+0], rax
mov rdi, rax; s
mov [rbp+10h], rcx
mov [rsp+48h+var_40], rcx
call _memset
mov rcx, [rsp+48h+var_40]
pxor xmm2, xmm2
xor edi, edi
mov r9, rax
mov rax, r14
pxor xmm1, xmm1
mov rdx, 0AAAAAAAAAAAAAAABh
sub rax, r15
mov [rbp+8], rcx
sar rax, 3
imul rax, rdx
cvtsi2sd xmm2, eax
mov edx, eax
sub eax, 1
lea r10, [rax+rax*2]
shl r10, 3
loc_1CA1:
test edx, edx
jle short loc_1D10
mov r8, [r13+0]
nop dword ptr [rax+00000000h]
loc_1CB0:
lea rax, [r8+18h]
lea rsi, ds:0[rdi*4]
pxor xmm0, xmm0
mov rdx, r8
lea rcx, [rax+r10]
jmp short loc_1CD4
loc_1CD0:
add rax, 18h
loc_1CD4:
mov rdx, [rdx]
pxor xmm1, xmm1
cvtsi2sd xmm1, dword ptr [rdx+rsi]
mov rdx, rax
addsd xmm0, xmm1
cmp rax, rcx
jnz short loc_1CD0
divsd xmm0, xmm2
movsd qword ptr [r9+rdi*8], xmm0
add rdi, 1
cmp ebx, edi
jg short loc_1CB0
loc_1CFE:
add rsp, 18h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1D10:
movapd xmm0, xmm1
divsd xmm0, xmm2
movsd qword ptr [r9+rdi*8], xmm0
add rdi, 1
cmp ebx, edi
jg loc_1CA1
jmp short loc_1CFE
loc_1D2C:
mov qword ptr [rbp+10h], 0
jmp short loc_1CFE
loc_1D36:
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*) | long long func0(long long a1, _QWORD *a2)
{
long long v3; // r15
long long v4; // r14
int v5; // ebx
unsigned long long v6; // r12
char *v7; // rax
long long v8; // rdi
double *v9; // r9
int v10; // eax
double v11; // xmm2_8
long long v12; // r10
_QWORD *v13; // r8
_QWORD *v14; // rax
double v15; // xmm0_8
_QWORD *v16; // rdx
double v17; // xmm1_8
char *v19; // [rsp+8h] [rbp-40h]
v3 = *a2;
v4 = a2[1];
v5 = (long long)(*(_QWORD *)(*a2 + 8LL) - *(_QWORD *)*a2) >> 2;
if ( (unsigned long long)v5 >> 60 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
if ( v5 )
{
v6 = 8LL * v5;
v7 = (char *)operator new(v6);
*(_QWORD *)a1 = v7;
*(_QWORD *)(a1 + 16) = &v7[v6];
v19 = &v7[v6];
v8 = 0LL;
v9 = (double *)memset(v7, 0, v6);
*(_QWORD *)(a1 + 8) = v19;
v10 = -1431655765 * ((v4 - v3) >> 3);
v11 = (double)v10;
v12 = 3LL * (unsigned int)(v10 - 1);
while ( (int)(-1431655765 * ((v4 - v3) >> 3)) <= 0 )
{
v9[v8++] = 0.0 / v11;
if ( v5 <= (int)v8 )
return a1;
}
v13 = (_QWORD *)*a2;
do
{
v14 = v13 + 3;
v15 = 0.0;
v16 = v13;
while ( 1 )
{
v17 = (double)*(int *)(*v16 + 4 * v8);
v16 = v14;
v15 = v15 + v17;
if ( v14 == &v13[v12 + 3] )
break;
v14 += 3;
}
v9[v8++] = v15 / v11;
}
while ( v5 > (int)v8 );
}
else
{
*(_QWORD *)(a1 + 16) = 0LL;
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV R15,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [R15 + 0x8]
SUB RAX,qword ptr [R15]
SAR RAX,0x2
MOV EBX,EAX
CDQE
MOV RDI,RAX
SHR RDI,0x3c
JNZ 0x00101d36
PXOR XMM0,XMM0
MOV qword ptr [RBP + 0x10],0x0
MOVUPS xmmword ptr [RBP],XMM0
TEST RAX,RAX
JZ 0x00101d2c
LEA R12,[RAX*0x8]
MOV R13,RSI
MOV RDI,R12
CALL 0x00101200
MOV RDX,R12
XOR ESI,ESI
LEA RCX,[RAX + R12*0x1]
MOV qword ptr [RBP],RAX
MOV RDI,RAX
MOV qword ptr [RBP + 0x10],RCX
MOV qword ptr [RSP + 0x8],RCX
CALL 0x001011b0
MOV RCX,qword ptr [RSP + 0x8]
PXOR XMM2,XMM2
XOR EDI,EDI
MOV R9,RAX
MOV RAX,R14
PXOR XMM1,XMM1
MOV RDX,-0x5555555555555555
SUB RAX,R15
MOV qword ptr [RBP + 0x8],RCX
SAR RAX,0x3
IMUL RAX,RDX
CVTSI2SD XMM2,EAX
MOV EDX,EAX
SUB EAX,0x1
LEA R10,[RAX + RAX*0x2]
SHL R10,0x3
LAB_00101ca1:
TEST EDX,EDX
JLE 0x00101d10
MOV R8,qword ptr [R13]
NOP dword ptr [RAX]
LAB_00101cb0:
LEA RAX,[R8 + 0x18]
LEA RSI,[RDI*0x4]
PXOR XMM0,XMM0
MOV RDX,R8
LEA RCX,[RAX + R10*0x1]
JMP 0x00101cd4
LAB_00101cd0:
ADD RAX,0x18
LAB_00101cd4:
MOV RDX,qword ptr [RDX]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RDX + RSI*0x1]
MOV RDX,RAX
ADDSD XMM0,XMM1
CMP RAX,RCX
JNZ 0x00101cd0
DIVSD XMM0,XMM2
MOVSD qword ptr [R9 + RDI*0x8],XMM0
ADD RDI,0x1
CMP EBX,EDI
JG 0x00101cb0
LAB_00101cfe:
ADD RSP,0x18
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101d10:
MOVAPD XMM0,XMM1
DIVSD XMM0,XMM2
MOVSD qword ptr [R9 + RDI*0x8],XMM0
ADD RDI,0x1
CMP EBX,EDI
JG 0x00101ca1
JMP 0x00101cfe
LAB_00101d2c:
MOV qword ptr [RBP + 0x10],0x0
JMP 0x00101cfe
LAB_00101d36:
LEA RDI,[0x103008]
CALL 0x001011a0
NOP word ptr CS:[RAX + RAX*0x1]
NOP dword ptr [RAX] | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&) */
vector * func0(vector *param_1)
{
long *plVar1;
long *plVar2;
long lVar3;
vector *pvVar4;
long *plVar5;
int iVar6;
int iVar7;
ulong uVar8;
void *__s;
void *pvVar9;
long *plVar10;
vector *extraout_RAX;
long *plVar11;
long *in_RSI;
long lVar12;
char *pcVar13;
double dVar14;
plVar2 = (long *)*in_RSI;
lVar3 = in_RSI[1];
iVar6 = (int)(plVar2[1] - *plVar2 >> 2);
uVar8 = (ulong)iVar6;
if (uVar8 >> 0x3c != 0) {
pcVar13 = "cannot create std::vector larger than max_size()";
std::__throw_length_error("cannot create std::vector larger than max_size()");
pvVar4 = *(vector **)pcVar13;
if (pvVar4 != (vector *)0x0) {
operator_delete(pvVar4,*(long *)(pcVar13 + 0x10) - (long)pvVar4);
return extraout_RAX;
}
return pvVar4;
}
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
if (uVar8 == 0) {
*(int8 *)(param_1 + 0x10) = 0;
}
else {
uVar8 = uVar8 * 8;
__s = operator_new(uVar8);
*(void **)param_1 = __s;
*(void **)(param_1 + 0x10) = (void *)((long)__s + uVar8);
pvVar9 = memset(__s,0,uVar8);
lVar12 = 0;
*(void **)(param_1 + 8) = (void *)((long)__s + uVar8);
iVar7 = (int)(lVar3 - (long)plVar2 >> 3) * -0x55555555;
do {
if (0 < iVar7) {
plVar2 = (long *)*in_RSI;
do {
plVar1 = plVar2 + 3;
dVar14 = 0.0;
plVar5 = plVar1;
plVar11 = plVar2;
while (plVar10 = plVar5, dVar14 = dVar14 + (double)*(int *)(*plVar11 + lVar12 * 4),
plVar10 != plVar1 + (ulong)(iVar7 - 1) * 3) {
plVar11 = plVar10;
plVar5 = plVar10 + 3;
}
*(double *)((long)pvVar9 + lVar12 * 8) = dVar14 / (double)iVar7;
lVar12 = lVar12 + 1;
} while ((int)lVar12 < iVar6);
return param_1;
}
*(double *)((long)pvVar9 + lVar12 * 8) = 0.0 / (double)iVar7;
lVar12 = lVar12 + 1;
} while ((int)lVar12 < iVar6);
}
return param_1;
} |
2,460 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& test_tup1, const std::vector<int>& test_tup2) {
std::vector<int> res;
for(size_t i = 0; i < test_tup1.size(); ++i) {
res.push_back(test_tup1[i] % test_tup2[i]);
}
return res;
}
| int main() {
assert((func0({10, 4, 5, 6}, {5, 6, 7, 5}) == std::vector<int>{0, 4, 5, 1}));
assert((func0({11, 5, 6, 7}, {6, 7, 8, 6}) == std::vector<int>{5, 5, 6, 1}));
assert((func0({12, 6, 7, 8}, {7, 8, 9, 7}) == std::vector<int>{5, 6, 7, 1}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1bf8 <_ZNSt6vectorIiSaIiEEC1Ev>
movq $0x0,-0x20(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 1cfe <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,-0x20(%rbp)
setb %al
test %al,%al
je 1308 <_Z5func0RKSt6vectorIiSaIiEES3_+0xbf>
mov -0x20(%rbp),%rdx
mov -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1d26 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x20(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1d26 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%ecx
mov %ebx,%eax
cltd
idiv %ecx
mov %edx,%eax
mov %eax,-0x24(%rbp)
lea -0x24(%rbp),%rdx
mov -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1d4a <_ZNSt6vectorIiSaIiEE9push_backEOi>
addq $0x1,-0x20(%rbp)
jmp 1285 <_Z5func0RKSt6vectorIiSaIiEES3_+0x3c>
endbr64
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1cb6 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1150 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 131d <_Z5func0RKSt6vectorIiSaIiEES3_+0xd4>
callq 1130 <__stack_chk_fail@plt>
mov -0x38(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov [rbp+var_20], 0
jmp short loc_12F5
loc_12A7:
mov rdx, [rbp+var_20]
mov rax, [rbp+var_40]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ecx, [rax]
mov eax, ebx
cdq
idiv ecx
mov ecx, edx
mov eax, ecx
mov [rbp+var_24], eax
lea rdx, [rbp+var_24]
mov rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE9push_backEOi; std::vector<int>::push_back(int &&)
add [rbp+var_20], 1
loc_12F5:
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
cmp [rbp+var_20], rax
setb al
test al, al
jnz short loc_12A7
jmp short loc_1340
endbr64
mov rbx, rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1338
call ___stack_chk_fail
loc_1338:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1340:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_1354
call ___stack_chk_fail
loc_1354:
mov rax, [rbp+var_38]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, long long a3)
{
int v3; // ebx
unsigned long long v4; // rax
int v7; // [rsp+2Ch] [rbp-24h] BYREF
unsigned long long i; // [rsp+30h] [rbp-20h]
unsigned long long v9; // [rsp+38h] [rbp-18h]
v9 = __readfsqword(0x28u);
std::vector<int>::vector(a1);
for ( i = 0LL; ; ++i )
{
v4 = std::vector<int>::size(a2);
if ( i >= v4 )
break;
v3 = *(_DWORD *)std::vector<int>::operator[](a2, i);
v7 = v3 % *(_DWORD *)std::vector<int>::operator[](a3, i);
std::vector<int>::push_back(a1, &v7);
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101c96
MOV qword ptr [RBP + -0x20],0x0
JMP 0x001012f5
LAB_001012a7:
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101dbc
MOV EBX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101dbc
MOV ECX,dword ptr [RAX]
MOV EAX,EBX
CDQ
IDIV ECX
MOV ECX,EDX
MOV EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
LEA RDX,[RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
LAB_001012eb:
CALL 0x00101de0
ADD qword ptr [RBP + -0x20],0x1
LAB_001012f5:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101d94
CMP qword ptr [RBP + -0x20],RAX
SETC AL
TEST AL,AL
JNZ 0x001012a7
JMP 0x00101340
LAB_00101340:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101354
CALL 0x00101150
LAB_00101354:
MOV RAX,qword ptr [RBP + -0x38]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int *piVar2;
ulong uVar3;
vector<int,std::allocator<int>> *in_RDX;
long in_FS_OFFSET;
int local_2c;
ulong local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<int,std::allocator<int>>::vector((vector<int,std::allocator<int>> *)param_1);
local_28 = 0;
while( true ) {
uVar3 = std::vector<int,std::allocator<int>>::size((vector<int,std::allocator<int>> *)param_2);
if (uVar3 <= local_28) break;
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_2,local_28);
iVar1 = *piVar2;
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](in_RDX,local_28);
local_2c = iVar1 % *piVar2;
/* try { // try from 001012eb to 001012ef has its CatchHandler @ 0010130e */
std::vector<int,std::allocator<int>>::push_back
((vector<int,std::allocator<int>> *)param_1,&local_2c);
local_28 = local_28 + 1;
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,461 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& test_tup1, const std::vector<int>& test_tup2) {
std::vector<int> res;
for(size_t i = 0; i < test_tup1.size(); ++i) {
res.push_back(test_tup1[i] % test_tup2[i]);
}
return res;
}
| int main() {
assert((func0({10, 4, 5, 6}, {5, 6, 7, 5}) == std::vector<int>{0, 4, 5, 1}));
assert((func0({11, 5, 6, 7}, {6, 7, 8, 6}) == std::vector<int>{5, 5, 6, 1}));
assert((func0({12, 6, 7, 8}, {7, 8, 9, 7}) == std::vector<int>{5, 6, 7, 1}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbp
mov %rdx,%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
je 1301 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb8>
mov %rsi,%r12
mov $0x0,%ebx
lea 0x4(%rsp),%r14
jmp 12c2 <_Z5func0RKSt6vectorIiSaIiEES3_+0x79>
mov %r14,%rdx
mov %rbp,%rdi
callq 1972 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
add $0x1,%rbx
mov (%r12),%rdx
mov 0x8(%r12),%rax
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 1301 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb8>
mov 0x0(%r13),%rcx
mov (%rdx,%rbx,4),%eax
cltd
idivl (%rcx,%rbx,4)
mov %edx,0x4(%rsp)
mov 0x8(%rbp),%rsi
cmp 0x10(%rbp),%rsi
je 129e <_Z5func0RKSt6vectorIiSaIiEES3_+0x55>
mov %edx,(%rsi)
addq $0x4,0x8(%rbp)
jmp 12a9 <_Z5func0RKSt6vectorIiSaIiEES3_+0x60>
endbr64
mov %rax,%rbx
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 12f9 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
callq 1110 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1150 <_Unwind_Resume@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1321 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd8>
mov %rbp,%rax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov r13, rdx
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp rdx, [rsi+8]
jz loc_1314
mov r12, rsi
mov ebx, 0
lea r14, [rsp+38h+var_34]
jmp short loc_12C6
loc_12A2:
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int &&)
loc_12AD:
add rbx, 1
mov rdx, [r12]
mov rax, [r12+8]
sub rax, rdx
sar rax, 2
cmp rbx, rax
jnb short loc_1314
loc_12C6:
mov rcx, [r13+0]
mov eax, [rdx+rbx*4]
cdq
idiv dword ptr [rcx+rbx*4]
mov [rsp+38h+var_34], edx
mov rsi, [rbp+8]
cmp rsi, [rbp+10h]
jz short loc_12A2
mov [rsi], edx
add qword ptr [rbp+8], 4
jmp short loc_12AD
endbr64
mov rbx, rax
mov rdi, rbp
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+arg_0]
sub rax, fs:28h
jz short loc_130C
call ___stack_chk_fail
loc_130C:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1314:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1334
mov rax, rbp
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1334:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
unsigned long long v6; // rbx
int v7; // edx
int *v8; // rsi
int v10; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+8h] [rbp-30h]
v11 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v4 = *a2;
if ( *a2 != a2[1] )
{
v6 = 0LL;
do
{
v7 = *(_DWORD *)(v4 + 4 * v6) % *(_DWORD *)(*a3 + 4 * v6);
v10 = v7;
v8 = (int *)a1[1];
if ( v8 == (int *)a1[2] )
{
std::vector<int>::_M_realloc_insert<int>(a1, v8, &v10);
}
else
{
*v8 = v7;
a1[1] += 4LL;
}
++v6;
v4 = *a2;
}
while ( v6 < (a2[1] - *a2) >> 2 );
}
return a1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV R13,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP RDX,qword ptr [RSI + 0x8]
JZ 0x00101314
MOV R12,RSI
MOV EBX,0x0
LEA R14,[RSP + 0x4]
JMP 0x001012c6
LAB_001012a2:
MOV RDX,R14
MOV RDI,RBP
LAB_001012a8:
CALL 0x001019a2
LAB_001012ad:
ADD RBX,0x1
MOV RDX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
SUB RAX,RDX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x00101314
LAB_001012c6:
MOV RCX,qword ptr [R13]
MOV EAX,dword ptr [RDX + RBX*0x4]
CDQ
IDIV dword ptr [RCX + RBX*0x4]
MOV dword ptr [RSP + 0x4],EDX
MOV RSI,qword ptr [RBP + 0x8]
CMP RSI,qword ptr [RBP + 0x10]
JZ 0x001012a2
MOV dword ptr [RSI],EDX
ADD qword ptr [RBP + 0x8],0x4
JMP 0x001012ad
LAB_00101314:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101334
MOV RAX,RBP
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101334:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int *piVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
lVar2 = *(long *)param_2;
if (lVar2 != *(long *)(param_2 + 8)) {
uVar3 = 0;
do {
local_34 = *(int *)(lVar2 + uVar3 * 4) % *(int *)(*in_RDX + uVar3 * 4);
piVar1 = *(int **)(param_1 + 8);
if (piVar1 == *(int **)(param_1 + 0x10)) {
/* try { // try from 001012a8 to 001012ac has its CatchHandler @ 001012e8 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar1,&local_34);
}
else {
*piVar1 = local_34;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 4;
}
uVar3 = uVar3 + 1;
lVar2 = *(long *)param_2;
} while (uVar3 < (ulong)(*(long *)(param_2 + 8) - lVar2 >> 2));
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,462 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& test_tup1, const std::vector<int>& test_tup2) {
std::vector<int> res;
for(size_t i = 0; i < test_tup1.size(); ++i) {
res.push_back(test_tup1[i] % test_tup2[i]);
}
return res;
}
| int main() {
assert((func0({10, 4, 5, 6}, {5, 6, 7, 5}) == std::vector<int>{0, 4, 5, 1}));
assert((func0({11, 5, 6, 7}, {6, 7, 8, 6}) == std::vector<int>{5, 5, 6, 1}));
assert((func0({12, 6, 7, 8}, {7, 8, 9, 7}) == std::vector<int>{5, 6, 7, 1}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp 0x8(%rsi),%rdx
je 1810 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
mov %rsi,%rbp
xor %edi,%edi
xor %esi,%esi
xor %ebx,%ebx
lea 0x4(%rsp),%r14
jmp 17ed <_Z5func0RKSt6vectorIiSaIiEES3_+0x8d>
nopw %cs:0x0(%rax,%rax,1)
mov %edx,(%rsi)
add $0x4,%rsi
mov %rsi,0x8(%r12)
mov 0x0(%rbp),%rdx
mov 0x8(%rbp),%rax
add $0x1,%rbx
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 1810 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
mov 0x8(%r12),%rsi
mov 0x10(%r12),%rdi
mov (%rdx,%rbx,4),%eax
mov 0x0(%r13),%rcx
cltd
idivl (%rcx,%rbx,4)
mov %edx,0x4(%rsp)
cmp %rdi,%rsi
jne 17c0 <_Z5func0RKSt6vectorIiSaIiEES3_+0x60>
mov %r14,%rdx
mov %r12,%rdi
callq 1960 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmp 17cb <_Z5func0RKSt6vectorIiSaIiEES3_+0x6b>
xchg %ax,%ax
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1830 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd0>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1160 <_Z5func0RKSt6vectorIiSaIiEES3_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rcx
jz short loc_1770
mov r12, rsi
mov r13, rdx
xor edi, edi
xor esi, esi
xor ebx, ebx
lea r14, [rsp+38h+var_34]
jmp short loc_1747
loc_1720:
mov [rsi], edx
add rsi, 4
mov [rbp+8], rsi
loc_172A:
mov rax, [r12+8]
add rbx, 1
sub rax, rcx
sar rax, 2
cmp rbx, rax
jnb short loc_1770
mov rsi, [rbp+8]
mov rdi, [rbp+10h]
loc_1747:
mov eax, [rcx+rbx*4]
mov r8, [r13+0]
cdq
idiv dword ptr [r8+rbx*4]
mov [rsp+38h+var_34], edx
cmp rsi, rdi
jnz short loc_1720
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int &&)
mov rcx, [r12]
jmp short loc_172A
loc_1770:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1790
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1790:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEES3__cold; func0(std::vector<int> const&,std::vector<int> const&) [clone] | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rcx
int *v7; // rdi
int *v8; // rsi
long long v9; // rbx
int v10; // edx
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v4 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if ( a2[1] != v4 )
{
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
while ( 1 )
{
v10 = *(_DWORD *)(v4 + 4 * v9) % *(_DWORD *)(*a3 + 4 * v9);
v12 = v10;
if ( v8 == v7 )
{
std::vector<int>::_M_realloc_insert<int>(a1, v8, &v12);
v4 = *a2;
}
else
{
*v8 = v10;
*(_QWORD *)(a1 + 8) = v8 + 1;
}
if ( ++v9 >= (unsigned long long)((a2[1] - v4) >> 2) )
break;
v8 = *(int **)(a1 + 8);
v7 = *(int **)(a1 + 16);
}
}
return a1;
} | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RCX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RCX
JZ 0x00101770
MOV R12,RSI
MOV R13,RDX
XOR EDI,EDI
XOR ESI,ESI
XOR EBX,EBX
LEA R14,[RSP + 0x4]
JMP 0x00101747
LAB_00101720:
MOV dword ptr [RSI],EDX
ADD RSI,0x4
MOV qword ptr [RBP + 0x8],RSI
LAB_0010172a:
MOV RAX,qword ptr [R12 + 0x8]
ADD RBX,0x1
SUB RAX,RCX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x00101770
MOV RSI,qword ptr [RBP + 0x8]
MOV RDI,qword ptr [RBP + 0x10]
LAB_00101747:
MOV EAX,dword ptr [RCX + RBX*0x4]
MOV R8,qword ptr [R13]
CDQ
IDIV dword ptr [R8 + RBX*0x4]
MOV dword ptr [RSP + 0x4],EDX
CMP RSI,RDI
JNZ 0x00101720
MOV RDX,R14
MOV RDI,RBP
LAB_00101762:
CALL 0x001018c0
MOV RCX,qword ptr [R12]
JMP 0x0010172a
LAB_00101770:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101790
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101790:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
long lVar1;
long *in_RDX;
ulong uVar2;
int *piVar3;
int *piVar4;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int (*) [16])param_1 = (int [16])0x0;
lVar1 = *(long *)param_2;
*(int8 *)(param_1 + 0x10) = 0;
if (*(long *)(param_2 + 8) != lVar1) {
piVar4 = (int *)0x0;
piVar3 = (int *)0x0;
uVar2 = 0;
while( true ) {
local_34 = *(int *)(lVar1 + uVar2 * 4) % *(int *)(*in_RDX + uVar2 * 4);
if (piVar3 == piVar4) {
/* try { // try from 00101762 to 00101766 has its CatchHandler @ 00101795 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar3,&local_34);
lVar1 = *(long *)param_2;
}
else {
*piVar3 = local_34;
*(int **)(param_1 + 8) = piVar3 + 1;
}
uVar2 = uVar2 + 1;
if ((ulong)(*(long *)(param_2 + 8) - lVar1 >> 2) <= uVar2) break;
piVar3 = *(int **)(param_1 + 8);
piVar4 = *(int **)(param_1 + 0x10);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,463 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& test_tup1, const std::vector<int>& test_tup2) {
std::vector<int> res;
for(size_t i = 0; i < test_tup1.size(); ++i) {
res.push_back(test_tup1[i] % test_tup2[i]);
}
return res;
}
| int main() {
assert((func0({10, 4, 5, 6}, {5, 6, 7, 5}) == std::vector<int>{0, 4, 5, 1}));
assert((func0({11, 5, 6, 7}, {6, 7, 8, 6}) == std::vector<int>{5, 5, 6, 1}));
assert((func0({12, 6, 7, 8}, {7, 8, 9, 7}) == std::vector<int>{5, 6, 7, 1}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rdx
cmp 0x8(%rsi),%rdx
je 17c0 <_Z5func0RKSt6vectorIiSaIiEES3_+0xa0>
mov %rsi,%rbp
xor %edi,%edi
xor %esi,%esi
xor %ebx,%ebx
lea 0x4(%rsp),%r14
jmp 179d <_Z5func0RKSt6vectorIiSaIiEES3_+0x7d>
xchg %ax,%ax
mov %edx,(%rsi)
add $0x4,%rsi
mov %rsi,0x8(%r12)
mov 0x0(%rbp),%rdx
mov 0x8(%rbp),%rax
add $0x1,%rbx
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 17c0 <_Z5func0RKSt6vectorIiSaIiEES3_+0xa0>
mov 0x8(%r12),%rsi
mov 0x10(%r12),%rdi
mov (%rdx,%rbx,4),%eax
mov 0x0(%r13),%rcx
cltd
idivl (%rcx,%rbx,4)
mov %edx,0x4(%rsp)
cmp %rdi,%rsi
jne 1770 <_Z5func0RKSt6vectorIiSaIiEES3_+0x50>
mov %r14,%rdx
mov %r12,%rdi
callq 1850 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmp 177b <_Z5func0RKSt6vectorIiSaIiEES3_+0x5b>
xchg %ax,%ax
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 17e0 <_Z5func0RKSt6vectorIiSaIiEES3_+0xc0>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1175 <_Z5func0RKSt6vectorIiSaIiEES3_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rcx
jz short loc_1770
mov r12, rsi
mov r13, rdx
xor edi, edi
xor esi, esi
xor ebx, ebx
lea r14, [rsp+38h+var_34]
jmp short loc_1747
loc_1720:
mov [rsi], edx
add rsi, 4
mov [rbp+8], rsi
loc_172A:
mov rax, [r12+8]
add rbx, 1
sub rax, rcx
sar rax, 2
cmp rbx, rax
jnb short loc_1770
mov rsi, [rbp+8]
mov rdi, [rbp+10h]
loc_1747:
mov eax, [rcx+rbx*4]
mov r8, [r13+0]
cdq
idiv dword ptr [r8+rbx*4]
mov [rsp+38h+var_34], edx
cmp rsi, rdi
jnz short loc_1720
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int &&)
mov rcx, [r12]
jmp short loc_172A
loc_1770:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1790
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1790:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEES3__cold; func0(std::vector<int> const&,std::vector<int> const&) [clone] | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rcx
int *v7; // rdi
int *v8; // rsi
long long v9; // rbx
int v10; // edx
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v4 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if ( a2[1] != v4 )
{
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
while ( 1 )
{
v10 = *(_DWORD *)(v4 + 4 * v9) % *(_DWORD *)(*a3 + 4 * v9);
v12 = v10;
if ( v8 == v7 )
{
std::vector<int>::_M_realloc_insert<int>(a1, v8, &v12);
v4 = *a2;
}
else
{
*v8 = v10;
*(_QWORD *)(a1 + 8) = v8 + 1;
}
if ( ++v9 >= (unsigned long long)((a2[1] - v4) >> 2) )
break;
v8 = *(int **)(a1 + 8);
v7 = *(int **)(a1 + 16);
}
}
return a1;
} | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RCX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RCX
JZ 0x00101770
MOV R12,RSI
MOV R13,RDX
XOR EDI,EDI
XOR ESI,ESI
XOR EBX,EBX
LEA R14,[RSP + 0x4]
JMP 0x00101747
LAB_00101720:
MOV dword ptr [RSI],EDX
ADD RSI,0x4
MOV qword ptr [RBP + 0x8],RSI
LAB_0010172a:
MOV RAX,qword ptr [R12 + 0x8]
ADD RBX,0x1
SUB RAX,RCX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x00101770
MOV RSI,qword ptr [RBP + 0x8]
MOV RDI,qword ptr [RBP + 0x10]
LAB_00101747:
MOV EAX,dword ptr [RCX + RBX*0x4]
MOV R8,qword ptr [R13]
CDQ
IDIV dword ptr [R8 + RBX*0x4]
MOV dword ptr [RSP + 0x4],EDX
CMP RSI,RDI
JNZ 0x00101720
MOV RDX,R14
MOV RDI,RBP
LAB_00101762:
CALL 0x001018c0
MOV RCX,qword ptr [R12]
JMP 0x0010172a
LAB_00101770:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101790
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101790:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
long lVar1;
long *in_RDX;
ulong uVar2;
int *piVar3;
int *piVar4;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int (*) [16])param_1 = (int [16])0x0;
lVar1 = *(long *)param_2;
*(int8 *)(param_1 + 0x10) = 0;
if (*(long *)(param_2 + 8) != lVar1) {
piVar4 = (int *)0x0;
piVar3 = (int *)0x0;
uVar2 = 0;
while( true ) {
local_34 = *(int *)(lVar1 + uVar2 * 4) % *(int *)(*in_RDX + uVar2 * 4);
if (piVar3 == piVar4) {
/* try { // try from 00101762 to 00101766 has its CatchHandler @ 00101795 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar3,&local_34);
lVar1 = *(long *)param_2;
}
else {
*piVar3 = local_34;
*(int **)(param_1 + 8) = piVar3 + 1;
}
uVar2 = uVar2 + 1;
if ((ulong)(*(long *)(param_2 + 8) - lVar1 >> 2) <= uVar2) break;
piVar3 = *(int **)(param_1 + 8);
piVar4 = *(int **)(param_1 + 0x10);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,464 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| double func0(int a, int b, int d) {
int temp = a;
a = std::min(a, b);
b = std::max(temp, b);
if (d >= b) {
return static_cast<double>(d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
else {
return 2;
}
}
| int main() {
assert(func0(3, 4, 11) == 3.5);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x14(%rbp),%eax
mov %eax,-0xc(%rbp)
lea -0x18(%rbp),%rdx
lea -0x14(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 13b5 <_ZSt3minIiERKT_S2_S2_>
mov (%rax),%eax
mov %eax,-0x14(%rbp)
lea -0x18(%rbp),%rdx
lea -0xc(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 13e1 <_ZSt3maxIiERKT_S2_S2_>
mov (%rax),%eax
mov %eax,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp %eax,-0x1c(%rbp)
jl 1227 <_Z5func0iii+0x7e>
mov -0x18(%rbp),%edx
mov -0x1c(%rbp),%eax
add %edx,%eax
sub $0x1,%eax
cvtsi2sd %eax,%xmm0
mov -0x18(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd %xmm1,%xmm0
jmp 124d <_Z5func0iii+0xa4>
cmpl $0x0,-0x1c(%rbp)
jne 1233 <_Z5func0iii+0x8a>
pxor %xmm0,%xmm0
jmp 124d <_Z5func0iii+0xa4>
mov -0x14(%rbp),%eax
cmp %eax,-0x1c(%rbp)
jne 1245 <_Z5func0iii+0x9c>
movsd 0xe5d(%rip),%xmm0
jmp 124d <_Z5func0iii+0xa4>
movsd 0xe5b(%rip),%xmm0
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
je 1261 <_Z5func0iii+0xb8>
callq 10a0 <__stack_chk_fail@plt>
leaveq
retq
| _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_14]
mov [rbp+var_C], eax
lea rdx, [rbp+var_18]
lea rax, [rbp+var_14]
mov rsi, rdx
mov rdi, rax
call _ZSt3minIiERKT_S2_S2_; std::min<int>(int const&,int const&)
mov eax, [rax]
mov [rbp+var_14], eax
lea rdx, [rbp+var_18]
lea rax, [rbp+var_C]
mov rsi, rdx
mov rdi, rax
call _ZSt3maxIiERKT_S2_S2_; std::max<int>(int const&,int const&)
mov eax, [rax]
mov [rbp+var_18], eax
mov eax, [rbp+var_18]
cmp [rbp+var_1C], eax
jl short loc_11EF
mov edx, [rbp+var_18]
mov eax, [rbp+var_1C]
add eax, edx
sub eax, 1
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
mov eax, [rbp+var_18]
pxor xmm1, xmm1
cvtsi2sd xmm1, eax
divsd xmm0, xmm1
jmp short loc_1215
loc_11EF:
cmp [rbp+var_1C], 0
jnz short loc_11FB
pxor xmm0, xmm0
jmp short loc_1215
loc_11FB:
mov eax, [rbp+var_14]
cmp [rbp+var_1C], eax
jnz short loc_120D
movsd xmm0, cs:qword_2080
jmp short loc_1215
loc_120D:
movsd xmm0, cs:qword_2088
loc_1215:
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short locret_1229
call ___stack_chk_fail
locret_1229:
leave
retn | unsigned long long func0(int a1, int a2)
{
int v3; // [rsp+8h] [rbp-18h] BYREF
int v4; // [rsp+Ch] [rbp-14h] BYREF
int v5; // [rsp+14h] [rbp-Ch] BYREF
unsigned long long v6; // [rsp+18h] [rbp-8h]
v4 = a1;
v3 = a2;
v6 = __readfsqword(0x28u);
v5 = a1;
v4 = *(_DWORD *)std::min<int>(&v4, &v3);
std::max<int>(&v5, &v3);
return v6 - __readfsqword(0x28u);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0xc],EAX
LEA RDX,[RBP + -0x18]
LEA RAX,[RBP + -0x14]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010135f
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
LEA RDX,[RBP + -0x18]
LEA RAX,[RBP + -0xc]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010138b
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x18]
CMP dword ptr [RBP + -0x1c],EAX
JL 0x001011ef
MOV EDX,dword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EDX
SUB EAX,0x1
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOV EAX,dword ptr [RBP + -0x18]
PXOR XMM1,XMM1
CVTSI2SD XMM1,EAX
DIVSD XMM0,XMM1
JMP 0x00101215
LAB_001011ef:
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x001011fb
PXOR XMM0,XMM0
JMP 0x00101215
LAB_001011fb:
MOV EAX,dword ptr [RBP + -0x14]
CMP dword ptr [RBP + -0x1c],EAX
JNZ 0x0010120d
MOVSD XMM0,qword ptr [0x00102080]
JMP 0x00101215
LAB_0010120d:
MOVSD XMM0,qword ptr [0x00102088]
LAB_00101215:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101229
CALL 0x00101070
LAB_00101229:
LEAVE
RET | /* func0(int, int, int) */
double func0(int param_1,int param_2,int param_3)
{
int *piVar1;
long in_FS_OFFSET;
double dVar2;
int local_20;
int local_1c [2];
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = param_2;
local_1c[0] = param_1;
local_14 = param_1;
piVar1 = std::min<int>(local_1c,&local_20);
local_1c[0] = *piVar1;
piVar1 = std::max<int>(&local_14,&local_20);
local_20 = *piVar1;
if (param_3 < local_20) {
if (param_3 == 0) {
dVar2 = 0.0;
}
else {
dVar2 = DAT_00102088;
if (param_3 == local_1c[0]) {
dVar2 = DAT_00102080;
}
}
}
else {
dVar2 = (double)(param_3 + local_20 + -1) / (double)local_20;
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return dVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,465 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| double func0(int a, int b, int d) {
int temp = a;
a = std::min(a, b);
b = std::max(temp, b);
if (d >= b) {
return static_cast<double>(d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
else {
return 2;
}
}
| int main() {
assert(func0(3, 4, 11) == 3.5);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
cmp %esi,%edi
mov %esi,%ecx
cmovge %edi,%ecx
cmp %ecx,%edx
jge 11ba <_Z5func0iii+0x31>
pxor %xmm0,%xmm0
test %edx,%edx
je 11b9 <_Z5func0iii+0x30>
cmp %esi,%edi
cmovg %esi,%edi
movsd 0xefb(%rip),%xmm0
cmp %edi,%edx
je 11b9 <_Z5func0iii+0x30>
movsd 0xef7(%rip),%xmm0
retq
lea -0x1(%rcx,%rdx,1),%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd %xmm1,%xmm0
retq
| _Z5func0iii:
endbr64
cmp esi, edi
mov eax, edi
cmovge eax, esi
cmp edx, eax
jge short loc_1172
pxor xmm0, xmm0
test edx, edx
jz short locret_1171
cmp esi, edi
cmovg esi, edi
movsd xmm0, cs:qword_2080
cmp esi, edx
jz short loc_118B
locret_1171:
retn
loc_1172:
lea edx, [rax+rdx-1]
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
pxor xmm1, xmm1
cvtsi2sd xmm1, eax
divsd xmm0, xmm1
retn
loc_118B:
movsd xmm0, cs:qword_2078
retn | double func0(int a1, int a2, int a3)
{
int v3; // eax
double result; // xmm0_8
v3 = a1;
if ( a2 >= a1 )
v3 = a2;
if ( a3 >= v3 )
return (double)(v3 + a3 - 1) / (double)v3;
result = 0.0;
if ( a3 )
{
if ( a2 > a1 )
a2 = a1;
result = 2.0;
if ( a2 == a3 )
return 1.0;
}
return result;
} | func0:
ENDBR64
CMP ESI,EDI
MOV EAX,EDI
CMOVGE EAX,ESI
CMP EDX,EAX
JGE 0x00101172
PXOR XMM0,XMM0
TEST EDX,EDX
JZ 0x00101171
CMP ESI,EDI
CMOVG ESI,EDI
MOVSD XMM0,qword ptr [0x00102080]
CMP ESI,EDX
JZ 0x0010118b
LAB_00101171:
RET
LAB_00101172:
LEA EDX,[RAX + RDX*0x1 + -0x1]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
PXOR XMM1,XMM1
CVTSI2SD XMM1,EAX
DIVSD XMM0,XMM1
RET
LAB_0010118b:
MOVSD XMM0,qword ptr [0x00102078]
RET | /* func0(int, int, int) */
double func0(int param_1,int param_2,int param_3)
{
int iVar1;
double dVar2;
iVar1 = param_1;
if (param_1 <= param_2) {
iVar1 = param_2;
}
if (iVar1 <= param_3) {
return (double)(iVar1 + -1 + param_3) / (double)iVar1;
}
dVar2 = 0.0;
if (param_3 != 0) {
if (param_1 < param_2) {
param_2 = param_1;
}
dVar2 = DAT_00102080;
if (param_2 == param_3) {
return DAT_00102078;
}
}
return dVar2;
} |
2,466 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| double func0(int a, int b, int d) {
int temp = a;
a = std::min(a, b);
b = std::max(temp, b);
if (d >= b) {
return static_cast<double>(d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
else {
return 2;
}
}
| int main() {
assert(func0(3, 4, 11) == 3.5);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
cmp %esi,%edi
jle 11ce <_Z5func0iii+0xe>
mov %esi,%eax
mov %edi,%esi
mov %eax,%edi
cmp %edx,%esi
jle 11f0 <_Z5func0iii+0x30>
pxor %xmm0,%xmm0
test %edx,%edx
je 11ee <_Z5func0iii+0x2e>
movsd 0xe26(%rip),%xmm0
cmp %edi,%edx
je 11ee <_Z5func0iii+0x2e>
movsd 0xe22(%rip),%xmm0
retq
lea -0x1(%rsi,%rdx,1),%eax
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm0
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
nopl 0x0(%rax)
| _Z5func0iii:
endbr64
cmp edi, esi
jg short loc_11F1
mov eax, esi
mov esi, edi
cmovge eax, edi
mov edi, eax
loc_11F1:
cmp edi, edx
jle short loc_1210
pxor xmm0, xmm0
test edx, edx
jz short locret_1209
movsd xmm0, cs:qword_2068
cmp edx, esi
jz short loc_1230
locret_1209:
retn
loc_1210:
lea eax, [rdi+rdx-1]
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, eax
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
retn
loc_1230:
movsd xmm0, cs:qword_2060
retn | double func0(int a1, int a2, int a3)
{
bool v3; // cc
int v4; // eax
double result; // xmm0_8
v3 = a1 < a2;
if ( a1 <= a2 )
{
v4 = a2;
a2 = a1;
if ( !v3 )
v4 = a1;
a1 = v4;
}
if ( a1 <= a3 )
return (double)(a1 + a3 - 1) / (double)a1;
result = 0.0;
if ( a3 )
{
result = 2.0;
if ( a3 == a2 )
return 1.0;
}
return result;
} | func0:
ENDBR64
CMP EDI,ESI
JG 0x001011f1
MOV EAX,ESI
MOV ESI,EDI
CMOVGE EAX,EDI
MOV EDI,EAX
LAB_001011f1:
CMP EDI,EDX
JLE 0x00101210
PXOR XMM0,XMM0
TEST EDX,EDX
JZ 0x00101209
MOVSD XMM0,qword ptr [0x00102068]
CMP EDX,ESI
JZ 0x00101230
LAB_00101209:
RET
LAB_00101210:
LEA EAX,[RDI + RDX*0x1 + -0x1]
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EAX
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
RET
LAB_00101230:
MOVSD XMM0,qword ptr [0x00102060]
RET | /* func0(int, int, int) */
double func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
double dVar3;
iVar1 = param_2;
iVar2 = param_1;
if ((param_1 <= param_2) && (iVar1 = param_1, iVar2 = param_2, param_2 <= param_1)) {
iVar2 = param_1;
}
if (iVar2 <= param_3) {
return (double)(iVar2 + -1 + param_3) / (double)iVar2;
}
dVar3 = 0.0;
if ((param_3 != 0) && (dVar3 = DAT_00102068, param_3 == iVar1)) {
return DAT_00102060;
}
return dVar3;
} |
2,467 | func0 |
#include <iostream>
#include <algorithm>
#include <cassert>
| double func0(int a, int b, int d) {
int temp = a;
a = std::min(a, b);
b = std::max(temp, b);
if (d >= b) {
return static_cast<double>(d + b - 1) / b;
}
if (d == 0) {
return 0;
}
if (d == a) {
return 1;
}
else {
return 2;
}
}
| int main() {
assert(func0(3, 4, 11) == 3.5);
assert(func0(3, 4, 0) == 0);
assert(func0(11, 14, 11) == 1);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
cmp %esi,%edi
jle 11ce <_Z5func0iii+0xe>
mov %esi,%eax
mov %edi,%esi
mov %eax,%edi
cmp %edx,%esi
jle 11f0 <_Z5func0iii+0x30>
pxor %xmm0,%xmm0
test %edx,%edx
je 11ee <_Z5func0iii+0x2e>
movsd 0xe26(%rip),%xmm0
cmp %edi,%edx
je 11ee <_Z5func0iii+0x2e>
movsd 0xe22(%rip),%xmm0
retq
lea -0x1(%rsi,%rdx,1),%eax
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm0
cvtsi2sd %esi,%xmm1
divsd %xmm1,%xmm0
retq
nopl 0x0(%rax)
| _Z5func0iii:
endbr64
cmp edi, esi
jg short loc_1151
mov eax, esi
mov esi, edi
cmovge eax, edi
mov edi, eax
loc_1151:
cmp edi, edx
jle short loc_1170
pxor xmm0, xmm0
test edx, edx
jz short locret_1169
movsd xmm0, cs:qword_2010
cmp edx, esi
jz short loc_1190
locret_1169:
retn
loc_1170:
lea eax, [rdi+rdx-1]
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, eax
cvtsi2sd xmm1, edi
divsd xmm0, xmm1
retn
loc_1190:
movsd xmm0, cs:qword_2008
retn | double func0(int a1, int a2, int a3)
{
bool v3; // cc
int v4; // eax
double result; // xmm0_8
v3 = a1 < a2;
if ( a1 <= a2 )
{
v4 = a2;
a2 = a1;
if ( !v3 )
v4 = a1;
a1 = v4;
}
if ( a1 <= a3 )
return (double)(a1 + a3 - 1) / (double)a1;
result = 0.0;
if ( a3 )
{
result = 2.0;
if ( a3 == a2 )
return 1.0;
}
return result;
} | func0:
ENDBR64
CMP EDI,ESI
JG 0x00101151
MOV EAX,ESI
MOV ESI,EDI
CMOVGE EAX,EDI
MOV EDI,EAX
LAB_00101151:
CMP EDI,EDX
JLE 0x00101170
PXOR XMM0,XMM0
TEST EDX,EDX
JZ 0x00101169
MOVSD XMM0,qword ptr [0x00102010]
CMP EDX,ESI
JZ 0x00101190
LAB_00101169:
RET
LAB_00101170:
LEA EAX,[RDI + RDX*0x1 + -0x1]
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,EAX
CVTSI2SD XMM1,EDI
DIVSD XMM0,XMM1
RET
LAB_00101190:
MOVSD XMM0,qword ptr [0x00102008]
RET | /* func0(int, int, int) */
double func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
double dVar3;
iVar1 = param_2;
iVar2 = param_1;
if ((param_1 <= param_2) && (iVar1 = param_1, iVar2 = param_2, param_2 <= param_1)) {
iVar2 = param_1;
}
if (iVar2 <= param_3) {
return (double)(iVar2 + -1 + param_3) / (double)iVar2;
}
dVar3 = 0.0;
if ((param_3 != 0) && (dVar3 = DAT_00102010, param_3 == iVar1)) {
return DAT_00102008;
}
return dVar3;
} |
2,468 | func0 |
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<double> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(static_cast<double>(nums1[i]) / nums2[i]);
}
return result;
}
| int main() {
assert(func0({4,5,6},{1, 2, 3}) == std::vector<double>({4.0, 2.5, 2.0}));
assert(func0({3,2},{1,4}) == std::vector<double>({3.0, 0.5}));
assert(func0({90,120},{50,70}) == std::vector<double>({1.8, 1.7142857142857142}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1b8e <_ZNSt6vectorIdSaIdEEC1Ev>
movq $0x0,-0x20(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 1c94 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,-0x20(%rbp)
setb %al
test %al,%al
je 1301 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd8>
mov -0x20(%rbp),%rdx
mov -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1cbc <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
cvtsi2sd %eax,%xmm1
movsd %xmm1,-0x50(%rbp)
mov -0x20(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1cbc <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
cvtsi2sd %eax,%xmm0
movsd -0x50(%rbp),%xmm1
divsd %xmm0,%xmm1
movapd %xmm1,%xmm0
movsd %xmm0,-0x28(%rbp)
lea -0x28(%rbp),%rdx
mov -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1ce0 <_ZNSt6vectorIdSaIdEE9push_backEOd>
addq $0x1,-0x20(%rbp)
jmp 1265 <_Z5func0RKSt6vectorIiSaIiEES3_+0x3c>
endbr64
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1c4c <_ZNSt6vectorIdSaIdEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1130 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 1316 <_Z5func0RKSt6vectorIiSaIiEES3_+0xed>
callq 1110 <__stack_chk_fail@plt>
mov -0x38(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIdSaIdEEC2Ev; std::vector<double>::vector(void)
mov [rbp+var_20], 0
jmp short loc_12EC
loc_1287:
mov rdx, [rbp+var_20]
mov rax, [rbp+var_40]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
movsd [rbp+var_50], xmm2
mov rdx, [rbp+var_20]
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
pxor xmm1, xmm1
cvtsi2sd xmm1, eax
movsd xmm0, [rbp+var_50]
divsd xmm0, xmm1
movsd [rbp+var_28], xmm0
lea rdx, [rbp+var_28]
mov rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIdSaIdEE9push_backEOd; std::vector<double>::push_back(double &&)
add [rbp+var_20], 1
loc_12EC:
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
cmp [rbp+var_20], rax
setb al
test al, al
jnz short loc_1287
jmp short loc_1337
endbr64
mov rbx, rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIdSaIdEED2Ev; std::vector<double>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_132F
call ___stack_chk_fail
loc_132F:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1337:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_134B
call ___stack_chk_fail
loc_134B:
mov rax, [rbp+var_38]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, long long a3)
{
unsigned long long v3; // rax
double v5; // [rsp+0h] [rbp-50h]
double v7; // [rsp+28h] [rbp-28h] BYREF
unsigned long long i; // [rsp+30h] [rbp-20h]
unsigned long long v9; // [rsp+38h] [rbp-18h]
v9 = __readfsqword(0x28u);
std::vector<double>::vector(a1);
for ( i = 0LL; ; ++i )
{
v3 = std::vector<int>::size(a2);
if ( i >= v3 )
break;
v5 = (double)*(int *)std::vector<int>::operator[](a2, i);
v7 = v5 / (double)*(int *)std::vector<int>::operator[](a3, i);
std::vector<double>::push_back(a1, &v7);
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101c2a
MOV qword ptr [RBP + -0x20],0x0
JMP 0x001012ec
LAB_00101287:
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101d50
MOV EAX,dword ptr [RAX]
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
MOVSD qword ptr [RBP + -0x50],XMM2
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101d50
MOV EAX,dword ptr [RAX]
PXOR XMM1,XMM1
CVTSI2SD XMM1,EAX
MOVSD XMM0,qword ptr [RBP + -0x50]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x28],XMM0
LEA RDX,[RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
LAB_001012e2:
CALL 0x00101d74
ADD qword ptr [RBP + -0x20],0x1
LAB_001012ec:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101d28
CMP qword ptr [RBP + -0x20],RAX
SETC AL
TEST AL,AL
JNZ 0x00101287
JMP 0x00101337
LAB_00101337:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010134b
CALL 0x00101130
LAB_0010134b:
MOV RAX,qword ptr [RBP + -0x38]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int *piVar2;
ulong uVar3;
vector<int,std::allocator<int>> *in_RDX;
long in_FS_OFFSET;
double local_30;
ulong local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<double,std::allocator<double>>::vector
((vector<double,std::allocator<double>> *)param_1);
local_28 = 0;
while( true ) {
uVar3 = std::vector<int,std::allocator<int>>::size((vector<int,std::allocator<int>> *)param_2);
if (uVar3 <= local_28) break;
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_2,local_28);
iVar1 = *piVar2;
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](in_RDX,local_28);
local_30 = (double)iVar1 / (double)*piVar2;
/* try { // try from 001012e2 to 001012e6 has its CatchHandler @ 00101305 */
std::vector<double,std::allocator<double>>::push_back
((vector<double,std::allocator<double>> *)param_1,&local_30);
local_28 = local_28 + 1;
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,469 | func0 |
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<double> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(static_cast<double>(nums1[i]) / nums2[i]);
}
return result;
}
| int main() {
assert(func0({4,5,6},{1, 2, 3}) == std::vector<double>({4.0, 2.5, 2.0}));
assert(func0({3,2},{1,4}) == std::vector<double>({3.0, 0.5}));
assert(func0({90,120},{50,70}) == std::vector<double>({1.8, 1.7142857142857142}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbp
mov %rdx,%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
je 12f5 <_Z5func0RKSt6vectorIiSaIiEES3_+0xcc>
mov %rsi,%r12
mov $0x0,%ebx
mov %rsp,%r14
jmp 12a4 <_Z5func0RKSt6vectorIiSaIiEES3_+0x7b>
mov %r14,%rdx
mov %rbp,%rdi
callq 19a2 <_ZNSt6vectorIdSaIdEE17_M_realloc_insertIJdEEEvN9__gnu_cxx17__normal_iteratorIPdS1_EEDpOT_>
add $0x1,%rbx
mov (%r12),%rdx
mov 0x8(%r12),%rax
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 12f5 <_Z5func0RKSt6vectorIiSaIiEES3_+0xcc>
pxor %xmm0,%xmm0
cvtsi2sdl (%rdx,%rbx,4),%xmm0
mov 0x0(%r13),%rax
pxor %xmm1,%xmm1
cvtsi2sdl (%rax,%rbx,4),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,(%rsp)
mov 0x8(%rbp),%rsi
cmp 0x10(%rbp),%rsi
je 1280 <_Z5func0RKSt6vectorIiSaIiEES3_+0x57>
movsd %xmm0,(%rsi)
addq $0x8,0x8(%rbp)
jmp 128b <_Z5func0RKSt6vectorIiSaIiEES3_+0x62>
endbr64
mov %rax,%rbx
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 12ed <_Z5func0RKSt6vectorIiSaIiEES3_+0xc4>
callq 10f0 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1130 <_Unwind_Resume@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1315 <_Z5func0RKSt6vectorIiSaIiEES3_+0xec>
mov %rbp,%rax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1110 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov r13, rdx
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp rdx, [rsi+8]
jz loc_1304
mov r12, rsi
mov ebx, 0
mov r14, rsp
jmp short loc_12A4
loc_1280:
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIdSaIdEE17_M_realloc_insertIJdEEEvN9__gnu_cxx17__normal_iteratorIPdS1_EEDpOT_; std::vector<double>::_M_realloc_insert<double>(__gnu_cxx::__normal_iterator<double *,std::vector<double>>,double &&)
loc_128B:
add rbx, 1
mov rdx, [r12]
mov rax, [r12+8]
sub rax, rdx
sar rax, 2
cmp rbx, rax
jnb short loc_1304
loc_12A4:
pxor xmm0, xmm0
cvtsi2sd xmm0, dword ptr [rdx+rbx*4]
mov rax, [r13+0]
pxor xmm1, xmm1
cvtsi2sd xmm1, dword ptr [rax+rbx*4]
divsd xmm0, xmm1
movsd [rsp+38h+var_38], xmm0
mov rsi, [rbp+8]
cmp rsi, [rbp+10h]
jz short loc_1280
movsd qword ptr [rsi], xmm0
add qword ptr [rbp+8], 8
jmp short loc_128B
endbr64
mov rbx, rax
mov rdi, rbp
call _ZNSt6vectorIdSaIdEED2Ev; std::vector<double>::~vector()
mov rax, [rsp+arg_0]
sub rax, fs:28h
jz short loc_12FC
call ___stack_chk_fail
loc_12FC:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1304:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1324
mov rax, rbp
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1324:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
unsigned long long v6; // rbx
double v7; // xmm0_8
double *v8; // rsi
double v10[7]; // [rsp+0h] [rbp-38h] BYREF
*(_QWORD *)&v10[1] = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v4 = *a2;
if ( *a2 != a2[1] )
{
v6 = 0LL;
do
{
v7 = (double)*(int *)(v4 + 4 * v6) / (double)*(int *)(*a3 + 4 * v6);
v10[0] = v7;
v8 = (double *)a1[1];
if ( v8 == (double *)a1[2] )
{
std::vector<double>::_M_realloc_insert<double>(a1, v8, v10);
}
else
{
*v8 = v7;
a1[1] += 8LL;
}
++v6;
v4 = *a2;
}
while ( v6 < (a2[1] - *a2) >> 2 );
}
return a1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV R13,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP RDX,qword ptr [RSI + 0x8]
JZ 0x00101304
MOV R12,RSI
MOV EBX,0x0
MOV R14,RSP
JMP 0x001012a4
LAB_00101280:
MOV RDX,R14
MOV RDI,RBP
LAB_00101286:
CALL 0x00101a10
LAB_0010128b:
ADD RBX,0x1
MOV RDX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
SUB RAX,RDX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x00101304
LAB_001012a4:
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RDX + RBX*0x4]
MOV RAX,qword ptr [R13]
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RAX + RBX*0x4]
DIVSD XMM0,XMM1
MOVSD qword ptr [RSP],XMM0
MOV RSI,qword ptr [RBP + 0x8]
CMP RSI,qword ptr [RBP + 0x10]
JZ 0x00101280
MOVSD qword ptr [RSI],XMM0
ADD qword ptr [RBP + 0x8],0x8
JMP 0x0010128b
LAB_00101304:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101324
MOV RAX,RBP
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101324:
CALL 0x00101110 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
double *pdVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
long in_FS_OFFSET;
double local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
lVar2 = *(long *)param_2;
if (lVar2 != *(long *)(param_2 + 8)) {
uVar3 = 0;
do {
local_38 = (double)*(int *)(lVar2 + uVar3 * 4) / (double)*(int *)(*in_RDX + uVar3 * 4);
pdVar1 = *(double **)(param_1 + 8);
if (pdVar1 == *(double **)(param_1 + 0x10)) {
/* try { // try from 00101286 to 0010128a has its CatchHandler @ 001012d8 */
std::vector<double,std::allocator<double>>::_M_realloc_insert<double>
((vector<double,std::allocator<double>> *)param_1,(__normal_iterator)pdVar1,
&local_38);
}
else {
*pdVar1 = local_38;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 8;
}
uVar3 = uVar3 + 1;
lVar2 = *(long *)param_2;
} while (uVar3 < (ulong)(*(long *)(param_2 + 8) - lVar2 >> 2));
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,470 | func0 |
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<double> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(static_cast<double>(nums1[i]) / nums2[i]);
}
return result;
}
| int main() {
assert(func0({4,5,6},{1, 2, 3}) == std::vector<double>({4.0, 2.5, 2.0}));
assert(func0({3,2},{1,4}) == std::vector<double>({3.0, 0.5}));
assert(func0({90,120},{50,70}) == std::vector<double>({1.8, 1.7142857142857142}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov (%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
cmp 0x8(%rsi),%rdx
je 1850 <_Z5func0RKSt6vectorIiSaIiEES3_+0xc0>
mov %rsi,%rbp
xor %ecx,%ecx
xor %esi,%esi
xor %ebx,%ebx
mov %rsp,%r14
jmp 1813 <_Z5func0RKSt6vectorIiSaIiEES3_+0x83>
nopl 0x0(%rax)
movsd %xmm0,(%rsi)
add $0x8,%rsi
mov %rsi,0x8(%r12)
mov 0x8(%rbp),%rax
add $0x1,%rbx
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 1850 <_Z5func0RKSt6vectorIiSaIiEES3_+0xc0>
mov 0x8(%r12),%rsi
mov 0x10(%r12),%rcx
mov 0x0(%r13),%rax
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl (%rdx,%rbx,4),%xmm0
cvtsi2sdl (%rax,%rbx,4),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,(%rsp)
cmp %rcx,%rsi
jne 17e8 <_Z5func0RKSt6vectorIiSaIiEES3_+0x58>
mov %r14,%rdx
mov %r12,%rdi
callq 1a10 <_ZNSt6vectorIdSaIdEE17_M_realloc_insertIJdEEEvN9__gnu_cxx17__normal_iteratorIPdS1_EEDpOT_>
mov 0x0(%rbp),%rdx
jmp 17f5 <_Z5func0RKSt6vectorIiSaIiEES3_+0x65>
nopl 0x0(%rax,%rax,1)
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1870 <_Z5func0RKSt6vectorIiSaIiEES3_+0xe0>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1110 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1140 <_Z5func0RKSt6vectorIiSaIiEES3_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rdx, [rsi]
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
cmp [rsi+8], rdx
jz short loc_1790
mov r12, rsi
xor ecx, ecx
xor esi, esi
xor ebx, ebx
mov r14, rsp
jmp short loc_1759
loc_1730:
movsd qword ptr [rsi], xmm0
add rsi, 8
mov [rbp+8], rsi
loc_173C:
mov rax, [r12+8]
add rbx, 1
sub rax, rdx
sar rax, 2
cmp rbx, rax
jnb short loc_1790
mov rsi, [rbp+8]
mov rcx, [rbp+10h]
loc_1759:
mov rax, [r13+0]
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, dword ptr [rdx+rbx*4]
cvtsi2sd xmm1, dword ptr [rax+rbx*4]
divsd xmm0, xmm1
movsd [rsp+38h+var_38], xmm0
cmp rsi, rcx
jnz short loc_1730
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIdSaIdEE17_M_realloc_insertIJdEEEvN9__gnu_cxx17__normal_iteratorIPdS1_EEDpOT_; std::vector<double>::_M_realloc_insert<double>(__gnu_cxx::__normal_iterator<double *,std::vector<double>>,double &&)
mov rdx, [r12]
jmp short loc_173C
loc_1790:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_17B0
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_17B0:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEES3__cold; func0(std::vector<int> const&,std::vector<int> const&) [clone] | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
double *v6; // rcx
double *v7; // rsi
long long v8; // rbx
double v9; // xmm0_8
double v11[7]; // [rsp+0h] [rbp-38h] BYREF
v4 = *a2;
*(_QWORD *)&v11[1] = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
if ( a2[1] != v4 )
{
v6 = 0LL;
v7 = 0LL;
v8 = 0LL;
while ( 1 )
{
v9 = (double)*(int *)(v4 + 4 * v8) / (double)*(int *)(*a3 + 4 * v8);
v11[0] = v9;
if ( v7 == v6 )
{
std::vector<double>::_M_realloc_insert<double>(a1, v7, v11);
v4 = *a2;
}
else
{
*v7 = v9;
*(_QWORD *)(a1 + 8) = v7 + 1;
}
if ( ++v8 >= (unsigned long long)((a2[1] - v4) >> 2) )
break;
v7 = *(double **)(a1 + 8);
v6 = *(double **)(a1 + 16);
}
}
return a1;
} | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x00101790
MOV R12,RSI
XOR ECX,ECX
XOR ESI,ESI
XOR EBX,EBX
MOV R14,RSP
JMP 0x00101759
LAB_00101730:
MOVSD qword ptr [RSI],XMM0
ADD RSI,0x8
MOV qword ptr [RBP + 0x8],RSI
LAB_0010173c:
MOV RAX,qword ptr [R12 + 0x8]
ADD RBX,0x1
SUB RAX,RDX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x00101790
MOV RSI,qword ptr [RBP + 0x8]
MOV RCX,qword ptr [RBP + 0x10]
LAB_00101759:
MOV RAX,qword ptr [R13]
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,dword ptr [RDX + RBX*0x4]
CVTSI2SD XMM1,dword ptr [RAX + RBX*0x4]
DIVSD XMM0,XMM1
MOVSD qword ptr [RSP],XMM0
CMP RSI,RCX
JNZ 0x00101730
MOV RDX,R14
MOV RDI,RBP
LAB_00101783:
CALL 0x001019f0
MOV RDX,qword ptr [R12]
JMP 0x0010173c
LAB_00101790:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001017b0
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001017b0:
CALL 0x00101110 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
double *pdVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
double *pdVar4;
long in_FS_OFFSET;
double local_38;
long local_30;
lVar2 = *(long *)param_2;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
if (*(long *)(param_2 + 8) != lVar2) {
pdVar1 = (double *)0x0;
pdVar4 = (double *)0x0;
uVar3 = 0;
while( true ) {
local_38 = (double)*(int *)(lVar2 + uVar3 * 4) / (double)*(int *)(*in_RDX + uVar3 * 4);
if (pdVar4 == pdVar1) {
/* try { // try from 00101783 to 00101787 has its CatchHandler @ 001017b5 */
std::vector<double,std::allocator<double>>::_M_realloc_insert<double>
((vector<double,std::allocator<double>> *)param_1,(__normal_iterator)pdVar4,
&local_38);
lVar2 = *(long *)param_2;
}
else {
*pdVar4 = local_38;
*(double **)(param_1 + 8) = pdVar4 + 1;
}
uVar3 = uVar3 + 1;
if ((ulong)(*(long *)(param_2 + 8) - lVar2 >> 2) <= uVar3) break;
pdVar4 = *(double **)(param_1 + 8);
pdVar1 = *(double **)(param_1 + 0x10);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,471 | func0 |
#include <vector>
#include <cassert>
| std::vector<double> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<double> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(static_cast<double>(nums1[i]) / nums2[i]);
}
return result;
}
| int main() {
assert(func0({4,5,6},{1, 2, 3}) == std::vector<double>({4.0, 2.5, 2.0}));
assert(func0({3,2},{1,4}) == std::vector<double>({3.0, 0.5}));
assert(func0({90,120},{50,70}) == std::vector<double>({1.8, 1.7142857142857142}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov (%rsi),%rdx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
cmp 0x8(%rsi),%rdx
je 1810 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
mov %rsi,%rbp
xor %ecx,%ecx
xor %esi,%esi
xor %ebx,%ebx
mov %rsp,%r14
jmp 17db <_Z5func0RKSt6vectorIiSaIiEES3_+0x7b>
nopl 0x0(%rax)
movsd %xmm0,(%rsi)
add $0x8,%rsi
mov %rsi,0x8(%r12)
mov 0x8(%rbp),%rax
add $0x1,%rbx
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 1810 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
mov 0x8(%r12),%rsi
mov 0x10(%r12),%rcx
mov 0x0(%r13),%rax
pxor %xmm0,%xmm0
pxor %xmm1,%xmm1
cvtsi2sdl (%rdx,%rbx,4),%xmm0
cvtsi2sdl (%rax,%rbx,4),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,(%rsp)
cmp %rcx,%rsi
jne 17b0 <_Z5func0RKSt6vectorIiSaIiEES3_+0x50>
mov %r14,%rdx
mov %r12,%rdi
callq 19b0 <_ZNSt6vectorIdSaIdEE17_M_realloc_insertIJdEEEvN9__gnu_cxx17__normal_iteratorIPdS1_EEDpOT_>
mov 0x0(%rbp),%rdx
jmp 17bd <_Z5func0RKSt6vectorIiSaIiEES3_+0x5d>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1830 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd0>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1110 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1140 <_Z5func0RKSt6vectorIiSaIiEES3_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
mov r12, rdx
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rdx, [rsi]
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 rdi, [rsi+8]
cmp rdi, rdx
jz short loc_17B0
mov r13, rsi
xor ecx, ecx
xor esi, esi
xor ebx, ebx
mov r14, rsp
jmp short loc_1777
loc_1750:
movsd qword ptr [rsi], xmm0
add rsi, 8
mov [rbp+8], rsi
loc_175C:
mov rax, rdi
add rbx, 1
sub rax, rdx
sar rax, 2
cmp rbx, rax
jnb short loc_17B0
mov rsi, [rbp+8]
mov rcx, [rbp+10h]
loc_1777:
mov rax, [r12]
pxor xmm0, xmm0
pxor xmm1, xmm1
cvtsi2sd xmm0, dword ptr [rdx+rbx*4]
cvtsi2sd xmm1, dword ptr [rax+rbx*4]
divsd xmm0, xmm1
movsd [rsp+38h+var_38], xmm0
cmp rsi, rcx
jnz short loc_1750
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIdSaIdEE17_M_realloc_insertIJdEEEvN9__gnu_cxx17__normal_iteratorIPdS1_EEDpOT_; std::vector<double>::_M_realloc_insert<double>(__gnu_cxx::__normal_iterator<double *,std::vector<double>>,double &&)
mov rdi, [r13+8]
mov rdx, [r13+0]
jmp short loc_175C
loc_17B0:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_17D0
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_17D0:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEES3__cold; func0(std::vector<int> const&,std::vector<int> const&) [clone] | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v5; // rdx
long long v6; // rdi
double *v8; // rcx
double *v9; // rsi
long long v10; // rbx
double v11; // xmm0_8
double v13[7]; // [rsp+0h] [rbp-38h] BYREF
v5 = *a2;
*(_QWORD *)&v13[1] = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v6 = a2[1];
if ( v6 != v5 )
{
v8 = 0LL;
v9 = 0LL;
v10 = 0LL;
while ( 1 )
{
v11 = (double)*(int *)(v5 + 4 * v10) / (double)*(int *)(*a3 + 4 * v10);
v13[0] = v11;
if ( v9 == v8 )
{
std::vector<double>::_M_realloc_insert<double>(a1, v9, v13);
v6 = a2[1];
v5 = *a2;
}
else
{
*v9 = v11;
*(_QWORD *)(a1 + 8) = v9 + 1;
}
if ( ++v10 >= (unsigned long long)((v6 - v5) >> 2) )
break;
v9 = *(double **)(a1 + 8);
v8 = *(double **)(a1 + 16);
}
}
return a1;
} | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,qword ptr [RSI + 0x8]
CMP RDI,RDX
JZ 0x001017b0
MOV R13,RSI
XOR ECX,ECX
XOR ESI,ESI
XOR EBX,EBX
MOV R14,RSP
JMP 0x00101777
LAB_00101750:
MOVSD qword ptr [RSI],XMM0
ADD RSI,0x8
MOV qword ptr [RBP + 0x8],RSI
LAB_0010175c:
MOV RAX,RDI
ADD RBX,0x1
SUB RAX,RDX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x001017b0
MOV RSI,qword ptr [RBP + 0x8]
MOV RCX,qword ptr [RBP + 0x10]
LAB_00101777:
MOV RAX,qword ptr [R12]
PXOR XMM0,XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM0,dword ptr [RDX + RBX*0x4]
CVTSI2SD XMM1,dword ptr [RAX + RBX*0x4]
DIVSD XMM0,XMM1
MOVSD qword ptr [RSP],XMM0
CMP RSI,RCX
JNZ 0x00101750
MOV RDX,R14
MOV RDI,RBP
LAB_001017a1:
CALL 0x00101a10
MOV RDI,qword ptr [R13 + 0x8]
MOV RDX,qword ptr [R13]
JMP 0x0010175c
LAB_001017b0:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001017d0
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001017d0:
CALL 0x00101110 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
double *pdVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
double *pdVar4;
long lVar5;
long in_FS_OFFSET;
double local_38;
long local_30;
lVar2 = *(long *)param_2;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
lVar5 = *(long *)(param_2 + 8);
if (lVar5 != lVar2) {
pdVar1 = (double *)0x0;
pdVar4 = (double *)0x0;
uVar3 = 0;
while( true ) {
local_38 = (double)*(int *)(lVar2 + uVar3 * 4) / (double)*(int *)(*in_RDX + uVar3 * 4);
if (pdVar4 == pdVar1) {
/* try { // try from 001017a1 to 001017a5 has its CatchHandler @ 001017d5 */
std::vector<double,std::allocator<double>>::_M_realloc_insert<double>
((vector<double,std::allocator<double>> *)param_1,(__normal_iterator)pdVar4,
&local_38);
lVar5 = *(long *)(param_2 + 8);
lVar2 = *(long *)param_2;
}
else {
*pdVar4 = local_38;
*(double **)(param_1 + 8) = pdVar4 + 1;
}
uVar3 = uVar3 + 1;
if ((ulong)(lVar5 - lVar2 >> 2) <= uVar3) break;
pdVar4 = *(double **)(param_1 + 8);
pdVar1 = *(double **)(param_1 + 0x10);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,472 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
using namespace std;
| string func0(string test_str) {
string res = "";
string dig = "";
for (char ele : test_str) {
if (isdigit(ele)) {
dig += ele;
} else {
res += ele;
}
}
res += dig;
return res;
}
| int main() {
assert(func0("I1love143you55three3000thousand") == "Iloveyouthreethousand1143553000");
assert(func0("Avengers124Assemble") == "AvengersAssemble124");
assert(func0("Its11our12path13to14see15things16do17things") == "Itsourpathtoseethingsdothings11121314151617");
cout << "All tests passed successfully." << endl;
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 23b0 <_ZNSaIcEC1Ev@plt>
lea -0x50(%rbp),%rdx
mov -0x68(%rbp),%rax
lea 0xb00(%rip),%rsi
mov %rax,%rdi
callq 2aa6 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1IS3_EEPKcRKS3_>
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2310 <_ZNSaIcED1Ev@plt>
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 23b0 <_ZNSaIcEC1Ev@plt>
lea -0x50(%rbp),%rdx
lea -0x40(%rbp),%rax
lea 0xad1(%rip),%rsi
mov %rax,%rdi
callq 2aa6 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1IS3_EEPKcRKS3_>
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2310 <_ZNSaIcED1Ev@plt>
mov -0x70(%rbp),%rax
mov %rax,-0x48(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 22c0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv@plt>
mov %rax,-0x58(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 2240 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv@plt>
mov %rax,-0x50(%rbp)
lea -0x50(%rbp),%rdx
lea -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2b42 <_ZN9__gnu_cxxneIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESD_>
test %al,%al
je 25e4 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x11b>
lea -0x58(%rbp),%rax
mov %rax,%rdi
callq 2ba6 <_ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv>
movzbl (%rax),%eax
mov %al,-0x59(%rbp)
movsbl -0x59(%rbp),%eax
sub $0x30,%eax
cmp $0x9,%eax
setbe %al
movzbl %al,%eax
test %eax,%eax
je 25c4 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xfb>
movsbl -0x59(%rbp),%edx
lea -0x40(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 2260 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLEc@plt>
jmp 25d6 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10d>
movsbl -0x59(%rbp),%edx
mov -0x68(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 2260 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLEc@plt>
lea -0x58(%rbp),%rax
mov %rax,%rdi
callq 2b82 <_ZN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEv>
jmp 2573 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xaa>
lea -0x40(%rbp),%rdx
mov -0x68(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2360 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLERKS4_@plt>
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 2250 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 2678 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1af>
jmp 2673 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1aa>
endbr64
mov %rax,%rbx
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2310 <_ZNSaIcED1Ev@plt>
mov %rbx,%rax
mov %rax,%rdi
callq 23a0 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbx
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2310 <_ZNSaIcED1Ev@plt>
jmp 265c <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x193>
endbr64
mov %rax,%rbx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 2250 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
mov -0x68(%rbp),%rax
mov %rax,%rdi
callq 2250 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
mov %rbx,%rax
mov %rax,%rdi
callq 23a0 <_Unwind_Resume@plt>
callq 2340 <__stack_chk_fail@plt>
mov -0x68(%rbp),%rax
add $0x68,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_60]
mov [rbp+var_50], rax
nop
nop
lea rdx, [rbp+var_60]
mov rax, [rbp+var_78]
lea rcx, unk_3008
mov rsi, rcx
mov rdi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rbp+var_60]
mov rdi, rax
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
nop
lea rax, [rbp+var_60]
mov [rbp+var_48], rax
nop
nop
lea rdx, [rbp+var_60]
lea rax, [rbp+var_40]
lea rcx, unk_3008
mov rsi, rcx
mov rdi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rbp+var_60]
mov rdi, rax
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
nop
mov rax, [rbp+var_80]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rbp+var_68], rax
mov rax, [rbp+var_58]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rbp+var_60], rax
jmp short loc_2531
loc_24D9:
lea rax, [rbp+var_68]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char *,std::string>::operator*(void)
movzx eax, byte ptr [rax]
mov [rbp+var_69], al
movsx eax, [rbp+var_69]
sub eax, 30h ; '0'
cmp eax, 9
setbe al
movzx eax, al
test eax, eax
jz short loc_2513
movsx edx, [rbp+var_69]
lea rax, [rbp+var_40]
mov esi, edx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLEc; std::string::operator+=(char)
jmp short loc_2525
loc_2513:
movsx edx, [rbp+var_69]
mov rax, [rbp+var_78]
mov esi, edx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLEc; std::string::operator+=(char)
loc_2525:
lea rax, [rbp+var_68]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEv; __gnu_cxx::__normal_iterator<char *,std::string>::operator++(void)
loc_2531:
lea rdx, [rbp+var_60]
lea rax, [rbp+var_68]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESD_; __gnu_cxx::operator!=<char *,std::string>(__gnu_cxx::__normal_iterator<char *,std::string> const&,__gnu_cxx::__normal_iterator<char *,std::string> const&)
test al, al
jnz short loc_24D9
lea rdx, [rbp+var_40]
mov rax, [rbp+var_78]
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLERKS4_; std::string::operator+=(std::string const&)
nop
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
nop
mov rax, [rbp+var_18]
sub rax, fs:28h
jz loc_260D
jmp loc_2608
endbr64
mov rbx, rax
lea rax, [rbp+var_60]
mov rdi, rax
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
nop
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_25AC
call ___stack_chk_fail
loc_25AC:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
endbr64
mov rbx, rax
lea rax, [rbp+var_60]
mov rdi, rax
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
nop
jmp short loc_25DD
endbr64
mov rbx, rax
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_25DD:
mov rax, [rbp+var_78]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_2600
call ___stack_chk_fail
loc_2600:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_2608:
call ___stack_chk_fail
loc_260D:
mov rax, [rbp+var_78]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2)
{
char v3; // [rsp+17h] [rbp-69h]
long long v4; // [rsp+18h] [rbp-68h] BYREF
long long v5; // [rsp+20h] [rbp-60h] BYREF
long long v6; // [rsp+28h] [rbp-58h]
long long *v7; // [rsp+30h] [rbp-50h]
long long *v8; // [rsp+38h] [rbp-48h]
_BYTE v9[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v10; // [rsp+68h] [rbp-18h]
v10 = __readfsqword(0x28u);
v7 = &v5;
std::string::basic_string<std::allocator<char>>(a1, &unk_3008, &v5);
std::__new_allocator<char>::~__new_allocator(&v5);
v8 = &v5;
std::string::basic_string<std::allocator<char>>(v9, &unk_3008, &v5);
std::__new_allocator<char>::~__new_allocator(&v5);
v6 = a2;
v4 = std::string::begin(a2);
v5 = std::string::end(v6);
while ( (unsigned __int8)__gnu_cxx::operator!=<char *,std::string>(&v4, &v5) )
{
v3 = *(_BYTE *)__gnu_cxx::__normal_iterator<char *,std::string>::operator*(&v4);
if ( (unsigned int)(v3 - 48) > 9 )
std::string::operator+=(a1, (unsigned int)v3);
else
std::string::operator+=(v9, (unsigned int)v3);
__gnu_cxx::__normal_iterator<char *,std::string>::operator++(&v4);
}
std::string::operator+=(a1, v9);
std::string::~string(v9);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x60]
MOV qword ptr [RBP + -0x50],RAX
NOP
NOP
LEA RDX,[RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x78]
LEA RCX,[0x103008]
MOV RSI,RCX
MOV RDI,RAX
LAB_0010246c:
CALL 0x00102b3e
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x00102d00
NOP
LEA RAX,[RBP + -0x60]
MOV qword ptr [RBP + -0x48],RAX
NOP
NOP
LEA RDX,[RBP + -0x60]
LEA RAX,[RBP + -0x40]
LEA RCX,[0x103008]
MOV RSI,RCX
MOV RDI,RAX
LAB_0010249d:
CALL 0x00102b3e
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x00102d00
NOP
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
CALL 0x00102270
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
CALL 0x001021e0
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00102531
LAB_001024d9:
LEA RAX,[RBP + -0x68]
MOV RDI,RAX
CALL 0x00102c4a
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x69],AL
MOVSX EAX,byte ptr [RBP + -0x69]
SUB EAX,0x30
CMP EAX,0x9
SETBE AL
MOVZX EAX,AL
TEST EAX,EAX
JZ 0x00102513
MOVSX EDX,byte ptr [RBP + -0x69]
LEA RAX,[RBP + -0x40]
MOV ESI,EDX
MOV RDI,RAX
LAB_0010250c:
CALL 0x00102200
JMP 0x00102525
LAB_00102513:
MOVSX EDX,byte ptr [RBP + -0x69]
MOV RAX,qword ptr [RBP + -0x78]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00102200
LAB_00102525:
LEA RAX,[RBP + -0x68]
MOV RDI,RAX
CALL 0x00102c26
LAB_00102531:
LEA RDX,[RBP + -0x60]
LEA RAX,[RBP + -0x68]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102be6
TEST AL,AL
JNZ 0x001024d9
LEA RDX,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x78]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001022f0
NOP
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x001021f0
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010260d
JMP 0x00102608
LAB_00102608:
CALL 0x001022d0
LAB_0010260d:
MOV RAX,qword ptr [RBP + -0x78]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::string) */
string * func0(string *param_1,int8 param_2)
{
char cVar1;
bool bVar2;
char *pcVar3;
long in_FS_OFFSET;
int8 local_70;
int8 local_68;
int8 local_60;
int8 *local_58;
int8 *local_50;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = &local_68;
/* try { // try from 0010246c to 00102470 has its CatchHandler @ 00102581 */
std::string::string<std::allocator<char>>(param_1,"",(allocator *)&local_68);
std::__new_allocator<char>::~__new_allocator((__new_allocator<char> *)&local_68);
local_50 = &local_68;
/* try { // try from 0010249d to 001024a1 has its CatchHandler @ 001025b4 */
std::string::string<std::allocator<char>>(local_48,"",(allocator *)&local_68);
std::__new_allocator<char>::~__new_allocator((__new_allocator<char> *)&local_68);
local_60 = param_2;
local_70 = std::string::begin();
local_68 = std::string::end();
while( true ) {
bVar2 = operator!=((__normal_iterator *)&local_70,(__normal_iterator *)&local_68);
if (!bVar2) break;
pcVar3 = (char *)__normal_iterator<char*,std::string>::operator*
((__normal_iterator<char*,std::string> *)&local_70);
cVar1 = *pcVar3;
if ((int)cVar1 - 0x30U < 10) {
/* try { // try from 0010250c to 0010255a has its CatchHandler @ 001025ca */
std::string::operator+=(local_48,cVar1);
}
else {
std::string::operator+=(param_1,cVar1);
}
__normal_iterator<char*,std::string>::operator++
((__normal_iterator<char*,std::string> *)&local_70);
}
std::string::operator+=(param_1,local_48);
std::string::~string(local_48);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,473 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
using namespace std;
| string func0(string test_str) {
string res = "";
string dig = "";
for (char ele : test_str) {
if (isdigit(ele)) {
dig += ele;
} else {
res += ele;
}
}
res += dig;
return res;
}
| int main() {
assert(func0("I1love143you55three3000thousand") == "Iloveyouthreethousand1143553000");
assert(func0("Avengers124Assemble") == "AvengersAssemble124");
assert(func0("Its11our12path13to14see15things16do17things") == "Itsourpathtoseethingsdothings11121314151617");
cout << "All tests passed successfully." << endl;
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%rbp
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
mov %rax,0x8(%rsp)
mov %rax,(%rdi)
lea 0xd18(%rip),%rdx
mov %rdx,%rsi
callq 1742 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag>
lea 0x10(%rsp),%rdi
lea 0x20(%rsp),%rax
mov %rax,0x10(%rsp)
lea 0xcfa(%rip),%rdx
mov %rdx,%rsi
callq 1742 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag>
mov (%r12),%rbx
mov %rbx,%r14
add 0x8(%r12),%r14
cmp %r14,%rbx
jne 139b <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xb2>
mov 0x18(%rsp),%rdx
mov 0x10(%rsp),%rsi
mov %rbp,%rdi
callq 1130 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm@plt>
jmpq 1444 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x15b>
mov $0xf,%eax
jmp 13c5 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xdc>
mov 0x10(%rsp),%rax
mov %r12b,(%rax,%r13,1)
mov %r15,0x18(%rsp)
mov 0x10(%rsp),%rax
movb $0x0,0x1(%rax,%r13,1)
add $0x1,%rbx
cmp %rbx,%r14
je 135b <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x72>
movzbl (%rbx),%r12d
movsbl %r12b,%eax
sub $0x30,%eax
cmp $0x9,%eax
ja 13e9 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x100>
mov 0x18(%rsp),%r13
lea 0x1(%r13),%r15
lea 0x20(%rsp),%rax
cmp %rax,0x10(%rsp)
je 1372 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x89>
mov 0x20(%rsp),%rax
cmp %rax,%r15
jbe 1379 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x90>
lea 0x10(%rsp),%rdi
mov $0x1,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %r13,%rsi
callq 11f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm@plt>
jmp 1379 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x90>
mov 0x8(%rbp),%r13
lea 0x1(%r13),%r15
mov 0x8(%rsp),%rax
cmp 0x0(%rbp),%rax
je 1420 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x137>
mov 0x10(%rbp),%rax
cmp %rax,%r15
ja 1427 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x13e>
mov 0x0(%rbp),%rax
mov %r12b,(%rax,%r13,1)
mov %r15,0x8(%rbp)
mov 0x0(%rbp),%rax
movb $0x0,0x1(%rax,%r13,1)
jmpq 1392 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xa9>
mov $0xf,%eax
jmp 1400 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x117>
mov $0x1,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %r13,%rsi
mov %rbp,%rdi
callq 11f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm@plt>
jmp 1405 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x11c>
mov 0x10(%rsp),%rdi
lea 0x20(%rsp),%rax
cmp %rax,%rdi
je 1458 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x16f>
callq 1190 <_ZdlPv@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 14b6 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1cd>
mov %rbp,%rax
add $0x48,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
endbr64
mov %rax,%rbx
mov 0x10(%rsp),%rdi
lea 0x20(%rsp),%rax
cmp %rax,%rdi
je 1495 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1ac>
callq 1190 <_ZdlPv@plt>
mov 0x0(%rbp),%rdi
cmp 0x8(%rsp),%rdi
je 14a5 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1bc>
callq 1190 <_ZdlPv@plt>
mov %rbx,%rdi
callq 11d0 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbx
jmp 1495 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1ac>
callq 11a0 <__stack_chk_fail@plt>
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rbp, rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rsp+78h+var_78], rax
mov [rdi], rax
lea rbx, function+0Ah; ""
mov rdx, rbx
mov rsi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+78h+var_68]
lea rax, [rsp+78h+var_58]
mov [rsp+78h+var_68], rax
mov rdx, rbx
mov rsi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rbx, [r12]
mov r14, rbx
add r14, [r12+8]
cmp rbx, r14
jz loc_145E
lea rax, [rsp+78h+var_58]
mov [rsp+78h+var_70], rax
jmp short loc_13B6
loc_1389:
mov eax, 0Fh
jmp short loc_13E0
loc_1390:
mov rax, [rsp+78h+var_68]
mov [rax+r13], r12b
mov [rsp+78h+var_60], r15
mov rax, [rsp+78h+var_68]
mov byte ptr [rax+r13+1], 0
loc_13A9:
add rbx, 1
cmp r14, rbx
jz loc_145E
loc_13B6:
movzx r12d, byte ptr [rbx]
movsx eax, r12b
sub eax, 30h ; '0'
cmp eax, 9
ja short loc_1404
mov r13, [rsp+78h+var_60]
lea r15, [r13+1]
mov rax, [rsp+78h+var_70]
cmp [rsp+78h+var_68], rax
jz short loc_1389
mov rax, [rsp+78h+var_58]
loc_13E0:
cmp rax, r15
jnb short loc_1390
lea rdi, [rsp+78h+var_68]
mov r8d, 1
mov ecx, 0
mov edx, 0
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm; std::string::_M_mutate(ulong,ulong,char const*,ulong)
jmp short loc_1390
loc_1404:
mov r13, [rbp+8]
lea r15, [r13+1]
mov rax, [rsp+78h+var_78]
cmp rax, [rbp+0]
jz short loc_143A
mov rax, [rbp+10h]
loc_141A:
cmp rax, r15
jb short loc_1441
loc_141F:
mov rax, [rbp+0]
mov [rax+r13], r12b
mov [rbp+8], r15
mov rax, [rbp+0]
mov byte ptr [rax+r13+1], 0
jmp loc_13A9
loc_143A:
mov eax, 0Fh
jmp short loc_141A
loc_1441:
mov r8d, 1
mov ecx, 0
mov edx, 0
mov rsi, r13
mov rdi, rbp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm; std::string::_M_mutate(ulong,ulong,char const*,ulong)
jmp short loc_141F
loc_145E:
mov rdx, [rsp+78h+var_60]
mov rsi, [rsp+78h+var_68]
mov rax, 3FFFFFFFFFFFFFFFh
sub rax, [rbp+8]
cmp rax, rdx
jb short loc_1485
mov rdi, rbp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
jmp short loc_14D4
loc_1485:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_14CF
lea rdi, aBasicStringApp; "basic_string::append"
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
endbr64
mov rbx, rax
lea rdi, [rsp+78h+var_68]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
loc_14B2:
mov rdi, rbp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jz short loc_151C
call ___stack_chk_fail
loc_14CF:
call ___stack_chk_fail
loc_14D4:
mov rdi, [rsp+78h+var_68]; void *
lea rax, [rsp+78h+var_58]
cmp rdi, rax
jz short loc_14F1
mov rax, [rsp+78h+var_58]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_14F1:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_1524
mov rax, rbp
add rsp, 48h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
endbr64
mov rbx, rax
jmp short loc_14B2
loc_151C:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1524:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v2; // rbx
char *v3; // r14
unsigned long long v4; // rax
char v5; // r12
unsigned long long v6; // r13
unsigned long long v7; // r15
long long v8; // r13
unsigned long long v9; // r15
unsigned long long v10; // rax
void *v12; // [rsp+10h] [rbp-68h] BYREF
unsigned long long v13; // [rsp+18h] [rbp-60h]
_QWORD v14[11]; // [rsp+20h] [rbp-58h] BYREF
v14[3] = __readfsqword(0x28u);
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "", "");
v12 = v14;
std::string::_M_construct<char const*>(&v12, "", "");
v2 = *a2;
v3 = &(*a2)[(_QWORD)a2[1]];
if ( *a2 != v3 )
{
do
{
v5 = *v2;
if ( (unsigned int)(*v2 - 48) > 9 )
{
v8 = a1[1];
v9 = v8 + 1;
if ( a1 + 2 == (_QWORD *)*a1 )
v10 = 15LL;
else
v10 = a1[2];
if ( v10 < v9 )
std::string::_M_mutate(a1, a1[1], 0LL, 0LL, 1LL);
*(_BYTE *)(*a1 + v8) = v5;
a1[1] = v9;
*(_BYTE *)(*a1 + v8 + 1) = 0;
}
else
{
v6 = v13;
v7 = v13 + 1;
if ( v12 == v14 )
v4 = 15LL;
else
v4 = v14[0];
if ( v4 < v7 )
std::string::_M_mutate(&v12, v13, 0LL, 0LL, 1LL);
*((_BYTE *)v12 + v6) = v5;
v13 = v7;
*((_BYTE *)v12 + v6 + 1) = 0;
}
++v2;
}
while ( v3 != v2 );
}
if ( 0x3FFFFFFFFFFFFFFFLL - a1[1] < v13 )
std::__throw_length_error("basic_string::append");
std::string::_M_append(a1, v12);
if ( v12 != v14 )
operator delete(v12, v14[0] + 1LL);
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RBP,RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RDI],RAX
LEA RBX,[0x102236]
MOV RDX,RBX
MOV RSI,RBX
LAB_00101349:
CALL 0x001017a2
LEA RDI,[RSP + 0x10]
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV RDX,RBX
MOV RSI,RBX
LAB_00101363:
CALL 0x001017a2
MOV RBX,qword ptr [R12]
MOV R14,RBX
ADD R14,qword ptr [R12 + 0x8]
CMP RBX,R14
JZ 0x0010145e
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001013b6
LAB_00101389:
MOV EAX,0xf
JMP 0x001013e0
LAB_00101390:
MOV RAX,qword ptr [RSP + 0x10]
MOV byte ptr [RAX + R13*0x1],R12B
MOV qword ptr [RSP + 0x18],R15
MOV RAX,qword ptr [RSP + 0x10]
MOV byte ptr [RAX + R13*0x1 + 0x1],0x0
LAB_001013a9:
ADD RBX,0x1
CMP R14,RBX
JZ 0x0010145e
LAB_001013b6:
MOVZX R12D,byte ptr [RBX]
MOVSX EAX,R12B
SUB EAX,0x30
CMP EAX,0x9
JA 0x00101404
MOV R13,qword ptr [RSP + 0x18]
LEA R15,[R13 + 0x1]
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RSP + 0x10],RAX
JZ 0x00101389
MOV RAX,qword ptr [RSP + 0x20]
LAB_001013e0:
CMP RAX,R15
JNC 0x00101390
LEA RDI,[RSP + 0x10]
MOV R8D,0x1
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,R13
LAB_001013fd:
CALL 0x00101210
JMP 0x00101390
LAB_00101404:
MOV R13,qword ptr [RBP + 0x8]
LEA R15,[R13 + 0x1]
MOV RAX,qword ptr [RSP]
CMP RAX,qword ptr [RBP]
JZ 0x0010143a
MOV RAX,qword ptr [RBP + 0x10]
LAB_0010141a:
CMP RAX,R15
JC 0x00101441
LAB_0010141f:
MOV RAX,qword ptr [RBP]
MOV byte ptr [RAX + R13*0x1],R12B
MOV qword ptr [RBP + 0x8],R15
MOV RAX,qword ptr [RBP]
MOV byte ptr [RAX + R13*0x1 + 0x1],0x0
JMP 0x001013a9
LAB_0010143a:
MOV EAX,0xf
JMP 0x0010141a
LAB_00101441:
MOV R8D,0x1
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,R13
MOV RDI,RBP
CALL 0x00101210
JMP 0x0010141f
LAB_0010145e:
MOV RDX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
MOV RAX,0x3fffffffffffffff
SUB RAX,qword ptr [RBP + 0x8]
CMP RAX,RDX
JC 0x00101485
MOV RDI,RBP
CALL 0x00101130
JMP 0x001014d4
LAB_00101485:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014cf
LEA RDI,[0x102217]
CALL 0x00101170
LAB_001014a1:
ENDBR64
MOV RBX,RAX
LEA RDI,[RSP + 0x10]
CALL 0x001011e0
LAB_001014b2:
MOV RDI,RBP
CALL 0x001011e0
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010151c
CALL 0x001011d0
LAB_001014cf:
CALL 0x001011d0
LAB_001014d4:
MOV RDI,qword ptr [RSP + 0x10]
LEA RAX,[RSP + 0x20]
CMP RDI,RAX
JZ 0x001014f1
MOV RAX,qword ptr [RSP + 0x20]
LEA RSI,[RAX + 0x1]
CALL 0x001011c0
LAB_001014f1:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101524
MOV RAX,RBP
ADD RSP,0x48
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010151c:
MOV RDI,RBX
LAB_0010151f:
CALL 0x001011f0
LAB_00101524:
CALL 0x001011d0 | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
char cVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
int8 uVar5;
char *pcVar6;
char *pcVar7;
long in_FS_OFFSET;
ulong *local_68;
ulong local_60;
ulong local_58 [3];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*param_1 = (long)(param_1 + 2);
std::string::_M_construct<char_const*>((char *)param_1,"",0x102236);
local_68 = local_58;
/* try { // try from 00101363 to 00101367 has its CatchHandler @ 00101513 */
std::string::_M_construct<char_const*>((char *)&local_68,"",0x102236);
pcVar6 = (char *)*param_2;
pcVar7 = pcVar6 + param_2[1];
if (pcVar6 != pcVar7) {
do {
uVar2 = local_60;
cVar1 = *pcVar6;
if ((int)cVar1 - 0x30U < 10) {
uVar4 = local_60 + 1;
uVar3 = local_58[0];
if (local_68 == local_58) {
uVar3 = 0xf;
}
if (uVar3 < uVar4) {
/* try { // try from 001013fd to 001014a0 has its CatchHandler @ 001014a1 */
std::string::_M_mutate((ulong)&local_68,local_60,(char *)0x0,0);
}
*(char *)((long)local_68 + uVar2) = cVar1;
*(int *)((long)local_68 + uVar2 + 1) = 0;
local_60 = uVar4;
}
else {
uVar2 = param_1[1];
if (param_1 + 2 == (long *)*param_1) {
uVar4 = 0xf;
}
else {
uVar4 = param_1[2];
}
if (uVar4 < uVar2 + 1) {
std::string::_M_mutate((ulong)param_1,uVar2,(char *)0x0,0);
}
*(char *)(*param_1 + uVar2) = cVar1;
param_1[1] = uVar2 + 1;
*(int *)(*param_1 + 1 + uVar2) = 0;
}
pcVar6 = pcVar6 + 1;
} while (pcVar7 != pcVar6);
}
if (local_60 <= 0x3fffffffffffffffU - param_1[1]) {
std::string::_M_append((char *)param_1,(ulong)local_68);
if (local_68 != local_58) {
operator_delete(local_68,local_58[0] + 1);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
uVar5 = std::__throw_length_error("basic_string::append");
/* catch() { ... } // from try @ 001013fd with catch @ 001014a1 */
std::string::_M_dispose();
std::string::_M_dispose();
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar5);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,474 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
using namespace std;
| string func0(string test_str) {
string res = "";
string dig = "";
for (char ele : test_str) {
if (isdigit(ele)) {
dig += ele;
} else {
res += ele;
}
}
res += dig;
return res;
}
| int main() {
assert(func0("I1love143you55three3000thousand") == "Iloveyouthreethousand1143553000");
assert(func0("Avengers124Assemble") == "AvengersAssemble124");
assert(func0("Its11our12path13to14see15things16do17things") == "Itsourpathtoseethingsdothings11121314151617");
cout << "All tests passed successfully." << endl;
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x48,%rsp
mov 0x8(%rsi),%r14
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x0,0x8(%rdi)
mov %rax,(%rdi)
mov (%rsi),%rbx
mov %rax,0x8(%rsp)
lea 0x20(%rsp),%rax
add %rbx,%r14
movb $0x0,0x10(%rdi)
mov %rax,(%rsp)
mov %rax,0x10(%rsp)
movq $0x0,0x18(%rsp)
movb $0x0,0x20(%rsp)
cmp %r14,%rbx
jne 1653 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xb3>
jmpq 1750 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1b0>
nopl (%rax)
mov 0x18(%rsp),%r13
mov 0x10(%rsp),%rax
mov $0xf,%edx
cmp (%rsp),%rax
cmovne 0x20(%rsp),%rdx
lea 0x1(%r13),%r15
cmp %rdx,%r15
ja 16f0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x150>
mov %bpl,(%rax,%r13,1)
mov 0x10(%rsp),%rax
add $0x1,%rbx
mov %r15,0x18(%rsp)
movb $0x0,0x1(%rax,%r13,1)
cmp %rbx,%r14
je 16a2 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x102>
movsbl (%rbx),%eax
mov %eax,%ebp
sub $0x30,%eax
cmp $0x9,%eax
jbe 1610 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x70>
mov 0x8(%r12),%r13
mov (%r12),%rax
lea 0x1(%r13),%r15
cmp %rax,0x8(%rsp)
je 1740 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1a0>
mov 0x10(%r12),%rdx
cmp %rdx,%r15
ja 1718 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x178>
mov %bpl,(%rax,%r13,1)
mov (%r12),%rax
add $0x1,%rbx
mov %r15,0x8(%r12)
movb $0x0,0x1(%rax,%r13,1)
cmp %rbx,%r14
jne 1653 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xb3>
mov 0x18(%rsp),%rdx
mov 0x10(%rsp),%rsi
mov %r12,%rdi
callq 1140 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm@plt>
mov 0x10(%rsp),%rdi
cmp (%rsp),%rdi
je 16c4 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x124>
callq 11b0 <_ZdlPv@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 175b <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1bb>
add $0x48,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
lea 0x10(%rsp),%rdi
mov $0x1,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %r13,%rsi
callq 1210 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm@plt>
mov 0x10(%rsp),%rax
jmpq 1636 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x96>
nopl 0x0(%rax)
mov $0x1,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 1210 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm@plt>
mov (%r12),%rax
jmpq 1686 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xe6>
nopw %cs:0x0(%rax,%rax,1)
mov $0xf,%edx
jmpq 167d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xdd>
nopw 0x0(%rax,%rax,1)
mov (%rsp),%rsi
xor %edx,%edx
jmpq 16ac <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10c>
callq 11c0 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1220 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
nopl 0x0(%rax)
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
lea rbx, function+0Ah; ""
mov rdx, rbx
mov rsi, rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rdi], rax
mov [rsp+88h+var_78], rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag_isra_0; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag) [clone]
lea rax, [rsp+88h+var_58]
mov rdx, rbx
mov rsi, rbx
lea rdi, [rsp+88h+var_68]
mov [rsp+88h+var_80], rax
mov [rsp+88h+var_70], rdi
mov [rsp+88h+var_68], rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag_isra_0; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag) [clone]
mov rbx, [r12]
mov r14, [r12+8]
add r14, rbx
cmp rbx, r14
jnz short loc_1777
jmp loc_17C4
loc_1730:
mov r13, [rsp+88h+var_60]
mov rax, [rsp+88h+var_68]
mov rcx, [rsp+88h+var_80]
lea r15, [r13+1]
cmp rax, rcx
jz loc_1890
mov rdx, [rsp+88h+var_58]
loc_1751:
cmp rdx, r15
jb loc_1830
loc_175A:
mov [rax+r13], r12b
mov rax, [rsp+88h+var_68]
add rbx, 1
mov [rsp+88h+var_60], r15
mov byte ptr [rax+r13+1], 0
cmp r14, rbx
jz short loc_17C4
loc_1777:
movsx eax, byte ptr [rbx]
mov r12d, eax
sub eax, 30h ; '0'
cmp eax, 9
jbe short loc_1730
mov r13, [rbp+8]
mov rax, [rbp+0]
lea r15, [r13+1]
cmp [rsp+88h+var_78], rax
jz loc_1880
mov rdx, [rbp+10h]
loc_17A0:
cmp rdx, r15
jb loc_1858
loc_17A9:
mov [rax+r13], r12b
mov rax, [rbp+0]
add rbx, 1
mov [rbp+8], r15
mov byte ptr [rax+r13+1], 0
cmp r14, rbx
jnz short loc_1777
loc_17C4:
mov rdx, [rsp+88h+var_60]
mov rsi, [rsp+88h+var_68]
mov rax, 3FFFFFFFFFFFFFFFh
sub rax, [rbp+8]
cmp rax, rdx
jb loc_189A
mov rdi, rbp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+88h+var_68]; void *
mov rax, [rsp+88h+var_80]
cmp rdi, rax
jz short loc_180A
mov rax, [rsp+88h+var_58]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_180A:
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz loc_18B6
add rsp, 58h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1830:
mov rdi, [rsp+88h+var_70]
mov r8d, 1
xor ecx, ecx
xor edx, edx
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm; std::string::_M_mutate(ulong,ulong,char const*,ulong)
mov rax, [rsp+88h+var_68]
jmp loc_175A
loc_1858:
mov r8d, 1
xor ecx, ecx
xor edx, edx
mov rsi, r13
mov rdi, rbp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm; std::string::_M_mutate(ulong,ulong,char const*,ulong)
mov rax, [rbp+0]
jmp loc_17A9
loc_1880:
mov edx, 0Fh
jmp loc_17A0
loc_1890:
mov edx, 0Fh
jmp loc_1751
loc_189A:
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz short loc_18B6
lea rdi, aBasicStringApp; "basic_string::append"
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_18B6:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string) [clone]
endbr64
mov rbx, rax
jmp loc_128A | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v2; // rbx
char *v3; // r14
unsigned long long v4; // r13
_BYTE *v5; // rax
unsigned long long v6; // r15
unsigned long long v7; // rdx
int v8; // r12d
long long v9; // r13
_QWORD *v10; // rax
unsigned long long v11; // r15
unsigned long long v12; // rdx
_QWORD *v13; // rax
void *v15; // [rsp+20h] [rbp-68h] BYREF
unsigned long long v16; // [rsp+28h] [rbp-60h]
_QWORD v17[11]; // [rsp+30h] [rbp-58h] BYREF
v17[3] = __readfsqword(0x28u);
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "", "");
v15 = v17;
std::string::_M_construct<char const*>(&v15, "", "");
v2 = *a2;
v3 = &a2[1][(_QWORD)*a2];
if ( *a2 != v3 )
{
do
{
while ( 1 )
{
v8 = *v2;
if ( (unsigned int)(v8 - 48) <= 9 )
break;
v9 = a1[1];
v10 = (_QWORD *)*a1;
v11 = v9 + 1;
if ( a1 + 2 == (_QWORD *)*a1 )
v12 = 15LL;
else
v12 = a1[2];
if ( v12 < v11 )
{
std::string::_M_mutate(a1, a1[1], 0LL, 0LL, 1LL);
v10 = (_QWORD *)*a1;
}
*((_BYTE *)v10 + v9) = v8;
v13 = (_QWORD *)*a1;
++v2;
a1[1] = v11;
*((_BYTE *)v13 + v9 + 1) = 0;
if ( v3 == v2 )
goto LABEL_14;
}
v4 = v16;
v5 = v15;
v6 = v16 + 1;
if ( v15 == v17 )
v7 = 15LL;
else
v7 = v17[0];
if ( v7 < v6 )
{
std::string::_M_mutate(&v15, v16, 0LL, 0LL, 1LL);
v5 = v15;
}
v5[v4] = v8;
++v2;
v16 = v6;
*((_BYTE *)v15 + v4 + 1) = 0;
}
while ( v3 != v2 );
}
LABEL_14:
if ( 0x3FFFFFFFFFFFFFFFLL - a1[1] < v16 )
std::__throw_length_error("basic_string::append");
std::string::_M_append(a1, v15);
if ( v15 != v17 )
operator delete(v15, v17[0] + 1LL);
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
LEA RBX,[0x102023]
MOV RDX,RBX
MOV RSI,RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV qword ptr [RSP + 0x10],RAX
LAB_001016f1:
CALL 0x00101600
LEA RAX,[RSP + 0x30]
MOV RDX,RBX
MOV RSI,RBX
LEA RDI,[RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x20],RAX
LAB_00101715:
CALL 0x00101600
MOV RBX,qword ptr [R12]
MOV R14,qword ptr [R12 + 0x8]
ADD R14,RBX
CMP RBX,R14
JNZ 0x00101777
JMP 0x001017c4
LAB_00101730:
MOV R13,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x8]
LEA R15,[R13 + 0x1]
CMP RAX,RCX
JZ 0x00101890
MOV RDX,qword ptr [RSP + 0x30]
LAB_00101751:
CMP RDX,R15
JC 0x00101830
LAB_0010175a:
MOV byte ptr [RAX + R13*0x1],R12B
MOV RAX,qword ptr [RSP + 0x20]
ADD RBX,0x1
MOV qword ptr [RSP + 0x28],R15
MOV byte ptr [RAX + R13*0x1 + 0x1],0x0
CMP R14,RBX
JZ 0x001017c4
LAB_00101777:
MOVSX EAX,byte ptr [RBX]
MOV R12D,EAX
SUB EAX,0x30
CMP EAX,0x9
JBE 0x00101730
MOV R13,qword ptr [RBP + 0x8]
MOV RAX,qword ptr [RBP]
LEA R15,[R13 + 0x1]
CMP qword ptr [RSP + 0x10],RAX
JZ 0x00101880
MOV RDX,qword ptr [RBP + 0x10]
LAB_001017a0:
CMP RDX,R15
JC 0x00101858
LAB_001017a9:
MOV byte ptr [RAX + R13*0x1],R12B
MOV RAX,qword ptr [RBP]
ADD RBX,0x1
MOV qword ptr [RBP + 0x8],R15
MOV byte ptr [RAX + R13*0x1 + 0x1],0x0
CMP R14,RBX
JNZ 0x00101777
LAB_001017c4:
MOV RDX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
MOV RAX,0x3fffffffffffffff
SUB RAX,qword ptr [RBP + 0x8]
CMP RAX,RDX
JC 0x0010189a
MOV RDI,RBP
LAB_001017e8:
CALL 0x00101170
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x8]
CMP RDI,RAX
JZ 0x0010180a
MOV RAX,qword ptr [RSP + 0x30]
LEA RSI,[RAX + 0x1]
CALL 0x00101200
LAB_0010180a:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001018b6
ADD RSP,0x58
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101830:
MOV RDI,qword ptr [RSP + 0x18]
MOV R8D,0x1
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,R13
CALL 0x00101270
MOV RAX,qword ptr [RSP + 0x20]
JMP 0x0010175a
LAB_00101858:
MOV R8D,0x1
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,R13
MOV RDI,RBP
CALL 0x00101270
MOV RAX,qword ptr [RBP]
JMP 0x001017a9
LAB_00101880:
MOV EDX,0xf
JMP 0x001017a0
LAB_00101890:
MOV EDX,0xf
JMP 0x00101751
LAB_0010189a:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001018b6
LEA RDI,[0x102004]
CALL 0x001011a0
LAB_001018b6:
CALL 0x00101210 | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
char cVar1;
ulong uVar2;
long *plVar3;
ulong uVar4;
ulong uVar5;
char *pcVar6;
char *pcVar7;
long in_FS_OFFSET;
ulong *local_68;
ulong local_60;
ulong local_58 [3];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*param_1 = (long)(param_1 + 2);
std::string::_M_construct<char_const*>((char *)param_1,"",0x102023);
local_68 = local_58;
/* try { // try from 00101715 to 00101719 has its CatchHandler @ 001018c7 */
std::string::_M_construct<char_const*>((char *)&local_68,"",0x102023);
pcVar6 = (char *)*param_2;
pcVar7 = pcVar6 + param_2[1];
for (; pcVar6 != pcVar7; pcVar6 = pcVar6 + 1) {
while (uVar2 = local_60, cVar1 = *pcVar6, (int)cVar1 - 0x30U < 10) {
uVar5 = local_60 + 1;
uVar4 = local_58[0];
if (local_68 == local_58) {
uVar4 = 0xf;
}
if (uVar4 < uVar5) {
std::string::_M_mutate((ulong)&local_68,local_60,(char *)0x0,0);
}
*(char *)((long)local_68 + uVar2) = cVar1;
pcVar6 = pcVar6 + 1;
*(int *)((long)local_68 + uVar2 + 1) = 0;
local_60 = uVar5;
if (pcVar7 == pcVar6) goto LAB_001017c4;
}
uVar2 = param_1[1];
plVar3 = (long *)*param_1;
if (param_1 + 2 == plVar3) {
uVar5 = 0xf;
}
else {
uVar5 = param_1[2];
}
if (uVar5 < uVar2 + 1) {
std::string::_M_mutate((ulong)param_1,uVar2,(char *)0x0,0);
plVar3 = (long *)*param_1;
}
*(char *)((long)plVar3 + uVar2) = cVar1;
param_1[1] = uVar2 + 1;
*(int *)(*param_1 + 1 + uVar2) = 0;
}
LAB_001017c4:
if (0x3fffffffffffffffU - param_1[1] < local_60) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("basic_string::append");
}
}
else {
/* try { // try from 001017e8 to 001018b5 has its CatchHandler @ 001018bb */
std::string::_M_append((char *)param_1,(ulong)local_68);
if (local_68 != local_58) {
operator_delete(local_68,local_58[0] + 1);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,475 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
using namespace std;
| string func0(string test_str) {
string res = "";
string dig = "";
for (char ele : test_str) {
if (isdigit(ele)) {
dig += ele;
} else {
res += ele;
}
}
res += dig;
return res;
}
| int main() {
assert(func0("I1love143you55three3000thousand") == "Iloveyouthreethousand1143553000");
assert(func0("Avengers124Assemble") == "AvengersAssemble124");
assert(func0("Its11our12path13to14see15things16do17things") == "Itsourpathtoseethingsdothings11121314151617");
cout << "All tests passed successfully." << endl;
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x48,%rsp
mov 0x8(%rsi),%r14
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
movq $0x0,0x8(%rdi)
mov %rax,(%rdi)
mov (%rsi),%rbx
mov %rax,0x8(%rsp)
lea 0x20(%rsp),%rax
add %rbx,%r14
movb $0x0,0x10(%rdi)
mov %rax,(%rsp)
mov %rax,0x10(%rsp)
movq $0x0,0x18(%rsp)
movb $0x0,0x20(%rsp)
cmp %r14,%rbx
jne 1653 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xb3>
jmpq 1750 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1b0>
nopl (%rax)
mov 0x18(%rsp),%r13
mov 0x10(%rsp),%rax
mov $0xf,%edx
cmp (%rsp),%rax
cmovne 0x20(%rsp),%rdx
lea 0x1(%r13),%r15
cmp %rdx,%r15
ja 16f0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x150>
mov %bpl,(%rax,%r13,1)
mov 0x10(%rsp),%rax
add $0x1,%rbx
mov %r15,0x18(%rsp)
movb $0x0,0x1(%rax,%r13,1)
cmp %rbx,%r14
je 16a2 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x102>
movsbl (%rbx),%eax
mov %eax,%ebp
sub $0x30,%eax
cmp $0x9,%eax
jbe 1610 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x70>
mov 0x8(%r12),%r13
mov (%r12),%rax
lea 0x1(%r13),%r15
cmp %rax,0x8(%rsp)
je 1740 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1a0>
mov 0x10(%r12),%rdx
cmp %rdx,%r15
ja 1718 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x178>
mov %bpl,(%rax,%r13,1)
mov (%r12),%rax
add $0x1,%rbx
mov %r15,0x8(%r12)
movb $0x0,0x1(%rax,%r13,1)
cmp %rbx,%r14
jne 1653 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xb3>
mov 0x18(%rsp),%rdx
mov 0x10(%rsp),%rsi
mov %r12,%rdi
callq 1140 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm@plt>
mov 0x10(%rsp),%rdi
cmp (%rsp),%rdi
je 16c4 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x124>
callq 11b0 <_ZdlPv@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 175a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1ba>
add $0x48,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
lea 0x10(%rsp),%rdi
mov $0x1,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %r13,%rsi
callq 1210 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm@plt>
mov 0x10(%rsp),%rax
jmpq 1636 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x96>
nopl 0x0(%rax)
mov $0x1,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %r13,%rsi
mov %r12,%rdi
callq 1210 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm@plt>
mov (%r12),%rax
jmpq 1686 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xe6>
nopw %cs:0x0(%rax,%rax,1)
mov $0xf,%edx
jmpq 167d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xdd>
nopw 0x0(%rax,%rax,1)
mov %rax,%rsi
xor %edx,%edx
jmpq 16ac <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10c>
callq 11c0 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1220 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
nopl 0x0(%rax,%rax,1)
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov byte ptr [rdi+10h], 0
mov [rdi], rax
mov rbx, [rsi]
mov qword ptr [rdi+8], 0
mov r14, [rsi+8]
mov [rsp+88h+var_80], rax
lea rax, [rsp+88h+var_58]
add r14, rbx
mov [rsp+88h+var_88], rax
mov [rsp+88h+var_68], rax
mov [rsp+88h+var_60], 0
mov byte ptr [rsp+88h+var_58], 0
cmp rbx, r14
jz loc_1800
lea rax, [rsp+88h+var_68]
mov [rsp+88h+var_70], rax
jmp short loc_16B6
loc_1670:
mov r13, [rsp+88h+var_60]
mov rax, [rsp+88h+var_68]
mov rcx, [rsp+88h+var_88]
lea r15, [r13+1]
cmp rax, rcx
jz loc_17F0
mov rdx, [rsp+88h+var_58]
loc_1690:
cmp rdx, r15
jb loc_1780
loc_1699:
mov [rax+r13], r12b
mov rax, [rsp+88h+var_68]
add rbx, 1
mov [rsp+88h+var_60], r15
mov byte ptr [rax+r13+1], 0
cmp r14, rbx
jz short loc_1703
loc_16B6:
movsx eax, byte ptr [rbx]
mov r12d, eax
sub eax, 30h ; '0'
cmp eax, 9
jbe short loc_1670
mov r13, [rbp+8]
mov rax, [rbp+0]
lea r15, [r13+1]
cmp [rsp+88h+var_80], rax
jz loc_17E0
mov rdx, [rbp+10h]
loc_16DF:
cmp rdx, r15
jb loc_17B0
loc_16E8:
mov [rax+r13], r12b
mov rax, [rbp+0]
add rbx, 1
mov [rbp+8], r15
mov byte ptr [rax+r13+1], 0
cmp r14, rbx
jnz short loc_16B6
loc_1703:
mov rdx, [rsp+88h+var_60]
mov rsi, [rsp+88h+var_68]
mov rax, 3FFFFFFFFFFFFFFFh
sub rax, [rbp+8]
cmp rax, rdx
jb loc_180A
loc_1724:
lea rax, [rsp+88h+var_68]
mov rdi, rbp
mov [rsp+88h+var_78], rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+88h+var_68]; void *
mov rax, [rsp+88h+var_88]
cmp rdi, rax
jz short loc_1752
mov rax, [rsp+88h+var_58]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1752:
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz loc_1830
add rsp, 58h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1780:
mov rdi, [rsp+88h+var_70]
mov r8d, 1
xor ecx, ecx
xor edx, edx
mov rsi, r13
mov [rsp+88h+var_78], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm; std::string::_M_mutate(ulong,ulong,char const*,ulong)
mov rax, [rsp+88h+var_68]
jmp loc_1699
loc_17B0:
mov rax, [rsp+88h+var_70]
mov r8d, 1
xor ecx, ecx
xor edx, edx
mov rsi, r13
mov rdi, rbp
mov [rsp+88h+var_78], rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm; std::string::_M_mutate(ulong,ulong,char const*,ulong)
mov rax, [rbp+0]
jmp loc_16E8
loc_17E0:
mov edx, 0Fh
jmp loc_16DF
loc_17F0:
mov edx, 0Fh
jmp loc_1690
loc_1800:
mov rsi, rax
xor edx, edx
jmp loc_1724
loc_180A:
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz short loc_1830
lea rax, [rsp+88h+var_68]
lea rdi, aBasicStringApp; "basic_string::append"
mov [rsp+88h+var_78], rax
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_1830:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string) [clone] | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v2; // rbx
char *v3; // r14
unsigned long long v4; // r13
_BYTE *v5; // rax
unsigned long long v6; // r15
unsigned long long v7; // rdx
int v8; // r12d
long long v9; // r13
long long v10; // rax
unsigned long long v11; // r15
unsigned long long v12; // rdx
long long v13; // rax
_QWORD *v14; // rsi
void *v16; // [rsp+20h] [rbp-68h] BYREF
unsigned long long v17; // [rsp+28h] [rbp-60h]
_QWORD v18[11]; // [rsp+30h] [rbp-58h] BYREF
v18[3] = __readfsqword(0x28u);
*((_BYTE *)a1 + 16) = 0;
*a1 = a1 + 2;
v2 = *a2;
a1[1] = 0LL;
v3 = &a2[1][(_QWORD)v2];
v16 = v18;
v17 = 0LL;
LOBYTE(v18[0]) = 0;
if ( v2 == v3 )
{
v14 = v18;
}
else
{
do
{
while ( 1 )
{
v8 = *v2;
if ( (unsigned int)(v8 - 48) <= 9 )
break;
v9 = a1[1];
v10 = *a1;
v11 = v9 + 1;
if ( a1 + 2 == (_QWORD *)*a1 )
v12 = 15LL;
else
v12 = a1[2];
if ( v12 < v11 )
{
std::string::_M_mutate(a1, a1[1], 0LL, 0LL, 1LL);
v10 = *a1;
}
*(_BYTE *)(v10 + v9) = v8;
v13 = *a1;
++v2;
a1[1] = v11;
*(_BYTE *)(v13 + v9 + 1) = 0;
if ( v3 == v2 )
goto LABEL_14;
}
v4 = v17;
v5 = v16;
v6 = v17 + 1;
if ( v16 == v18 )
v7 = 15LL;
else
v7 = v18[0];
if ( v7 < v6 )
{
std::string::_M_mutate(&v16, v17, 0LL, 0LL, 1LL);
v5 = v16;
}
v5[v4] = v8;
++v2;
v17 = v6;
*((_BYTE *)v16 + v4 + 1) = 0;
}
while ( v3 != v2 );
LABEL_14:
v14 = v16;
if ( 0x3FFFFFFFFFFFFFFFLL - a1[1] < v17 )
std::__throw_length_error("basic_string::append");
}
std::string::_M_append(a1, v14);
if ( v16 != v18 )
operator delete(v16, v18[0] + 1LL);
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV byte ptr [RDI + 0x10],0x0
MOV qword ptr [RDI],RAX
MOV RBX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],0x0
MOV R14,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],RAX
LEA RAX,[RSP + 0x30]
ADD R14,RBX
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],0x0
MOV byte ptr [RSP + 0x30],0x0
CMP RBX,R14
JZ 0x00101800
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001016b6
LAB_00101670:
MOV R13,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP]
LEA R15,[R13 + 0x1]
CMP RAX,RCX
JZ 0x001017f0
MOV RDX,qword ptr [RSP + 0x30]
LAB_00101690:
CMP RDX,R15
JC 0x00101780
LAB_00101699:
MOV byte ptr [RAX + R13*0x1],R12B
MOV RAX,qword ptr [RSP + 0x20]
ADD RBX,0x1
MOV qword ptr [RSP + 0x28],R15
MOV byte ptr [RAX + R13*0x1 + 0x1],0x0
CMP R14,RBX
JZ 0x00101703
LAB_001016b6:
MOVSX EAX,byte ptr [RBX]
MOV R12D,EAX
SUB EAX,0x30
CMP EAX,0x9
JBE 0x00101670
MOV R13,qword ptr [RBP + 0x8]
MOV RAX,qword ptr [RBP]
LEA R15,[R13 + 0x1]
CMP qword ptr [RSP + 0x8],RAX
JZ 0x001017e0
MOV RDX,qword ptr [RBP + 0x10]
LAB_001016df:
CMP RDX,R15
JC 0x001017b0
LAB_001016e8:
MOV byte ptr [RAX + R13*0x1],R12B
MOV RAX,qword ptr [RBP]
ADD RBX,0x1
MOV qword ptr [RBP + 0x8],R15
MOV byte ptr [RAX + R13*0x1 + 0x1],0x0
CMP R14,RBX
JNZ 0x001016b6
LAB_00101703:
MOV RDX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
MOV RAX,0x3fffffffffffffff
SUB RAX,qword ptr [RBP + 0x8]
CMP RAX,RDX
JC 0x0010180a
LAB_00101724:
LEA RAX,[RSP + 0x20]
MOV RDI,RBP
MOV qword ptr [RSP + 0x10],RAX
LAB_00101731:
CALL 0x00101170
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP]
CMP RDI,RAX
JZ 0x00101752
MOV RAX,qword ptr [RSP + 0x30]
LEA RSI,[RAX + 0x1]
CALL 0x001011f0
LAB_00101752:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101830
ADD RSP,0x58
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101780:
MOV RDI,qword ptr [RSP + 0x18]
MOV R8D,0x1
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,R13
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00101270
MOV RAX,qword ptr [RSP + 0x20]
JMP 0x00101699
LAB_001017b0:
MOV RAX,qword ptr [RSP + 0x18]
MOV R8D,0x1
XOR ECX,ECX
XOR EDX,EDX
MOV RSI,R13
MOV RDI,RBP
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00101270
MOV RAX,qword ptr [RBP]
JMP 0x001016e8
LAB_001017e0:
MOV EDX,0xf
JMP 0x001016df
LAB_001017f0:
MOV EDX,0xf
JMP 0x00101690
LAB_00101800:
MOV RSI,RAX
XOR EDX,EDX
JMP 0x00101724
LAB_0010180a:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101830
LEA RAX,[RSP + 0x20]
LEA RDI,[0x102004]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001011a0
LAB_00101830:
CALL 0x00101200 | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
char cVar1;
ulong uVar2;
long *plVar3;
ulong uVar4;
ulong uVar5;
char *pcVar6;
char *pcVar7;
long in_FS_OFFSET;
int *local_68;
ulong local_60;
int local_58;
int7 uStack_57;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int *)(param_1 + 2) = 0;
*param_1 = (long)(param_1 + 2);
pcVar6 = (char *)*param_2;
param_1[1] = 0;
pcVar7 = pcVar6 + param_2[1];
local_60 = 0;
local_58 = 0;
local_68 = &local_58;
if (pcVar6 != pcVar7) {
do {
while (uVar2 = local_60, cVar1 = *pcVar6, (int)cVar1 - 0x30U < 10) {
uVar4 = local_60 + 1;
if (local_68 == &local_58) {
uVar5 = 0xf;
}
else {
uVar5 = CONCAT71(uStack_57,local_58);
}
if (uVar5 < uVar4) {
std::string::_M_mutate((ulong)&local_68,local_60,(char *)0x0,0);
}
local_68[uVar2] = cVar1;
pcVar6 = pcVar6 + 1;
local_68[uVar2 + 1] = 0;
local_60 = uVar4;
if (pcVar7 == pcVar6) goto LAB_00101703;
}
uVar2 = param_1[1];
plVar3 = (long *)*param_1;
if (param_1 + 2 == plVar3) {
uVar4 = 0xf;
}
else {
uVar4 = param_1[2];
}
if (uVar4 < uVar2 + 1) {
std::string::_M_mutate((ulong)param_1,uVar2,(char *)0x0,0);
plVar3 = (long *)*param_1;
}
*(char *)((long)plVar3 + uVar2) = cVar1;
pcVar6 = pcVar6 + 1;
param_1[1] = uVar2 + 1;
*(int *)(*param_1 + 1 + uVar2) = 0;
} while (pcVar7 != pcVar6);
LAB_00101703:
if (0x3fffffffffffffffU - param_1[1] < local_60) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("basic_string::append");
}
goto LAB_00101830;
}
}
/* try { // try from 00101731 to 0010182f has its CatchHandler @ 00101835 */
std::string::_M_append((char *)param_1,(ulong)local_68);
if (local_68 != &local_58) {
operator_delete(local_68,CONCAT71(uStack_57,local_58) + 1);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
LAB_00101830:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,476 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int n) {
std::vector<int> dp(n, 0);
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; --i) {
int mxm = 0;
for (int j = i + 1; j < n; ++j) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
mxm = std::max(mxm, dp[j]);
}
}
dp[i] = 1 + mxm;
}
return *max_element(dp.begin(), dp.end());
}
| int main() {
assert(func0({1, 3, 6, 13, 17, 18}, 6) == 4);
assert(func0({10, 5, 3, 15, 20}, 5) == 3);
assert(func0({18, 1, 3, 6, 13, 17}, 6) == 4);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x41(%rbp),%rax
mov %rax,%rdi
callq 1844 <_ZNSaIiEC1Ev>
movl $0x0,-0x38(%rbp)
mov -0x5c(%rbp),%eax
movslq %eax,%rsi
lea -0x41(%rbp),%rcx
lea -0x38(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 1884 <_ZNSt6vectorIiSaIiEEC1EmRKiRKS0_>
lea -0x41(%rbp),%rax
mov %rax,%rdi
callq 1864 <_ZNSaIiED1Ev>
mov -0x5c(%rbp),%eax
sub $0x1,%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1954 <_ZNSt6vectorIiSaIiEEixEm>
movl $0x1,(%rax)
mov -0x5c(%rbp),%eax
sub $0x2,%eax
mov %eax,-0x40(%rbp)
cmpl $0x0,-0x40(%rbp)
js 13ef <_Z5func0RKSt6vectorIiSaIiEEi+0x186>
movl $0x0,-0x38(%rbp)
mov -0x40(%rbp),%eax
add $0x1,%eax
mov %eax,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cmp -0x5c(%rbp),%eax
jge 13c9 <_Z5func0RKSt6vectorIiSaIiEEi+0x160>
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1978 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x40(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1978 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%ecx
mov %ebx,%eax
cltd
idiv %ecx
mov %edx,%eax
test %eax,%eax
je 1384 <_Z5func0RKSt6vectorIiSaIiEEi+0x11b>
mov -0x40(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1978 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1978 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%ecx
mov %ebx,%eax
cltd
idiv %ecx
mov %edx,%eax
test %eax,%eax
jne 138b <_Z5func0RKSt6vectorIiSaIiEEi+0x122>
mov $0x1,%eax
jmp 1390 <_Z5func0RKSt6vectorIiSaIiEEi+0x127>
mov $0x0,%eax
test %al,%al
je 13c0 <_Z5func0RKSt6vectorIiSaIiEEi+0x157>
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1954 <_ZNSt6vectorIiSaIiEEixEm>
mov %rax,%rdx
lea -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 199c <_ZSt3maxIiERKT_S2_S2_>
mov (%rax),%eax
mov %eax,-0x38(%rbp)
addl $0x1,-0x3c(%rbp)
jmpq 1306 <_Z5func0RKSt6vectorIiSaIiEEi+0x9d>
mov -0x38(%rbp),%eax
lea 0x1(%rax),%ebx
mov -0x40(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1954 <_ZNSt6vectorIiSaIiEEixEm>
mov %ebx,(%rax)
subl $0x1,-0x40(%rbp)
jmpq 12ec <_Z5func0RKSt6vectorIiSaIiEEi+0x83>
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 1a14 <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 19c8 <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rbx,%rsi
mov %rax,%rdi
callq 1a64 <_ZSt11max_elementIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEET_S7_S7_>
mov %rax,-0x38(%rbp)
lea -0x38(%rbp),%rax
mov %rax,%rdi
callq 1a92 <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%ebx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 190c <_ZNSt6vectorIiSaIiEED1Ev>
mov %ebx,%eax
mov -0x18(%rbp),%rcx
xor %fs:0x28,%rcx
je 1487 <_Z5func0RKSt6vectorIiSaIiEEi+0x21e>
jmp 1482 <_Z5func0RKSt6vectorIiSaIiEEi+0x219>
endbr64
mov %rax,%rbx
lea -0x41(%rbp),%rax
mov %rax,%rdi
callq 1864 <_ZNSaIiED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1170 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 190c <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1170 <_Unwind_Resume@plt>
callq 1140 <__stack_chk_fail@plt>
add $0x58,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_49]
mov [rbp+var_38], rax
nop
nop
mov dword ptr [rbp+var_40], 0
mov eax, [rbp+var_5C]
movsxd rsi, eax
lea rcx, [rbp+var_49]
lea rdx, [rbp+var_40]
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2EmRKiRKS0_; std::vector<int>::vector(ulong,int const&,std::allocator<int> const&)
lea rax, [rbp+var_49]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
mov eax, [rbp+var_5C]
sub eax, 1
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov dword ptr [rax], 1
mov eax, [rbp+var_5C]
sub eax, 2
mov [rbp+var_48], eax
jmp loc_13C8
loc_12D0:
mov dword ptr [rbp+var_40], 0
mov eax, [rbp+var_48]
add eax, 1
mov [rbp+var_44], eax
jmp loc_139B
loc_12E5:
mov eax, [rbp+var_44]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_48]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ecx, [rax]
mov eax, ebx
cdq
idiv ecx
mov ecx, edx
mov eax, ecx
test eax, eax
jz short loc_135B
mov eax, [rbp+var_48]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_44]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ecx, [rax]
mov eax, ebx
cdq
idiv ecx
mov ecx, edx
mov eax, ecx
test eax, eax
jnz short loc_1362
loc_135B:
mov eax, 1
jmp short loc_1367
loc_1362:
mov eax, 0
loc_1367:
test al, al
jz short loc_1397
mov eax, [rbp+var_44]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rdx, rax
lea rax, [rbp+var_40]
mov rsi, rdx
mov rdi, rax
call _ZSt3maxIiERKT_S2_S2_; std::max<int>(int const&,int const&)
mov eax, [rax]
mov dword ptr [rbp+var_40], eax
loc_1397:
add [rbp+var_44], 1
loc_139B:
mov eax, [rbp+var_44]
cmp eax, [rbp+var_5C]
jl loc_12E5
mov eax, dword ptr [rbp+var_40]
lea ebx, [rax+1]
mov eax, [rbp+var_48]
movsxd rdx, eax
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rax], ebx
sub [rbp+var_48], 1
loc_13C8:
cmp [rbp+var_48], 0
jns loc_12D0
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov rsi, rbx
mov rdi, rax
call _ZSt11max_elementIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEET_S7_S7_; std::max_element<__gnu_cxx::__normal_iterator<int *,std::vector<int>>>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,__gnu_cxx::__normal_iterator<int *,std::vector<int>>)
mov [rbp+var_40], rax
lea rax, [rbp+var_40]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(void)
mov ebx, [rax]
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov eax, ebx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1493
jmp short loc_148E
endbr64
mov rbx, rax
lea rax, [rbp+var_49]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1454
call ___stack_chk_fail
loc_1454:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
endbr64
mov rbx, rax
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1486
call ___stack_chk_fail
loc_1486:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_148E:
call ___stack_chk_fail
loc_1493:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2)
{
int v2; // ebx
int v3; // ebx
long long v5; // rax
int v6; // ebx
long long v7; // rbx
long long v8; // rax
char v10; // [rsp+17h] [rbp-49h] BYREF
int i; // [rsp+18h] [rbp-48h]
int j; // [rsp+1Ch] [rbp-44h]
_QWORD v13[2]; // [rsp+20h] [rbp-40h] BYREF
_BYTE v14[24]; // [rsp+30h] [rbp-30h] BYREF
unsigned long long v15; // [rsp+48h] [rbp-18h]
v15 = __readfsqword(0x28u);
v13[1] = &v10;
LODWORD(v13[0]) = 0;
std::vector<int>::vector(v14, a2, v13, &v10);
std::__new_allocator<int>::~__new_allocator(&v10);
*(_DWORD *)std::vector<int>::operator[](v14, a2 - 1) = 1;
for ( i = a2 - 2; i >= 0; --i )
{
LODWORD(v13[0]) = 0;
for ( j = i + 1; j < a2; ++j )
{
v2 = *(_DWORD *)std::vector<int>::operator[](a1, j);
if ( v2 % *(_DWORD *)std::vector<int>::operator[](a1, i) )
{
v3 = *(_DWORD *)std::vector<int>::operator[](a1, i);
if ( v3 % *(_DWORD *)std::vector<int>::operator[](a1, j) )
continue;
}
v5 = std::vector<int>::operator[](v14, j);
LODWORD(v13[0]) = *(_DWORD *)std::max<int>(v13, v5);
}
v6 = LODWORD(v13[0]) + 1;
*(_DWORD *)std::vector<int>::operator[](v14, i) = v6;
}
v7 = std::vector<int>::end(v14);
v8 = std::vector<int>::begin(v14);
v13[0] = std::max_element<__gnu_cxx::__normal_iterator<int *,std::vector<int>>>(v8, v7);
LODWORD(v7) = *(_DWORD *)__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(v13);
std::vector<int>::~vector(v14);
return (unsigned int)v7;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x49]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV dword ptr [RBP + -0x40],0x0
MOV EAX,dword ptr [RBP + -0x5c]
MOVSXD RSI,EAX
LEA RCX,[RBP + -0x49]
LEA RDX,[RBP + -0x40]
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
LAB_00101292:
CALL 0x0010182a
LEA RAX,[RBP + -0x49]
MOV RDI,RAX
CALL 0x00101b24
NOP
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,0x1
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010190a
MOV dword ptr [RAX],0x1
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,0x2
MOV dword ptr [RBP + -0x48],EAX
JMP 0x001013c8
LAB_001012d0:
MOV dword ptr [RBP + -0x40],0x0
MOV EAX,dword ptr [RBP + -0x48]
ADD EAX,0x1
MOV dword ptr [RBP + -0x44],EAX
JMP 0x0010139b
LAB_001012e5:
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010192e
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010192e
MOV ECX,dword ptr [RAX]
MOV EAX,EBX
CDQ
IDIV ECX
MOV ECX,EDX
MOV EAX,ECX
TEST EAX,EAX
JZ 0x0010135b
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010192e
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010192e
MOV ECX,dword ptr [RAX]
MOV EAX,EBX
CDQ
IDIV ECX
MOV ECX,EDX
MOV EAX,ECX
TEST EAX,EAX
JNZ 0x00101362
LAB_0010135b:
MOV EAX,0x1
JMP 0x00101367
LAB_00101362:
MOV EAX,0x0
LAB_00101367:
TEST AL,AL
JZ 0x00101397
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010190a
MOV RDX,RAX
LEA RAX,[RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101952
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x40],EAX
LAB_00101397:
ADD dword ptr [RBP + -0x44],0x1
LAB_0010139b:
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x001012e5
MOV EAX,dword ptr [RBP + -0x40]
LEA EBX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010190a
MOV dword ptr [RAX],EBX
SUB dword ptr [RBP + -0x48],0x1
LAB_001013c8:
CMP dword ptr [RBP + -0x48],0x0
JNS 0x001012d0
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x001019ca
MOV RBX,RAX
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x0010197e
MOV RSI,RBX
MOV RDI,RAX
LAB_001013f3:
CALL 0x00101a1a
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00101a48
MOV EBX,dword ptr [RAX]
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x001018b0
MOV EAX,EBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101493
JMP 0x0010148e
LAB_0010148e:
CALL 0x00101130
LAB_00101493:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int4 func0(vector *param_1,int param_2)
{
int iVar1;
int4 uVar2;
bool bVar3;
__normal_iterator _Var4;
__normal_iterator _Var5;
int4 *puVar6;
int *piVar7;
int4 extraout_var;
long in_FS_OFFSET;
allocator local_51;
int local_50;
int local_4c;
ulong local_48;
allocator *local_40;
vector<int,std::allocator<int>> local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = &local_51;
local_48 = local_48 & 0xffffffff00000000;
/* try { // try from 00101292 to 00101296 has its CatchHandler @ 00101429 */
std::vector<int,std::allocator<int>>::vector(local_38,(long)param_2,(int *)&local_48,&local_51);
std::__new_allocator<int>::~__new_allocator((__new_allocator<int> *)&local_51);
puVar6 = (int4 *)
std::vector<int,std::allocator<int>>::operator[](local_38,(long)(param_2 + -1));
*puVar6 = 1;
local_50 = param_2 + -2;
do {
if (local_50 < 0) {
_Var4 = std::vector<int,std::allocator<int>>::end(local_38);
_Var5 = std::vector<int,std::allocator<int>>::begin(local_38);
/* try { // try from 001013f3 to 001013f7 has its CatchHandler @ 0010145c */
_Var4 = std::max_element<__normal_iterator<int*,std::vector<int,std::allocator<int>>>>
(_Var5,_Var4);
local_48 = CONCAT44(extraout_var,_Var4);
puVar6 = (int4 *)
__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)&local_48)
;
uVar2 = *puVar6;
std::vector<int,std::allocator<int>>::~vector(local_38);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
local_48 = local_48 & 0xffffffff00000000;
local_4c = local_50;
while (local_4c = local_4c + 1, local_4c < param_2) {
piVar7 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_4c);
iVar1 = *piVar7;
piVar7 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_50);
if (iVar1 % *piVar7 == 0) {
LAB_0010135b:
bVar3 = true;
}
else {
piVar7 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_50);
iVar1 = *piVar7;
piVar7 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_4c);
if (iVar1 % *piVar7 == 0) goto LAB_0010135b;
bVar3 = false;
}
if (bVar3) {
piVar7 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_4c);
piVar7 = std::max<int>((int *)&local_48,piVar7);
local_48 = CONCAT44(local_48._4_4_,*piVar7);
}
}
iVar1 = (int)local_48 + 1;
piVar7 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_50);
*piVar7 = iVar1;
local_50 = local_50 + -1;
} while( true );
} |
2,477 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int n) {
std::vector<int> dp(n, 0);
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; --i) {
int mxm = 0;
for (int j = i + 1; j < n; ++j) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
mxm = std::max(mxm, dp[j]);
}
}
dp[i] = 1 + mxm;
}
return *max_element(dp.begin(), dp.end());
}
| int main() {
assert(func0({1, 3, 6, 13, 17, 18}, 6) == 4);
assert(func0({10, 5, 3, 15, 20}, 5) == 3);
assert(func0({18, 1, 3, 6, 13, 17}, 6) == 4);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movslq %esi,%rax
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 12d8 <_Z5func0RKSt6vectorIiSaIiEEi+0x8f>
mov %rdi,%rbp
mov %esi,%ebx
test %rax,%rax
je 135d <_Z5func0RKSt6vectorIiSaIiEEi+0x114>
lea 0x0(,%rax,4),%r13
mov %r13,%rdi
callq 1120 <_Znwm@plt>
mov %rax,%r8
lea (%rax,%r13,1),%r14
movl $0x0,(%rax)
add $0x4,%rax
cmp %r14,%rax
jne 12a2 <_Z5func0RKSt6vectorIiSaIiEEi+0x59>
lea -0x1(%rbx),%r12d
movl $0x1,-0x4(%r8,%r13,1)
mov %ebx,%r13d
sub $0x2,%r13d
js 1375 <_Z5func0RKSt6vectorIiSaIiEEi+0x12c>
movslq %r13d,%r13
mov %r12d,%r15d
lea 0x4(%rsp),%r11
jmp 1330 <_Z5func0RKSt6vectorIiSaIiEEi+0xe7>
lea 0xd29(%rip),%rdi
callq 10d0 <_ZSt20__throw_length_errorPKc@plt>
lea (%r8,%rcx,1),%rax
mov (%r8,%rcx,1),%esi
cmp %esi,0x4(%rsp)
cmovge %r11,%rax
mov (%rax),%eax
mov %eax,0x4(%rsp)
add $0x4,%rcx
cmp %r9,%rcx
je 131b <_Z5func0RKSt6vectorIiSaIiEEi+0xd2>
mov (%r10,%rcx,1),%esi
mov %esi,%eax
cltd
idiv %edi
test %edx,%edx
je 12e4 <_Z5func0RKSt6vectorIiSaIiEEi+0x9b>
mov %edi,%eax
cltd
idiv %esi
test %edx,%edx
jne 12fa <_Z5func0RKSt6vectorIiSaIiEEi+0xb1>
jmp 12e4 <_Z5func0RKSt6vectorIiSaIiEEi+0x9b>
mov 0x4(%rsp),%eax
add $0x1,%eax
mov %eax,(%r8,%r13,4)
sub $0x1,%r13
sub $0x1,%r12d
je 1375 <_Z5func0RKSt6vectorIiSaIiEEi+0x12c>
movl $0x0,0x4(%rsp)
cmp %r12d,%ebx
jle 131b <_Z5func0RKSt6vectorIiSaIiEEi+0xd2>
mov 0x0(%rbp),%r10
mov (%r10,%r13,4),%edi
movslq %r12d,%rcx
shl $0x2,%rcx
mov %r15d,%eax
sub %r12d,%eax
lea 0x2(%r13,%rax,1),%r9
shl $0x2,%r9
jmp 1303 <_Z5func0RKSt6vectorIiSaIiEEi+0xba>
movl $0x1,0xfffffffffffffffc
mov $0x0,%r8d
mov $0x0,%edx
jmp 1395 <_Z5func0RKSt6vectorIiSaIiEEi+0x14c>
lea 0x4(%r8),%rcx
mov %rcx,%rax
mov %r8,%rdx
cmp %r14,%rcx
je 1395 <_Z5func0RKSt6vectorIiSaIiEEi+0x14c>
mov (%rax),%ebx
cmp %ebx,(%rdx)
cmovl %rax,%rdx
add $0x4,%rax
cmp %rax,%r14
jne 1384 <_Z5func0RKSt6vectorIiSaIiEEi+0x13b>
mov (%rdx),%ebx
test %r8,%r8
je 13a4 <_Z5func0RKSt6vectorIiSaIiEEi+0x15b>
mov %r8,%rdi
callq 1110 <_ZdlPv@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 13c5 <_Z5func0RKSt6vectorIiSaIiEEi+0x17c>
mov %ebx,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1130 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
movsxd r12, esi
mov rax, r12
shr rax, 3Dh
jnz short loc_128F
mov rbp, rdi
mov ebx, esi
test r12, r12
jz loc_1371
shl r12, 2
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
lea r15, [rax+r12]
loc_1258:
mov dword ptr [rax], 0
add rax, 4
cmp rax, r15
jnz short loc_1258
mov dword ptr [r14+r12-4], 1
mov r13d, ebx
sub r13d, 2
js loc_131C
lea r11d, [rbx-1]
movsxd r13, r13d
shl r13, 2
lea r10, [rsp+48h+var_44]
jmp short loc_12FE
loc_128F:
mov rax, [rsp+48h+var_40]
sub rax, fs:28h
jnz short loc_12AB
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_12AB:
call ___stack_chk_fail
loc_12B0:
mov rax, rcx
mov edi, [rcx]
cmp [rsp+48h+var_44], edi
cmovge rax, r10
mov eax, [rax]
mov [rsp+48h+var_44], eax
loc_12C3:
add rsi, 1
add rcx, 4
cmp ebx, esi
jle short loc_12E9
loc_12CF:
mov edi, [r9+rsi*4]
mov eax, edi
cdq
idiv r8d
test edx, edx
jz short loc_12B0
mov eax, r8d
cdq
idiv edi
test edx, edx
jnz short loc_12C3
jmp short loc_12B0
loc_12E9:
mov eax, [rsp+48h+var_44]
add eax, 1
mov [r14+r13], eax
sub r13, 4
sub r11d, 1
jz short loc_131C
loc_12FE:
mov [rsp+48h+var_44], 0
cmp ebx, r11d
jle short loc_1389
mov r9, [rbp+0]
mov r8d, [r9+r13]
movsxd rsi, r11d
lea rcx, [r14+rsi*4]
jmp short loc_12CF
loc_131C:
lea rax, [r14+4]
cmp rax, r15
jz short loc_136C
mov rdx, r14
loc_1328:
mov ebx, [rax]
cmp [rdx], ebx
cmovl rdx, rax
add rax, 4
cmp rax, r15
jnz short loc_1328
loc_1339:
mov ebx, [rdx]
test r14, r14
jz short loc_134B
mov rsi, r12; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_134B:
mov rax, [rsp+48h+var_40]
sub rax, fs:28h
jnz short loc_13A1
mov eax, ebx
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_136C:
mov rdx, r14
jmp short loc_1339
loc_1371:
mov dword ptr ds:0FFFFFFFFFFFFFFFCh, 1
mov r14d, 0
mov edx, 0
jmp short loc_1339
loc_1389:
mov eax, [rsp+48h+var_44]
add eax, 1
mov [r14+r13], eax
sub r11d, 1
sub r13, 4
jmp loc_12FE
loc_13A1:
call ___stack_chk_fail | long long func0(long long *a1, int a2)
{
unsigned long long v2; // r12
unsigned int *v4; // rax
unsigned int *v5; // r14
unsigned int *v6; // r15
int v7; // r11d
long long v8; // r13
int *v9; // rax
long long v10; // rsi
int *v11; // rcx
long long v12; // r9
int v13; // r8d
unsigned int *v14; // rax
unsigned int *v15; // rdx
unsigned int v16; // ebx
int v18; // [rsp+4h] [rbp-44h] BYREF
unsigned long long v19; // [rsp+8h] [rbp-40h]
v19 = __readfsqword(0x28u);
v2 = a2;
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( a2 )
{
v2 = 4LL * a2;
v4 = (unsigned int *)operator new(v2);
v5 = v4;
v6 = (unsigned int *)((char *)v4 + v2);
do
*v4++ = 0;
while ( v4 != v6 );
*(unsigned int *)((char *)v5 + v2 - 4) = 1;
if ( a2 - 2 >= 0 )
{
v7 = a2 - 1;
v8 = a2 - 2;
do
{
while ( 1 )
{
v18 = 0;
if ( a2 > v7 )
break;
v5[v8] = v18 + 1;
--v7;
--v8;
}
v12 = *a1;
v13 = *(_DWORD *)(*a1 + v8 * 4);
v10 = v7;
v11 = (int *)&v5[v7];
do
{
if ( !(*(_DWORD *)(v12 + 4 * v10) % v13) || !(v13 % *(_DWORD *)(v12 + 4 * v10)) )
{
v9 = v11;
if ( v18 >= *v11 )
v9 = &v18;
v18 = *v9;
}
++v10;
++v11;
}
while ( a2 > (int)v10 );
v5[v8--] = v18 + 1;
--v7;
}
while ( v7 );
}
v14 = v5 + 1;
if ( v5 + 1 == v6 )
{
v15 = v5;
}
else
{
v15 = v5;
do
{
if ( (int)*v15 < (int)*v14 )
v15 = v14;
++v14;
}
while ( v14 != v6 );
}
}
else
{
MEMORY[0xFFFFFFFFFFFFFFFC] = 1;
v5 = 0LL;
v15 = 0LL;
}
v16 = *v15;
if ( v5 )
operator delete(v5, v2);
return v16;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVSXD R12,ESI
MOV RAX,R12
SHR RAX,0x3d
JNZ 0x0010128f
MOV RBP,RDI
MOV EBX,ESI
TEST R12,R12
JZ 0x00101371
SHL R12,0x2
MOV RDI,R12
CALL 0x001010e0
MOV R14,RAX
LEA R15,[RAX + R12*0x1]
LAB_00101258:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,R15
JNZ 0x00101258
MOV dword ptr [R14 + R12*0x1 + -0x4],0x1
MOV R13D,EBX
SUB R13D,0x2
JS 0x0010131c
LEA R11D,[RBX + -0x1]
MOVSXD R13,R13D
SHL R13,0x2
LEA R10,[RSP + 0x4]
JMP 0x001012fe
LAB_0010128f:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012ab
LEA RDI,[0x102008]
CALL 0x001010b0
LAB_001012ab:
CALL 0x00101100
LAB_001012b0:
MOV RAX,RCX
MOV EDI,dword ptr [RCX]
CMP dword ptr [RSP + 0x4],EDI
CMOVGE RAX,R10
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x4],EAX
LAB_001012c3:
ADD RSI,0x1
ADD RCX,0x4
CMP EBX,ESI
JLE 0x001012e9
LAB_001012cf:
MOV EDI,dword ptr [R9 + RSI*0x4]
MOV EAX,EDI
CDQ
IDIV R8D
TEST EDX,EDX
JZ 0x001012b0
MOV EAX,R8D
CDQ
IDIV EDI
TEST EDX,EDX
JNZ 0x001012c3
JMP 0x001012b0
LAB_001012e9:
MOV EAX,dword ptr [RSP + 0x4]
ADD EAX,0x1
MOV dword ptr [R14 + R13*0x1],EAX
SUB R13,0x4
SUB R11D,0x1
JZ 0x0010131c
LAB_001012fe:
MOV dword ptr [RSP + 0x4],0x0
CMP EBX,R11D
JLE 0x00101389
MOV R9,qword ptr [RBP]
MOV R8D,dword ptr [R9 + R13*0x1]
MOVSXD RSI,R11D
LEA RCX,[R14 + RSI*0x4]
JMP 0x001012cf
LAB_0010131c:
LEA RAX,[R14 + 0x4]
CMP RAX,R15
JZ 0x0010136c
MOV RDX,R14
LAB_00101328:
MOV EBX,dword ptr [RAX]
CMP dword ptr [RDX],EBX
CMOVL RDX,RAX
ADD RAX,0x4
CMP RAX,R15
JNZ 0x00101328
LAB_00101339:
MOV EBX,dword ptr [RDX]
TEST R14,R14
JZ 0x0010134b
MOV RSI,R12
MOV RDI,R14
CALL 0x001010f0
LAB_0010134b:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013a1
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010136c:
MOV RDX,R14
JMP 0x00101339
LAB_00101371:
MOV dword ptr [0xfffffffffffffffc],0x1
MOV R14D,0x0
MOV EDX,0x0
JMP 0x00101339
LAB_00101389:
MOV EAX,dword ptr [RSP + 0x4]
ADD EAX,0x1
MOV dword ptr [R14 + R13*0x1],EAX
SUB R11D,0x1
SUB R13,0x4
JMP 0x001012fe
LAB_001013a1:
CALL 0x00101100 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int *piVar7;
long lVar8;
int iVar9;
ulong uVar10;
ulong uVar11;
long lVar12;
long in_FS_OFFSET;
int local_44;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar10 = (ulong)param_2;
if (uVar10 >> 0x3d != 0) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
if (uVar10 == 0) {
_DAT_fffffffffffffffc = 1;
piVar4 = (int *)0x0;
piVar7 = (int *)0x0;
uVar11 = 0;
}
else {
uVar11 = uVar10 * 4;
piVar4 = (int *)operator_new(uVar11);
piVar7 = piVar4;
do {
*piVar7 = 0;
piVar7 = piVar7 + 1;
} while (piVar7 != piVar4 + uVar10);
piVar4[uVar10 - 1] = 1;
piVar7 = piVar4;
piVar3 = piVar4;
if (-1 < param_2 + -2) {
iVar9 = param_2 + -1;
lVar12 = (long)(param_2 + -2) << 2;
do {
for (; local_44 = 0, param_2 <= iVar9; iVar9 = iVar9 + -1) {
*(int4 *)((long)piVar4 + lVar12) = 1;
lVar12 = lVar12 + -4;
}
iVar2 = *(int *)(*(long *)param_1 + lVar12);
lVar8 = (long)iVar9;
piVar6 = piVar4 + lVar8;
do {
iVar1 = *(int *)(*(long *)param_1 + lVar8 * 4);
if ((iVar1 % iVar2 == 0) || (iVar2 % iVar1 == 0)) {
piVar5 = piVar6;
if (*piVar6 <= local_44) {
piVar5 = &local_44;
}
local_44 = *piVar5;
}
lVar8 = lVar8 + 1;
piVar6 = piVar6 + 1;
} while ((int)lVar8 < param_2);
*(int *)((long)piVar4 + lVar12) = local_44 + 1;
lVar12 = lVar12 + -4;
iVar9 = iVar9 + -1;
} while (iVar9 != 0);
}
while (piVar3 = piVar3 + 1, piVar3 != piVar4 + uVar10) {
if (*piVar7 < *piVar3) {
piVar7 = piVar3;
}
}
}
iVar9 = *piVar7;
if (piVar4 != (int *)0x0) {
operator_delete(piVar4,uVar11);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar9;
} |
2,478 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int n) {
std::vector<int> dp(n, 0);
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; --i) {
int mxm = 0;
for (int j = i + 1; j < n; ++j) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
mxm = std::max(mxm, dp[j]);
}
}
dp[i] = 1 + mxm;
}
return *max_element(dp.begin(), dp.end());
}
| int main() {
assert(func0({1, 3, 6, 13, 17, 18}, 6) == 4);
assert(func0({10, 5, 3, 15, 20}, 5) == 3);
assert(func0({18, 1, 3, 6, 13, 17}, 6) == 4);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
movabs $0x1fffffffffffffff,%rdx
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movslq %esi,%rax
cmp %rdx,%rax
ja 1626 <_Z5func0RKSt6vectorIiSaIiEEi+0x176>
lea -0x1(%rsi),%r14d
mov %esi,%ebx
movslq %r14d,%r13
lea 0x0(,%r13,4),%r15
test %rax,%rax
je 1608 <_Z5func0RKSt6vectorIiSaIiEEi+0x158>
lea 0x4(%r15),%r12
mov %rdi,%rbp
mov %r12,%rdi
callq 1120 <_Znwm@plt>
mov %rax,%r10
add %rax,%r12
nopw 0x0(%rax,%rax,1)
movl $0x0,(%rax)
add $0x4,%rax
cmp %r12,%rax
jne 1520 <_Z5func0RKSt6vectorIiSaIiEEi+0x70>
movl $0x1,(%r10,%r13,4)
cmp $0x1,%ebx
jle 15ad <_Z5func0RKSt6vectorIiSaIiEEi+0xfd>
mov %r14d,%esi
lea -0x4(%r15),%r11
nopl 0x0(%rax,%rax,1)
movl $0x0,0x4(%rsp)
cmp %esi,%ebx
jle 1600 <_Z5func0RKSt6vectorIiSaIiEEi+0x150>
mov 0x0(%rbp),%r13
movslq %esi,%rcx
xor %r9d,%r9d
mov 0x0(%r13,%r11,1),%r8d
nopw 0x0(%rax,%rax,1)
mov 0x0(%r13,%rcx,4),%edi
mov %edi,%eax
cltd
idiv %r8d
test %edx,%edx
je 1589 <_Z5func0RKSt6vectorIiSaIiEEi+0xd9>
mov %r8d,%eax
cltd
idiv %edi
test %edx,%edx
jne 1594 <_Z5func0RKSt6vectorIiSaIiEEi+0xe4>
mov (%r10,%rcx,4),%eax
cmp %eax,%r9d
cmovl %eax,%r9d
add $0x1,%rcx
cmp %ecx,%ebx
jg 1570 <_Z5func0RKSt6vectorIiSaIiEEi+0xc0>
add $0x1,%r9d
mov %r9d,(%r10,%r11,1)
sub $0x4,%r11
sub $0x1,%esi
jne 1548 <_Z5func0RKSt6vectorIiSaIiEEi+0x98>
lea 0x4(%r10),%rax
mov (%r10),%r13d
cmp %r12,%rax
je 15d2 <_Z5func0RKSt6vectorIiSaIiEEi+0x122>
nopl 0x0(%rax)
mov (%rax),%edx
cmp %edx,%r13d
cmovl %edx,%r13d
add $0x4,%rax
cmp %rax,%r12
jne 15c0 <_Z5func0RKSt6vectorIiSaIiEEi+0x110>
mov %r10,%rdi
callq 1110 <_ZdlPv@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1621 <_Z5func0RKSt6vectorIiSaIiEEi+0x171>
add $0x18,%rsp
mov %r13d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov $0x1,%r9d
jmp 15a0 <_Z5func0RKSt6vectorIiSaIiEEi+0xf0>
movl $0x1,0x0(,%r13,4)
xor %r10d,%r10d
mov 0x0,%r13d
jmp 15d2 <_Z5func0RKSt6vectorIiSaIiEEi+0x122>
callq 1130 <__stack_chk_fail@plt>
lea 0x9db(%rip),%rdi
callq 10d0 <_ZSt20__throw_length_errorPKc@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r15
movsxd rax, esi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rax
sub rsp, 18h
shr rbx, 3Dh
jnz loc_1579
lea r13d, [rax-1]
mov rbp, rax
movsxd r15, r13d
lea rcx, ds:0[r15*4]
test rax, rax
jz loc_1565
lea rbx, [rcx+4]
mov r14, rdi
mov [rsp+48h+var_40], rcx
mov rdi, rbx; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, rbx; n
xor esi, esi; c
mov rdi, rax; s
lea r12, [rax+rbx]
call _memset
mov dword ptr [rax+r15*4], 1
mov r10, rax
cmp ebp, 1
jz short loc_14EB
mov rcx, [rsp+48h+var_40]
mov r9, [r14]
mov r11d, r13d
lea r13, [rcx-4]
nop dword ptr [rax+00000000h]
loc_1498:
cmp ebp, r11d
jle loc_1550
mov edi, [r9+r13]
mov ecx, r11d
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_14B0:
mov esi, [r9+rcx*4]
mov eax, esi
cdq
idiv edi
test edx, edx
jz short loc_14C6
mov eax, edi
cdq
idiv esi
test edx, edx
jnz short loc_14D1
loc_14C6:
mov eax, [r10+rcx*4]
cmp r8d, eax
cmovl r8d, eax
loc_14D1:
add rcx, 1
cmp ebp, ecx
jg short loc_14B0
add r8d, 1
mov [r10+r13], r8d
sub r13, 4
sub r11d, 1
jnz short loc_1498
loc_14EB:
lea rax, [r10+4]
mov ebp, [r10]
cmp rax, r12
jz short loc_1530
mov rdx, r12
sub rdx, rax
and edx, 4
jz short loc_1518
mov eax, [rax]
cmp ebp, eax
cmovl ebp, eax
lea rax, [r10+8]
cmp r12, rax
jz short loc_1530
nop word ptr [rax+rax+00h]
loc_1518:
mov edx, [rax]
cmp ebp, edx
cmovl ebp, edx
mov edx, [rax+4]
cmp ebp, edx
cmovl ebp, edx
add rax, 8
cmp r12, rax
jnz short loc_1518
loc_1530:
mov rsi, rbx; unsigned __int64
mov rdi, r10; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_153B:
add rsp, 18h
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1550:
mov dword ptr [r10+r13], 1
sub r11d, 1
sub r13, 4
jmp loc_1498
loc_1565:
mov dword ptr ds:0FFFFFFFFFFFFFFFCh, 1
mov ebp, ds:dword_0
jmp short loc_153B
loc_1579:
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*) | long long func0(long long *a1, int a2)
{
int v2; // r13d
long long v3; // rcx
size_t v4; // rbx
char *v5; // rax
char *v6; // r12
char *v7; // rax
char *v8; // r10
long long v9; // r9
int v10; // r11d
long long v11; // r13
int v12; // edi
long long v13; // rcx
int v14; // r8d
char *v15; // rax
signed int v16; // ebp
int v17; // eax
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v2 = a2 - 1;
v3 = 4LL * (a2 - 1);
if ( a2 )
{
v4 = v3 + 4;
v5 = (char *)operator new(v3 + 4);
v6 = &v5[v4];
v7 = (char *)memset(v5, 0, v4);
*(_DWORD *)&v7[4 * v2] = 1;
v8 = v7;
if ( a2 != 1 )
{
v9 = *a1;
v10 = a2 - 1;
v11 = 4LL * v2 - 4;
do
{
while ( a2 <= v10 )
{
*(_DWORD *)&v7[v11] = 1;
--v10;
v11 -= 4LL;
}
v12 = *(_DWORD *)(v9 + v11);
v13 = (unsigned int)v10;
v14 = 0;
do
{
if ( (!(*(_DWORD *)(v9 + 4 * v13) % v12) || !(v12 % *(_DWORD *)(v9 + 4 * v13)))
&& v14 < *(_DWORD *)&v7[4 * v13] )
{
v14 = *(_DWORD *)&v7[4 * v13];
}
++v13;
}
while ( a2 > (int)v13 );
*(_DWORD *)&v7[v11] = v14 + 1;
v11 -= 4LL;
--v10;
}
while ( v10 );
}
v15 = v7 + 4;
v16 = *(_DWORD *)v8;
if ( v8 + 4 != v6 )
{
if ( (((_BYTE)v6 - (_BYTE)v15) & 4) == 0 )
goto LABEL_30;
v17 = *(_DWORD *)v15;
if ( v16 < v17 )
v16 = v17;
v15 = v8 + 8;
if ( v6 != v8 + 8 )
{
LABEL_30:
do
{
if ( v16 < *(_DWORD *)v15 )
v16 = *(_DWORD *)v15;
if ( v16 < *((_DWORD *)v15 + 1) )
v16 = *((_DWORD *)v15 + 1);
v15 += 8;
}
while ( v6 != v15 );
}
}
operator delete(v8, v4);
}
else
{
MEMORY[0xFFFFFFFFFFFFFFFC] = 1;
return 1179403647;
}
return (unsigned int)v16;
} | func0:
ENDBR64
PUSH R15
MOVSXD RAX,ESI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RAX
SUB RSP,0x18
SHR RBX,0x3d
JNZ 0x00101579
LEA R13D,[RAX + -0x1]
MOV RBP,RAX
MOVSXD R15,R13D
LEA RCX,[R15*0x4]
TEST RAX,RAX
JZ 0x00101565
LEA RBX,[RCX + 0x4]
MOV R14,RDI
MOV qword ptr [RSP + 0x8],RCX
MOV RDI,RBX
CALL 0x00101100
MOV RDX,RBX
XOR ESI,ESI
MOV RDI,RAX
LEA R12,[RAX + RBX*0x1]
CALL 0x001010d0
MOV dword ptr [RAX + R15*0x4],0x1
MOV R10,RAX
CMP EBP,0x1
JZ 0x001014eb
MOV RCX,qword ptr [RSP + 0x8]
MOV R9,qword ptr [R14]
MOV R11D,R13D
LEA R13,[RCX + -0x4]
NOP dword ptr [RAX]
LAB_00101498:
CMP EBP,R11D
JLE 0x00101550
MOV EDI,dword ptr [R9 + R13*0x1]
MOV ECX,R11D
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_001014b0:
MOV ESI,dword ptr [R9 + RCX*0x4]
MOV EAX,ESI
CDQ
IDIV EDI
TEST EDX,EDX
JZ 0x001014c6
MOV EAX,EDI
CDQ
IDIV ESI
TEST EDX,EDX
JNZ 0x001014d1
LAB_001014c6:
MOV EAX,dword ptr [R10 + RCX*0x4]
CMP R8D,EAX
CMOVL R8D,EAX
LAB_001014d1:
ADD RCX,0x1
CMP EBP,ECX
JG 0x001014b0
ADD R8D,0x1
MOV dword ptr [R10 + R13*0x1],R8D
SUB R13,0x4
SUB R11D,0x1
JNZ 0x00101498
LAB_001014eb:
LEA RAX,[R10 + 0x4]
MOV EBP,dword ptr [R10]
CMP RAX,R12
JZ 0x00101530
MOV RDX,R12
SUB RDX,RAX
AND EDX,0x4
JZ 0x00101518
MOV EAX,dword ptr [RAX]
CMP EBP,EAX
CMOVL EBP,EAX
LEA RAX,[R10 + 0x8]
CMP R12,RAX
JZ 0x00101530
NOP word ptr [RAX + RAX*0x1]
LAB_00101518:
MOV EDX,dword ptr [RAX]
CMP EBP,EDX
CMOVL EBP,EDX
MOV EDX,dword ptr [RAX + 0x4]
CMP EBP,EDX
CMOVL EBP,EDX
ADD RAX,0x8
CMP R12,RAX
JNZ 0x00101518
LAB_00101530:
MOV RSI,RBX
MOV RDI,R10
CALL 0x00101110
LAB_0010153b:
ADD RSP,0x18
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101550:
MOV dword ptr [R10 + R13*0x1],0x1
SUB R11D,0x1
SUB R13,0x4
JMP 0x00101498
LAB_00101565:
MOV dword ptr [0xfffffffffffffffc],0x1
MOV EBP,dword ptr [0x00000000]
JMP 0x0010153b
LAB_00101579:
LEA RDI,[0x102008]
CALL 0x001010c0
NOP word ptr CS:[RAX + RAX*0x1]
NOP | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&, int) */
void * func0(vector *param_1,int param_2)
{
ulong __n;
uint *puVar1;
int iVar2;
int iVar3;
long lVar4;
void *pvVar5;
uint *puVar6;
uint *puVar7;
void *extraout_RAX;
ulong uVar8;
char *pcVar9;
uint uVar10;
uint uVar11;
long lVar12;
if ((ulong)(long)param_2 >> 0x3d != 0) {
pcVar9 = "cannot create std::vector larger than max_size()";
std::__throw_length_error("cannot create std::vector larger than max_size()");
pvVar5 = *(void **)pcVar9;
if (pvVar5 == (void *)0x0) {
return pvVar5;
}
operator_delete(pvVar5,*(long *)(pcVar9 + 0x10) - (long)pvVar5);
return extraout_RAX;
}
uVar11 = param_2 - 1;
lVar12 = (long)(int)uVar11 * 4;
if ((long)param_2 == 0) {
_DAT_fffffffffffffffc = 1;
uVar11 = _DAT_00000000;
goto LAB_0010153b;
}
__n = lVar12 + 4;
pvVar5 = operator_new(__n);
puVar1 = (uint *)((long)pvVar5 + __n);
puVar6 = (uint *)memset(pvVar5,0,__n);
puVar6[(int)uVar11] = 1;
if (param_2 != 1) {
lVar4 = *(long *)param_1;
lVar12 = lVar12 + -4;
do {
for (; param_2 <= (int)uVar11; uVar11 = uVar11 - 1) {
*(int4 *)((long)puVar6 + lVar12) = 1;
lVar12 = lVar12 + -4;
}
iVar2 = *(int *)(lVar4 + lVar12);
uVar8 = (ulong)uVar11;
uVar10 = 0;
do {
iVar3 = *(int *)(lVar4 + uVar8 * 4);
if (((iVar3 % iVar2 == 0) || (iVar2 % iVar3 == 0)) && ((int)uVar10 < (int)puVar6[uVar8])) {
uVar10 = puVar6[uVar8];
}
uVar8 = uVar8 + 1;
} while ((int)uVar8 < param_2);
*(uint *)((long)puVar6 + lVar12) = uVar10 + 1;
lVar12 = lVar12 + -4;
uVar11 = uVar11 - 1;
} while (uVar11 != 0);
}
puVar7 = puVar6 + 1;
uVar11 = *puVar6;
if (puVar7 != puVar1) {
if (((int)puVar1 - (int)puVar7 & 4U) != 0) {
if ((int)uVar11 < (int)*puVar7) {
uVar11 = *puVar7;
}
puVar7 = puVar6 + 2;
if (puVar1 == puVar7) goto LAB_00101530;
}
do {
if ((int)uVar11 < (int)*puVar7) {
uVar11 = *puVar7;
}
if ((int)uVar11 < (int)puVar7[1]) {
uVar11 = puVar7[1];
}
puVar7 = puVar7 + 2;
} while (puVar1 != puVar7);
}
LAB_00101530:
operator_delete(puVar6,__n);
LAB_0010153b:
return (void *)(ulong)uVar11;
} |
2,479 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int n) {
std::vector<int> dp(n, 0);
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; --i) {
int mxm = 0;
for (int j = i + 1; j < n; ++j) {
if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
mxm = std::max(mxm, dp[j]);
}
}
dp[i] = 1 + mxm;
}
return *max_element(dp.begin(), dp.end());
}
| int main() {
assert(func0({1, 3, 6, 13, 17, 18}, 6) == 4);
assert(func0({10, 5, 3, 15, 20}, 5) == 3);
assert(func0({18, 1, 3, 6, 13, 17}, 6) == 4);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
movabs $0x1fffffffffffffff,%rdx
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movslq %esi,%rax
cmp %rdx,%rax
ja 16c9 <_Z5func0RKSt6vectorIiSaIiEEi+0x239>
lea -0x1(%rsi),%r14d
mov %esi,%ebx
movslq %r14d,%r13
lea 0x0(,%r13,4),%r15
test %rax,%rax
je 16ab <_Z5func0RKSt6vectorIiSaIiEEi+0x21b>
lea 0x4(%r15),%r12
mov %rdi,%rbp
mov %r12,%rdi
callq 1140 <_Znwm@plt>
mov %r12,%rdx
xor %esi,%esi
mov %rax,%rdi
callq 10f0 <memset@plt>
movl $0x1,(%rax,%r13,4)
mov %rax,%r9
add %rax,%r12
cmp $0x1,%ebx
jle 157c <_Z5func0RKSt6vectorIiSaIiEEi+0xec>
mov %r14d,%r10d
lea -0x4(%r15),%r11
nopl 0x0(%rax,%rax,1)
movl $0x0,0x4(%rsp)
cmp %r10d,%ebx
jle 16a0 <_Z5func0RKSt6vectorIiSaIiEEi+0x210>
mov 0x0(%rbp),%r13
movslq %r10d,%rcx
xor %r8d,%r8d
mov 0x0(%r13,%r11,1),%edi
mov 0x0(%r13,%rcx,4),%esi
mov %esi,%eax
cltd
idiv %edi
test %edx,%edx
je 1557 <_Z5func0RKSt6vectorIiSaIiEEi+0xc7>
mov %edi,%eax
cltd
idiv %esi
test %edx,%edx
jne 1562 <_Z5func0RKSt6vectorIiSaIiEEi+0xd2>
mov (%r9,%rcx,4),%eax
cmp %eax,%r8d
cmovl %eax,%r8d
add $0x1,%rcx
cmp %ecx,%ebx
jg 1540 <_Z5func0RKSt6vectorIiSaIiEEi+0xb0>
add $0x1,%r8d
mov %r8d,(%r9,%r11,1)
sub $0x4,%r11
sub $0x1,%r10d
jne 1520 <_Z5func0RKSt6vectorIiSaIiEEi+0x90>
lea 0x4(%r9),%rcx
mov (%r9),%r13d
cmp %rcx,%r12
je 1674 <_Z5func0RKSt6vectorIiSaIiEEi+0x1e4>
lea -0x8(%r12),%rdx
mov %r9,%rax
sub %r9,%rdx
mov %rdx,%rsi
shr $0x2,%rsi
add $0x1,%rsi
cmp $0x8,%rdx
jbe 1645 <_Z5func0RKSt6vectorIiSaIiEEi+0x1b5>
mov %rsi,%rdx
movd %r13d,%xmm4
shr $0x2,%rdx
pshufd $0x0,%xmm4,%xmm2
shl $0x4,%rdx
add %r9,%rdx
nopl 0x0(%rax)
movdqu 0x4(%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm1,%xmm0
pandn %xmm2,%xmm1
movdqa %xmm1,%xmm2
por %xmm0,%xmm2
cmp %rax,%rdx
jne 15c8 <_Z5func0RKSt6vectorIiSaIiEEi+0x138>
movdqa %xmm2,%xmm0
mov %rsi,%rax
psrldq $0x8,%xmm0
and $0xfffffffffffffffc,%rax
movdqa %xmm0,%xmm1
movdqa %xmm0,%xmm3
lea (%rcx,%rax,4),%rcx
pcmpgtd %xmm2,%xmm1
movdqa %xmm1,%xmm0
pand %xmm1,%xmm3
pandn %xmm2,%xmm0
por %xmm3,%xmm0
movdqa %xmm0,%xmm2
psrldq $0x4,%xmm2
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand %xmm1,%xmm2
pandn %xmm0,%xmm1
por %xmm2,%xmm1
movd %xmm1,%r13d
cmp %rsi,%rax
je 1674 <_Z5func0RKSt6vectorIiSaIiEEi+0x1e4>
mov (%rcx),%eax
cmp %eax,%r13d
cmovl %eax,%r13d
lea 0x4(%rcx),%rax
cmp %rax,%r12
je 1674 <_Z5func0RKSt6vectorIiSaIiEEi+0x1e4>
mov 0x4(%rcx),%eax
cmp %eax,%r13d
cmovl %eax,%r13d
lea 0x8(%rcx),%rax
cmp %rax,%r12
je 1674 <_Z5func0RKSt6vectorIiSaIiEEi+0x1e4>
mov 0x8(%rcx),%eax
cmp %eax,%r13d
cmovl %eax,%r13d
mov %r9,%rdi
callq 1130 <_ZdlPv@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 16c4 <_Z5func0RKSt6vectorIiSaIiEEi+0x234>
add $0x18,%rsp
mov %r13d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xchg %ax,%ax
mov $0x1,%r8d
jmpq 156e <_Z5func0RKSt6vectorIiSaIiEEi+0xde>
movl $0x1,0x0(,%r13,4)
xor %r9d,%r9d
mov 0x0,%r13d
jmp 1674 <_Z5func0RKSt6vectorIiSaIiEEi+0x1e4>
callq 1150 <__stack_chk_fail@plt>
lea 0x938(%rip),%rdi
callq 10e0 <_ZSt20__throw_length_errorPKc@plt>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r15
movsxd rax, esi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rax
sub rsp, 18h
shr rbx, 3Dh
jnz loc_1621
lea r13d, [rax-1]
mov rbp, rax
movsxd r15, r13d
lea rcx, ds:0[r15*4]
test rax, rax
jz loc_160D
lea rbx, [rcx+4]
mov r14, rdi
mov [rsp+48h+var_40], rcx
mov rdi, rbx; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, rbx; n
xor esi, esi; c
mov rdi, rax; s
lea r12, [rax+rbx]
call _memset
mov dword ptr [rax+r15*4], 1
mov r10, rax
cmp ebp, 1
jz short loc_14EB
mov rcx, [rsp+48h+var_40]
mov r9, [r14]
mov r11d, r13d
lea r13, [rcx-4]
nop dword ptr [rax+00000000h]
loc_1498:
cmp ebp, r11d
jle loc_15F8
mov edi, [r9+r13]
mov ecx, r11d
xor r8d, r8d
nop dword ptr [rax+rax+00h]
loc_14B0:
mov esi, [r9+rcx*4]
mov eax, esi
cdq
idiv edi
test edx, edx
jz short loc_14C6
mov eax, edi
cdq
idiv esi
test edx, edx
jnz short loc_14D1
loc_14C6:
mov eax, [r10+rcx*4]
cmp r8d, eax
cmovl r8d, eax
loc_14D1:
add rcx, 1
cmp ebp, ecx
jg short loc_14B0
add r8d, 1
mov [r10+r13], r8d
sub r13, 4
sub r11d, 1
jnz short loc_1498
loc_14EB:
lea rcx, [r10+4]
mov ebp, [r10]
cmp rcx, r12
jz loc_15D5
lea rdx, [r12-8]
mov rax, r10
sub rdx, r10
mov rsi, rdx
shr rsi, 2
add rsi, 1
cmp rdx, 8
jbe loc_15AC
mov rdx, rsi
movd xmm3, ebp
shr rdx, 2
pshufd xmm2, xmm3, 0
shl rdx, 4
add rdx, r10
nop word ptr [rax+rax+00h]
loc_1538:
movdqu xmm0, xmmword ptr [rax+4]
add rax, 10h
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm2
pand xmm0, xmm1
pandn xmm1, xmm2
movdqa xmm2, xmm1
por xmm2, xmm0
cmp rdx, rax
jnz short loc_1538
movdqa xmm1, xmm2
mov rax, rsi
psrldq xmm1, 8
and rax, 0FFFFFFFFFFFFFFFCh
and esi, 3
movdqa xmm0, xmm1
lea rcx, [rcx+rax*4]
pcmpgtd xmm0, xmm2
pand xmm1, xmm0
pandn xmm0, xmm2
por xmm0, xmm1
movdqa xmm2, xmm0
psrldq xmm2, 4
movdqa xmm1, xmm2
pcmpgtd xmm1, xmm0
pand xmm2, xmm1
pandn xmm1, xmm0
por xmm1, xmm2
movd ebp, xmm1
jz short loc_15D5
loc_15AC:
mov eax, [rcx]
cmp ebp, eax
cmovl ebp, eax
lea rax, [rcx+4]
cmp r12, rax
jz short loc_15D5
mov eax, [rcx+4]
cmp ebp, eax
cmovl ebp, eax
lea rax, [rcx+8]
cmp r12, rax
jz short loc_15D5
mov eax, [rcx+8]
cmp ebp, eax
cmovl ebp, eax
loc_15D5:
mov rsi, rbx; unsigned __int64
mov rdi, r10; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_15E0:
add rsp, 18h
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_15F8:
mov dword ptr [r10+r13], 1
sub r11d, 1
sub r13, 4
jmp loc_1498
loc_160D:
mov dword ptr ds:0FFFFFFFFFFFFFFFCh, 1
mov ebp, ds:dword_0
jmp short loc_15E0
loc_1621:
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*) | long long func0(long long *a1, int a2)
{
int v2; // r13d
long long v3; // rcx
size_t v4; // rbx
char *v5; // rax
signed int *v6; // r12
char *v7; // rax
char *v8; // r10
long long v9; // r9
int v10; // r11d
long long v11; // r13
int v12; // edi
long long v13; // rcx
int v14; // r8d
signed int *v15; // rcx
signed int v16; // ebp
unsigned long long v17; // rsi
__m128i v18; // xmm2
__m128i v19; // xmm0
__m128i v20; // xmm1
__m128i v21; // xmm1
__m128i v22; // xmm0
__m128i v23; // xmm0
__m128i v24; // xmm2
__m128i v25; // xmm1
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v2 = a2 - 1;
v3 = 4LL * (a2 - 1);
if ( a2 )
{
v4 = v3 + 4;
v5 = (char *)operator new(v3 + 4);
v6 = (signed int *)&v5[v4];
v7 = (char *)memset(v5, 0, v4);
*(_DWORD *)&v7[4 * v2] = 1;
v8 = v7;
if ( a2 != 1 )
{
v9 = *a1;
v10 = a2 - 1;
v11 = 4LL * v2 - 4;
do
{
while ( a2 <= v10 )
{
*(_DWORD *)&v7[v11] = 1;
--v10;
v11 -= 4LL;
}
v12 = *(_DWORD *)(v9 + v11);
v13 = (unsigned int)v10;
v14 = 0;
do
{
if ( (!(*(_DWORD *)(v9 + 4 * v13) % v12) || !(v12 % *(_DWORD *)(v9 + 4 * v13)))
&& v14 < *(_DWORD *)&v7[4 * v13] )
{
v14 = *(_DWORD *)&v7[4 * v13];
}
++v13;
}
while ( a2 > (int)v13 );
*(_DWORD *)&v7[v11] = v14 + 1;
v11 -= 4LL;
--v10;
}
while ( v10 );
}
v15 = (signed int *)(v7 + 4);
v16 = *(_DWORD *)v7;
if ( v7 + 4 != (char *)v6 )
{
v17 = ((unsigned long long)((char *)(v6 - 2) - v7) >> 2) + 1;
if ( (unsigned long long)((char *)(v6 - 2) - v7) <= 8 )
goto LABEL_18;
v18 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v16), 0);
do
{
v19 = _mm_loadu_si128((const __m128i *)(v7 + 4));
v7 += 16;
v20 = _mm_cmpgt_epi32(v19, v18);
v18 = _mm_or_si128(_mm_andnot_si128(v20, v18), _mm_and_si128(v19, v20));
}
while ( &v8[16 * (v17 >> 2)] != v7 );
v21 = _mm_srli_si128(v18, 8);
v15 += v17 & 0xFFFFFFFFFFFFFFFCLL;
v22 = _mm_cmpgt_epi32(v21, v18);
v23 = _mm_or_si128(_mm_andnot_si128(v22, v18), _mm_and_si128(v21, v22));
v24 = _mm_srli_si128(v23, 4);
v25 = _mm_cmpgt_epi32(v24, v23);
v16 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v25, v23), _mm_and_si128(v24, v25)));
if ( (v17 & 3) != 0 )
{
LABEL_18:
if ( v16 < *v15 )
v16 = *v15;
if ( v6 != v15 + 1 )
{
if ( v16 < v15[1] )
v16 = v15[1];
if ( v6 != v15 + 2 && v16 < v15[2] )
v16 = v15[2];
}
}
}
operator delete(v8, v4);
}
else
{
MEMORY[0xFFFFFFFFFFFFFFFC] = 1;
return 1179403647;
}
return (unsigned int)v16;
} | func0:
ENDBR64
PUSH R15
MOVSXD RAX,ESI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RAX
SUB RSP,0x18
SHR RBX,0x3d
JNZ 0x00101621
LEA R13D,[RAX + -0x1]
MOV RBP,RAX
MOVSXD R15,R13D
LEA RCX,[R15*0x4]
TEST RAX,RAX
JZ 0x0010160d
LEA RBX,[RCX + 0x4]
MOV R14,RDI
MOV qword ptr [RSP + 0x8],RCX
MOV RDI,RBX
CALL 0x00101100
MOV RDX,RBX
XOR ESI,ESI
MOV RDI,RAX
LEA R12,[RAX + RBX*0x1]
CALL 0x001010d0
MOV dword ptr [RAX + R15*0x4],0x1
MOV R10,RAX
CMP EBP,0x1
JZ 0x001014eb
MOV RCX,qword ptr [RSP + 0x8]
MOV R9,qword ptr [R14]
MOV R11D,R13D
LEA R13,[RCX + -0x4]
NOP dword ptr [RAX]
LAB_00101498:
CMP EBP,R11D
JLE 0x001015f8
MOV EDI,dword ptr [R9 + R13*0x1]
MOV ECX,R11D
XOR R8D,R8D
NOP dword ptr [RAX + RAX*0x1]
LAB_001014b0:
MOV ESI,dword ptr [R9 + RCX*0x4]
MOV EAX,ESI
CDQ
IDIV EDI
TEST EDX,EDX
JZ 0x001014c6
MOV EAX,EDI
CDQ
IDIV ESI
TEST EDX,EDX
JNZ 0x001014d1
LAB_001014c6:
MOV EAX,dword ptr [R10 + RCX*0x4]
CMP R8D,EAX
CMOVL R8D,EAX
LAB_001014d1:
ADD RCX,0x1
CMP EBP,ECX
JG 0x001014b0
ADD R8D,0x1
MOV dword ptr [R10 + R13*0x1],R8D
SUB R13,0x4
SUB R11D,0x1
JNZ 0x00101498
LAB_001014eb:
LEA RCX,[R10 + 0x4]
MOV EBP,dword ptr [R10]
CMP RCX,R12
JZ 0x001015d5
LEA RDX,[R12 + -0x8]
MOV RAX,R10
SUB RDX,R10
MOV RSI,RDX
SHR RSI,0x2
ADD RSI,0x1
CMP RDX,0x8
JBE 0x001015ac
MOV RDX,RSI
MOVD XMM3,EBP
SHR RDX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RDX,0x4
ADD RDX,R10
NOP word ptr [RAX + RAX*0x1]
LAB_00101538:
MOVDQU XMM0,xmmword ptr [RAX + 0x4]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM0,XMM1
PANDN XMM1,XMM2
MOVDQA XMM2,XMM1
POR XMM2,XMM0
CMP RDX,RAX
JNZ 0x00101538
MOVDQA XMM1,XMM2
MOV RAX,RSI
PSRLDQ XMM1,0x8
AND RAX,-0x4
AND ESI,0x3
MOVDQA XMM0,XMM1
LEA RCX,[RCX + RAX*0x4]
PCMPGTD XMM0,XMM2
PAND XMM1,XMM0
PANDN XMM0,XMM2
POR XMM0,XMM1
MOVDQA XMM2,XMM0
PSRLDQ XMM2,0x4
MOVDQA XMM1,XMM2
PCMPGTD XMM1,XMM0
PAND XMM2,XMM1
PANDN XMM1,XMM0
POR XMM1,XMM2
MOVD EBP,XMM1
JZ 0x001015d5
LAB_001015ac:
MOV EAX,dword ptr [RCX]
CMP EBP,EAX
CMOVL EBP,EAX
LEA RAX,[RCX + 0x4]
CMP R12,RAX
JZ 0x001015d5
MOV EAX,dword ptr [RCX + 0x4]
CMP EBP,EAX
CMOVL EBP,EAX
LEA RAX,[RCX + 0x8]
CMP R12,RAX
JZ 0x001015d5
MOV EAX,dword ptr [RCX + 0x8]
CMP EBP,EAX
CMOVL EBP,EAX
LAB_001015d5:
MOV RSI,RBX
MOV RDI,R10
CALL 0x00101110
LAB_001015e0:
ADD RSP,0x18
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015f8:
MOV dword ptr [R10 + R13*0x1],0x1
SUB R11D,0x1
SUB R13,0x4
JMP 0x00101498
LAB_0010160d:
MOV dword ptr [0xfffffffffffffffc],0x1
MOV EBP,dword ptr [0x00000000]
JMP 0x001015e0
LAB_00101621:
LEA RDI,[0x102008]
CALL 0x001010c0
NOP dword ptr [RAX] | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&, int) */
void * func0(vector *param_1,int param_2)
{
ulong __n;
uint *puVar1;
uint *puVar2;
int iVar3;
int iVar4;
long lVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
void *pvVar9;
uint *puVar10;
uint *puVar11;
void *extraout_RAX;
ulong uVar12;
uint *puVar13;
ulong uVar14;
char *pcVar15;
uint uVar16;
uint uVar17;
long lVar18;
uint uVar19;
uint uVar20;
uint uVar21;
uint uVar22;
uint uVar23;
uint uVar24;
if ((ulong)(long)param_2 >> 0x3d != 0) {
pcVar15 = "cannot create std::vector larger than max_size()";
std::__throw_length_error("cannot create std::vector larger than max_size()");
pvVar9 = *(void **)pcVar15;
if (pvVar9 != (void *)0x0) {
operator_delete(pvVar9,*(long *)(pcVar15 + 0x10) - (long)pvVar9);
return extraout_RAX;
}
return pvVar9;
}
uVar17 = param_2 - 1;
lVar18 = (long)(int)uVar17 * 4;
if ((long)param_2 == 0) {
_DAT_fffffffffffffffc = 1;
uVar17 = _DAT_00000000;
goto LAB_001015e0;
}
__n = lVar18 + 4;
pvVar9 = operator_new(__n);
puVar2 = (uint *)((long)pvVar9 + __n);
puVar10 = (uint *)memset(pvVar9,0,__n);
puVar10[(int)uVar17] = 1;
if (param_2 != 1) {
lVar5 = *(long *)param_1;
lVar18 = lVar18 + -4;
do {
for (; param_2 <= (int)uVar17; uVar17 = uVar17 - 1) {
*(int4 *)((long)puVar10 + lVar18) = 1;
lVar18 = lVar18 + -4;
}
iVar3 = *(int *)(lVar5 + lVar18);
uVar12 = (ulong)uVar17;
uVar16 = 0;
do {
iVar4 = *(int *)(lVar5 + uVar12 * 4);
if ((iVar4 % iVar3 == 0) || (iVar3 % iVar4 == 0)) {
if ((int)uVar16 < (int)puVar10[uVar12]) {
uVar16 = puVar10[uVar12];
}
}
uVar12 = uVar12 + 1;
} while ((int)uVar12 < param_2);
*(uint *)((long)puVar10 + lVar18) = uVar16 + 1;
lVar18 = lVar18 + -4;
uVar17 = uVar17 - 1;
} while (uVar17 != 0);
}
puVar13 = puVar10 + 1;
uVar17 = *puVar10;
if (puVar13 != puVar2) {
uVar12 = (long)puVar2 + (-8 - (long)puVar10);
uVar14 = (uVar12 >> 2) + 1;
if (8 < uVar12) {
puVar11 = puVar10;
uVar16 = uVar17;
uVar20 = uVar17;
uVar24 = uVar17;
do {
puVar1 = puVar11 + 1;
puVar6 = puVar11 + 2;
puVar7 = puVar11 + 3;
puVar8 = puVar11 + 4;
puVar11 = puVar11 + 4;
uVar19 = -(uint)((int)uVar17 < (int)*puVar1);
uVar21 = -(uint)((int)uVar16 < (int)*puVar6);
uVar22 = -(uint)((int)uVar20 < (int)*puVar7);
uVar23 = -(uint)((int)uVar24 < (int)*puVar8);
uVar17 = ~uVar19 & uVar17 | *puVar1 & uVar19;
uVar16 = ~uVar21 & uVar16 | *puVar6 & uVar21;
uVar20 = ~uVar22 & uVar20 | *puVar7 & uVar22;
uVar24 = ~uVar23 & uVar24 | *puVar8 & uVar23;
} while (puVar10 + (uVar14 & 0xfffffffffffffffc) != puVar11);
puVar13 = puVar13 + (uVar14 & 0xfffffffffffffffc);
uVar17 = ~-(uint)((int)uVar17 < (int)uVar20) & uVar17 |
uVar20 & -(uint)((int)uVar17 < (int)uVar20);
uVar16 = ~-(uint)((int)uVar16 < (int)uVar24) & uVar16 |
uVar24 & -(uint)((int)uVar16 < (int)uVar24);
uVar20 = -(uint)((int)uVar17 < (int)uVar16);
uVar17 = ~uVar20 & uVar17 | uVar16 & uVar20;
if ((uVar14 & 3) == 0) goto LAB_001015d5;
}
if ((int)uVar17 < (int)*puVar13) {
uVar17 = *puVar13;
}
if (puVar2 != puVar13 + 1) {
if ((int)uVar17 < (int)puVar13[1]) {
uVar17 = puVar13[1];
}
if ((puVar2 != puVar13 + 2) && ((int)uVar17 < (int)puVar13[2])) {
uVar17 = puVar13[2];
}
}
}
LAB_001015d5:
operator_delete(puVar10,__n);
LAB_001015e0:
return (void *)(ulong)uVar17;
} |
2,480 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <cctype>
#include <algorithm>
using namespace std;
| vector<string> func0(const vector<string>& test_list, int K) {
vector<string> res;
for (const auto &ele : test_list) {
if (!ele.empty() && all_of(ele.begin(), ele.end(), [](char c){ return isdigit(c); })) {
int num = stoi(ele);
res.push_back(to_string(num + K));
} else {
res.push_back(ele);
}
}
return res;
}
| int main() {
{
vector<string> input = {"MSM", "234", "is", "98", "123", "best", "4"};
vector<string> expected = {"MSM", "240", "is", "104", "129", "best", "10"};
assert(func0(input, 6) == expected);
}
{
vector<string> input = {"Dart", "356", "is", "88", "169", "Super", "6"};
vector<string> expected = {"Dart", "368", "is", "100", "181", "Super", "18"};
assert(func0(input, 12) == expected);
}
{
vector<string> input = {"Flutter", "451", "is", "44", "96", "Magnificent", "12"};
vector<string> expected = {"Flutter", "484", "is", "77", "129", "Magnificent", "45"};
assert(func0(input, 33) == expected);
}
return 0;
}
| O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&, int)::{lambda(char)#1}::operator()(char) const:
push %rbp
mov %rsp,%rbp
mov %rdi,-0x8(%rbp)
mov %esi,%eax
mov %al,-0xc(%rbp)
movsbl -0xc(%rbp),%eax
sub $0x30,%eax
cmp $0x9,%eax
setbe %al
movzbl %al,%eax
pop %rbp
retq
| _ZZ5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEiENKUlcE_clEc:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov eax, esi
mov [rbp+var_C], al
movsx eax, [rbp+var_C]
sub eax, 30h ; '0'
cmp eax, 9
setbe al
movzx eax, al
pop rbp
retn | _BOOL8 func0(std::vector<std::string> const&,int)::{lambda(char)#1}::operator()(long long a1, char a2)
{
return (unsigned int)(a2 - 48) <= 9;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV dword ptr [RBP + -0x84],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDI,RAX
CALL 0x001034ba
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00103c24
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00103c70
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0010271e
LAB_0010264f:
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x00103d24
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00102480
XOR EAX,0x1
TEST AL,AL
JZ 0x001026a3
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001024b0
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001023b0
MOV RSI,RBX
MOV RDI,RAX
LAB_00102693:
CALL 0x00102e98
TEST AL,AL
JZ 0x001026a3
MOV EAX,0x1
JMP 0x001026a8
LAB_001026a3:
MOV EAX,0x0
LAB_001026a8:
TEST AL,AL
JZ 0x001026ff
MOV RAX,qword ptr [RBP + -0x48]
MOV EDX,0xa
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00103359
MOV dword ptr [RBP + -0x64],EAX
MOV EDX,dword ptr [RBP + -0x64]
MOV EAX,dword ptr [RBP + -0x84]
ADD EDX,EAX
LEA RAX,[RBP + -0x40]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x001033a7
LEA RDX,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x78]
MOV RSI,RDX
MOV RDI,RAX
LAB_001026ec:
CALL 0x00103d3a
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00102330
JMP 0x00102712
LAB_001026ff:
MOV RDX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x78]
MOV RSI,RDX
MOV RDI,RAX
LAB_0010270d:
CALL 0x00103d70
LAB_00102712:
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x00103d00
LAB_0010271e:
LEA RDX,[RBP + -0x58]
LEA RAX,[RBP + -0x60]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00103cc0
TEST AL,AL
JNZ 0x0010264f
JMP 0x00102782
LAB_00102782:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00102796
CALL 0x00102410
LAB_00102796:
MOV RAX,qword ptr [RBP + -0x78]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<std::string, std::allocator<std::string > > const&, int) */
vector * func0(vector *param_1,int param_2)
{
char cVar1;
bool bVar2;
int8 uVar3;
int8 uVar4;
int4 in_register_00000034;
long in_FS_OFFSET;
int8 local_68;
int8 local_60;
vector<std::string,std::allocator<std::string>> *local_58;
string *local_50;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<std::string,std::allocator<std::string>>::vector
((vector<std::string,std::allocator<std::string>> *)param_1);
local_58 = (vector<std::string,std::allocator<std::string>> *)
CONCAT44(in_register_00000034,param_2);
local_68 = std::vector<std::string,std::allocator<std::string>>::begin
((vector<std::string,std::allocator<std::string>> *)
CONCAT44(in_register_00000034,param_2));
local_60 = std::vector<std::string,std::allocator<std::string>>::end(local_58);
do {
bVar2 = operator!=((__normal_iterator *)&local_68,(__normal_iterator *)&local_60);
if (!bVar2) {
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
local_50 = (string *)
__normal_iterator<std::string_const*,std::vector<std::string,std::allocator<std::string>>>
::operator*((__normal_iterator<std::string_const*,std::vector<std::string,std::allocator<std::string>>>
*)&local_68);
cVar1 = std::string::empty();
if (cVar1 == '\x01') {
LAB_001026a3:
bVar2 = false;
}
else {
uVar3 = std::string::end();
uVar4 = std::string::begin();
/* try { // try from 00102693 to 001026c1 has its CatchHandler @ 00102750 */
cVar1 = std::
all_of<__normal_iterator<char_const*,std::string>,func0(std::vector<std::string,std::allocator<std::string>>const&,int)::_lambda(char)_1_>
(uVar4,uVar3);
if (cVar1 == '\0') goto LAB_001026a3;
bVar2 = true;
}
if (bVar2) {
std::stoi(local_50,(ulong *)0x0,10);
std::to_string((int)local_48);
/* try { // try from 001026ec to 001026f0 has its CatchHandler @ 0010273b */
std::vector<std::string,std::allocator<std::string>>::push_back
((vector<std::string,std::allocator<std::string>> *)param_1,local_48);
std::string::~string(local_48);
}
else {
/* try { // try from 0010270d to 00102711 has its CatchHandler @ 00102750 */
std::vector<std::string,std::allocator<std::string>>::push_back
((vector<std::string,std::allocator<std::string>> *)param_1,local_50);
}
__normal_iterator<std::string_const*,std::vector<std::string,std::allocator<std::string>>>::
operator++((__normal_iterator<std::string_const*,std::vector<std::string,std::allocator<std::string>>>
*)&local_68);
} while( true );
} |
2,481 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <cctype>
#include <algorithm>
using namespace std;
| vector<string> func0(const vector<string>& test_list, int K) {
vector<string> res;
for (const auto &ele : test_list) {
if (!ele.empty() && all_of(ele.begin(), ele.end(), [](char c){ return isdigit(c); })) {
int num = stoi(ele);
res.push_back(to_string(num + K));
} else {
res.push_back(ele);
}
}
return res;
}
| int main() {
{
vector<string> input = {"MSM", "234", "is", "98", "123", "best", "4"};
vector<string> expected = {"MSM", "240", "is", "104", "129", "best", "10"};
assert(func0(input, 6) == expected);
}
{
vector<string> input = {"Dart", "356", "is", "88", "169", "Super", "6"};
vector<string> expected = {"Dart", "368", "is", "100", "181", "Super", "18"};
assert(func0(input, 12) == expected);
}
{
vector<string> input = {"Flutter", "451", "is", "44", "96", "Magnificent", "12"};
vector<string> expected = {"Flutter", "484", "is", "77", "129", "Magnificent", "45"};
assert(func0(input, 33) == expected);
}
return 0;
}
| O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,%rbp
mov %edx,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbx
mov 0x8(%rsi),%r13
cmp %r13,%rbx
je 1652 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x309>
lea 0x28(%rsp),%rax
mov %rax,0x10(%rsp)
mov $0x80000000,%r15d
lea 0x30(%rsp),%rax
mov %rax,0x8(%rsp)
jmpq 147c <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x133>
add $0x1,%rax
cmp %rdi,%rax
je 1513 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x1ca>
mov 0x8(%rbp),%rdi
cmp 0x10(%rbp),%rdi
je 159a <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x251>
lea 0x10(%rdi),%rax
mov %rax,(%rdi)
mov (%rcx),%rsi
mov %rsi,%rdx
add 0x8(%rcx),%rdx
callq 2322 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag>
jmp 146a <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x121>
add $0x2,%rax
jmp 13bc <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x73>
add $0x3,%rax
jmp 13bc <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x73>
mov %r12,%rax
jmpq 14ef <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x1a6>
movsbl (%rax),%edx
sub $0x30,%edx
cmp $0x9,%edx
ja 13bc <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x73>
add $0x1,%rax
movsbl (%rax),%edx
sub $0x30,%edx
cmp $0x9,%edx
ja 13bc <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x73>
add $0x1,%rax
movsbl (%rax),%edx
sub $0x30,%edx
cmp $0x9,%edx
jbe 1513 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x1ca>
jmp 13bc <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x73>
lea 0x1c4c(%rip),%rdi
callq 1190 <_ZSt24__throw_invalid_argumentPKc@plt>
endbr64
mov %rax,%rbx
cmpl $0x0,(%r14)
jne 144e <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x105>
mov 0x1c(%rsp),%eax
mov %eax,(%r14)
mov %rbp,%rdi
callq 1f92 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED1Ev>
mov %rbx,%rdi
callq 1240 <_Unwind_Resume@plt>
lea 0x1c1c(%rip),%rdi
callq 1210 <_ZSt20__throw_out_of_rangePKc@plt>
addq $0x20,0x8(%rbp)
add $0x20,%rbx
cmp %rbx,%r13
je 1652 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x309>
mov %rbx,%rcx
mov 0x8(%rbx),%rax
test %rax,%rax
je 13c5 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x7c>
mov (%rbx),%r12
lea (%r12,%rax,1),%rdi
sar $0x2,%rax
test %rax,%rax
jle 13f7 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0xae>
lea (%r12,%rax,4),%rsi
mov %r12,%rax
movsbl (%rax),%edx
sub $0x30,%edx
cmp $0x9,%edx
ja 13bc <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x73>
movsbl 0x1(%rax),%edx
sub $0x30,%edx
cmp $0x9,%edx
ja 13b8 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x6f>
movsbl 0x2(%rax),%edx
sub $0x30,%edx
cmp $0x9,%edx
ja 13eb <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0xa2>
movsbl 0x3(%rax),%edx
sub $0x30,%edx
cmp $0x9,%edx
ja 13f1 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0xa8>
add $0x4,%rax
cmp %rsi,%rax
jne 14a7 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x15e>
mov %rdi,%rdx
sub %rax,%rdx
cmp $0x2,%rdx
je 140e <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0xc5>
cmp $0x3,%rdx
je 13ff <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0xb6>
cmp $0x1,%rdx
je 141d <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0xd4>
callq 1150 <__errno_location@plt>
mov %rax,%r14
mov (%rax),%eax
mov %eax,0x1c(%rsp)
movl $0x0,(%r14)
mov $0xa,%edx
mov 0x10(%rsp),%rsi
mov %r12,%rdi
callq 1200 <strtol@plt>
cmp 0x28(%rsp),%r12
je 142e <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0xe5>
mov (%r14),%edx
cmp $0x22,%edx
je 145e <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x115>
lea (%rax,%r15,1),%rcx
mov $0xffffffff,%esi
cmp %rsi,%rcx
ja 145e <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x115>
test %edx,%edx
jne 156e <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x225>
mov 0x1c(%rsp),%ecx
mov %ecx,(%r14)
mov 0x18(%rsp),%ecx
lea (%rcx,%rax,1),%r8d
lea 0x1b09(%rip),%rcx
mov $0x10,%edx
mov 0x3a4f(%rip),%rsi
mov 0x8(%rsp),%rdi
mov $0x0,%eax
callq 23dc <_ZN9__gnu_cxx12__to_xstringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcEET_PFiPT0_mPKS8_P13__va_list_tagEmSB_z>
jmp 15ad <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x264>
mov %rcx,%rdx
mov %rdi,%rsi
mov %rbp,%rdi
callq 2630 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_>
jmpq 146f <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x126>
mov 0x8(%rbp),%rsi
cmp 0x10(%rbp),%rsi
je 15f8 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x2af>
lea 0x10(%rsi),%rax
mov %rax,(%rsi)
mov 0x30(%rsp),%rax
lea 0x40(%rsp),%rdx
cmp %rdx,%rax
je 15ec <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x2a3>
mov %rax,(%rsi)
mov 0x40(%rsp),%rax
mov %rax,0x10(%rsi)
mov 0x38(%rsp),%rax
mov %rax,0x8(%rsi)
addq $0x20,0x8(%rbp)
jmpq 146f <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x126>
movdqa 0x40(%rsp),%xmm0
movups %xmm0,0x10(%rsi)
jmp 15d9 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x290>
mov 0x8(%rsp),%rdx
mov %rbp,%rdi
callq 2120 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_>
mov 0x30(%rsp),%rdi
lea 0x40(%rsp),%rax
cmp %rax,%rdi
je 146f <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x126>
callq 11d0 <_ZdlPv@plt>
jmpq 146f <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x126>
endbr64
mov %rax,%rbx
mov 0x30(%rsp),%rdi
lea 0x40(%rsp),%rax
cmp %rax,%rdi
je 144e <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x105>
callq 11d0 <_ZdlPv@plt>
jmpq 144e <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x105>
endbr64
mov %rax,%rbx
jmpq 144e <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x105>
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 1674 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi+0x32b>
mov %rbp,%rax
add $0x68,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 11f0 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 128h
mov r13, rdi
mov [rsp+158h+var_154], edx
mov rax, fs:28h
mov [rsp+158h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rbp, [rsi]
mov r15, [rsi+8]
cmp r15, rbp
jz loc_1C8F
lea rax, [rsp+158h+var_140]
mov [rsp+158h+var_150], rax
jmp loc_152A
loc_140E:
add rax, 1
loc_1412:
cmp rdi, rax
jz loc_15C2
loc_141B:
mov rdi, [r13+8]
cmp rdi, [r13+10h]
jz loc_16A9
lea rax, [rdi+10h]
mov [rdi], rax
mov rax, [rsi]
mov rdx, rax
add rdx, [rsi+8]
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
jmp loc_1518
loc_1447:
add rax, 2
jmp short loc_1412
loc_144D:
add rax, 3
jmp short loc_1412
loc_1453:
mov rcx, rbx
jmp loc_159E
loc_145B:
movsx eax, byte ptr [rcx]
sub eax, 30h ; '0'
cmp eax, 9
ja short loc_148D
add rcx, 1
loc_146A:
movsx eax, byte ptr [rcx]
sub eax, 30h ; '0'
cmp eax, 9
ja short loc_1492
add rcx, 1
loc_1479:
movsx eax, byte ptr [rcx]
sub eax, 30h ; '0'
cmp eax, 9
jbe loc_15C2
mov rax, rcx
jmp short loc_1412
loc_148D:
mov rax, rcx
jmp short loc_1412
loc_1492:
mov rax, rcx
jmp loc_1412
loc_149A:
mov rax, [rsp+158h+var_40]
sub rax, fs:28h
jnz short loc_14B9
lea rdi, aStoi; "stoi"
call __ZSt24__throw_invalid_argumentPKc; std::__throw_invalid_argument(char const*)
loc_14B9:
call ___stack_chk_fail
loc_14BE:
mov rax, [rsp+158h+var_40]
sub rax, fs:28h
jnz short loc_1513
lea rdi, aStoi; "stoi"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
endbr64
mov rbx, rax
cmp dword ptr [r12], 0
jnz short loc_14EF
mov [r12], r14d
loc_14EF:
mov rdi, r13
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, [rsp+158h+var_40]
sub rax, fs:28h
jz loc_1C5A
call ___stack_chk_fail
loc_1513:
call ___stack_chk_fail
loc_1518:
add qword ptr [r13+8], 20h ; ' '
loc_151D:
add rbp, 20h ; ' '
cmp r15, rbp
jz loc_1C8F
loc_152A:
mov rsi, rbp
mov rax, [rbp+8]
test rax, rax
jz loc_141B
mov rbx, [rbp+0]
lea rdi, [rbx+rax]
sar rax, 2
test rax, rax
jle loc_1453
lea rcx, [rbx+rax*4]
mov rax, rbx
loc_1556:
movsx edx, byte ptr [rax]
sub edx, 30h ; '0'
cmp edx, 9
ja loc_1412
movsx edx, byte ptr [rax+1]
sub edx, 30h ; '0'
cmp edx, 9
ja loc_140E
movsx edx, byte ptr [rax+2]
sub edx, 30h ; '0'
cmp edx, 9
ja loc_1447
movsx edx, byte ptr [rax+3]
sub edx, 30h ; '0'
cmp edx, 9
ja loc_144D
add rax, 4
cmp rcx, rax
jnz short loc_1556
loc_159E:
mov rax, rdi
sub rax, rcx
cmp rax, 2
jz loc_146A
cmp rax, 3
jz loc_145B
cmp rax, 1
jz loc_1479
loc_15C2:
call ___errno_location
mov r12, rax
mov r14d, [rax]
mov dword ptr [rax], 0
mov edx, 0Ah
mov rsi, [rsp+158h+var_150]
mov rdi, rbx
call ___isoc23_strtol
cmp rbx, [rsp+158h+var_140]
jz loc_149A
mov edx, [r12]
cmp edx, 22h ; '"'
jz loc_14BE
mov ebx, 80000000h
lea rcx, [rax+rbx]
lea rbx, [rbx+7FFFFFFFh]
cmp rbx, rcx
jb loc_14BE
test edx, edx
jnz short loc_161E
mov [r12], r14d
loc_161E:
mov edi, [rsp+158h+var_154]
add eax, edi
mov r14d, eax
shr r14d, 1Fh
mov r12d, eax
neg r12d
cmovs r12d, eax
cmp r12d, 9
jbe loc_1C62
cmp r12d, 63h ; 'c'
jbe short loc_16BC
cmp r12d, 3E7h
jbe loc_1912
cmp r12d, 270Fh
jbe loc_1B59
mov eax, r12d
mov ebx, 1
mov rcx, 346DC5D63886594Bh
loc_1671:
mov eax, eax
mul rcx
shr rdx, 0Bh
mov eax, edx
add ebx, 4
cmp edx, 9
jbe loc_191A
cmp edx, 63h ; 'c'
jbe short loc_16C1
cmp edx, 3E7h
jbe loc_1917
cmp edx, 270Fh
ja short loc_1671
loc_16A1:
add ebx, 3
jmp loc_191A
loc_16A9:
mov rdx, rsi
mov rsi, rdi
mov rdi, r13
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string const&>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string const&)
jmp loc_151D
loc_16BC:
mov ebx, 1
loc_16C1:
lea rdi, [rsp+158h+var_138]
lea rax, [rsp+158h+var_128]
mov [rsp+158h+var_138], rax
lea esi, [rbx+r14+1]
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
movzx r14d, r14b
add r14, [rsp+158h+var_138]
mov rax, 3330323031303030h
mov rdx, 3730363035303430h
mov [rsp+158h+var_118], rax
mov [rsp+158h+var_110], rdx
mov rax, 3131303139303830h
mov rdx, 3531343133313231h
mov [rsp+158h+var_108], rax
mov [rsp+158h+var_100], rdx
mov rax, 3931383137313631h
mov rdx, 3332323231323032h
mov [rsp+158h+var_F8], rax
mov [rsp+158h+var_F0], rdx
mov rax, 3732363235323432h
mov rdx, 3133303339323832h
mov [rsp+158h+var_E8], rax
mov [rsp+158h+var_E0], rdx
mov rax, 3533343333333233h
mov rdx, 3933383337333633h
mov [rsp+158h+var_D8], rax
mov [rsp+158h+var_D0], rdx
mov rax, 3334323431343034h
mov rdx, 3734363435343434h
mov [rsp+158h+var_C8], rax
mov [rsp+158h+var_C0], rdx
mov rax, 3135303539343834h
mov rdx, 3535343533353235h
mov [rsp+158h+var_B8], rax
mov [rsp+158h+var_B0], rdx
mov rax, 3935383537353635h
mov rdx, 3336323631363036h
mov [rsp+158h+var_A8], rax
mov [rsp+158h+var_A0], rdx
mov rax, 3736363635363436h
mov rdx, 3137303739363836h
mov [rsp+158h+var_98], rax
mov [rsp+158h+var_90], rdx
mov rax, 3537343733373237h
mov rdx, 3937383737373637h
mov [rsp+158h+var_88], rax
mov [rsp+158h+var_80], rdx
mov rax, 3338323831383038h
mov rdx, 3738363835383438h
mov [rsp+158h+var_78], rax
mov [rsp+158h+var_70], rdx
mov rax, 3139303939383838h
mov rdx, 3539343933393239h
mov [rsp+158h+var_68], rax
mov [rsp+158h+var_60], rdx
mov rax, 3935393439333932h
mov rdx, 39393839373936h
mov [rsp+158h+var_60+1], rax
mov [rsp+158h+var_57], rdx
cmp r12d, 63h ; 'c'
ja loc_1AFF
loc_18AE:
add r12d, r12d
lea eax, [r12+1]
movzx eax, byte ptr [rsp+rax+158h+var_118]
mov [r14+1], al
mov r12d, r12d
movzx r12d, byte ptr [rsp+r12+158h+var_118]
loc_18C8:
mov [r14], r12b
mov rsi, [r13+8]
cmp rsi, [r13+10h]
jz loc_1C05
lea rdx, [rsi+10h]
mov [rsi], rdx
mov rax, [rsp+158h+var_138]
lea rcx, [rsp+158h+var_128]
cmp rax, rcx
jz loc_1B63
mov [rsi], rax
mov rax, [rsp+158h+var_128]
mov [rsi+10h], rax
loc_18FF:
mov rax, [rsp+158h+var_130]
mov [rsi+8], rax
add qword ptr [r13+8], 20h ; ' '
jmp loc_151D
loc_1912:
mov ebx, 1
loc_1917:
add ebx, 2
loc_191A:
lea rdi, [rsp+158h+var_138]
lea rax, [rsp+158h+var_128]
mov [rsp+158h+var_138], rax
lea esi, [r14+rbx]
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
movzx r14d, r14b
add r14, [rsp+158h+var_138]
mov rax, 3330323031303030h
mov rdx, 3730363035303430h
mov [rsp+158h+var_118], rax
mov [rsp+158h+var_110], rdx
mov rax, 3131303139303830h
mov rdx, 3531343133313231h
mov [rsp+158h+var_108], rax
mov [rsp+158h+var_100], rdx
mov rax, 3931383137313631h
mov rdx, 3332323231323032h
mov [rsp+158h+var_F8], rax
mov [rsp+158h+var_F0], rdx
mov rax, 3732363235323432h
mov rdx, 3133303339323832h
mov [rsp+158h+var_E8], rax
mov [rsp+158h+var_E0], rdx
mov rax, 3533343333333233h
mov rdx, 3933383337333633h
mov [rsp+158h+var_D8], rax
mov [rsp+158h+var_D0], rdx
mov rax, 3334323431343034h
mov rdx, 3734363435343434h
mov [rsp+158h+var_C8], rax
mov [rsp+158h+var_C0], rdx
mov rax, 3135303539343834h
mov rdx, 3535343533353235h
mov [rsp+158h+var_B8], rax
mov [rsp+158h+var_B0], rdx
mov rax, 3935383537353635h
mov rdx, 3336323631363036h
mov [rsp+158h+var_A8], rax
mov [rsp+158h+var_A0], rdx
mov rax, 3736363635363436h
mov rdx, 3137303739363836h
mov [rsp+158h+var_98], rax
mov [rsp+158h+var_90], rdx
mov rax, 3537343733373237h
mov rdx, 3937383737373637h
mov [rsp+158h+var_88], rax
mov [rsp+158h+var_80], rdx
mov rax, 3338323831383038h
mov rdx, 3738363835383438h
mov [rsp+158h+var_78], rax
mov [rsp+158h+var_70], rdx
mov rax, 3139303939383838h
mov rdx, 3539343933393239h
mov [rsp+158h+var_68], rax
mov [rsp+158h+var_60], rdx
mov rax, 3935393439333932h
mov rdx, 39393839373936h
mov [rsp+158h+var_60+1], rax
mov [rsp+158h+var_57], rdx
sub ebx, 1
loc_1AFF:
mov edx, r12d
imul rdx, 51EB851Fh
shr rdx, 25h
imul ecx, edx, 64h ; 'd'
mov eax, r12d
sub eax, ecx
add eax, eax
mov ecx, r12d
mov r12d, edx
mov edx, ebx
lea esi, [rax+1]
movzx esi, byte ptr [rsp+rsi+158h+var_118]
mov [r14+rdx], sil
lea edx, [rbx-1]
mov eax, eax
movzx eax, byte ptr [rsp+rax+158h+var_118]
mov [r14+rdx], al
sub ebx, 2
cmp ecx, 270Fh
ja short loc_1AFF
cmp ecx, 3E7h
ja loc_18AE
loc_1B50:
add r12d, 30h ; '0'
jmp loc_18C8
loc_1B59:
mov ebx, 1
jmp loc_16A1
loc_1B63:
mov rax, [rsp+158h+var_130]
add rax, 1
cmp eax, 8
jnb short loc_1BB5
test al, 4
jnz short loc_1B9F
test eax, eax
jz loc_18FF
movzx edi, byte ptr [rsp+158h+var_128]
mov [rsi+10h], dil
test al, 2
jz loc_18FF
mov eax, eax
movzx ecx, word ptr [rcx+rax-2]
mov [rdx+rax-2], cx
jmp loc_18FF
loc_1B9F:
mov edi, dword ptr [rsp+158h+var_128]
mov [rsi+10h], edi
mov eax, eax
mov ecx, [rcx+rax-4]
mov [rdx+rax-4], ecx
jmp loc_18FF
loc_1BB5:
mov rdi, [rsp+158h+var_128]
mov [rsi+10h], rdi
mov edi, eax
mov r8, [rcx+rdi-8]
mov [rdx+rdi-8], r8
lea rdi, [rdx+8]
and rdi, 0FFFFFFFFFFFFFFF8h
sub rdx, rdi
sub rcx, rdx
add eax, edx
and eax, 0FFFFFFF8h
cmp eax, 8
jb loc_18FF
and eax, 0FFFFFFF8h
mov edx, 0
loc_1BEE:
mov r8d, edx
mov r9, [rcx+r8]
mov [rdi+r8], r9
add edx, 8
cmp edx, eax
jb short loc_1BEE
jmp loc_18FF
loc_1C05:
lea rdx, [rsp+158h+var_138]
mov rdi, r13
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string &&)
mov rdi, [rsp+158h+var_138]; void *
lea rax, [rsp+158h+var_128]
cmp rdi, rax
jz loc_151D
mov rax, [rsp+158h+var_128]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_151D
endbr64
mov rbx, rax
lea rdi, [rsp+158h+var_138]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
jmp loc_14EF
endbr64
mov rbx, rax
jmp loc_14EF
loc_1C5A:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1C62:
lea rdi, [rsp+158h+var_138]
lea rax, [rsp+158h+var_128]
mov [rsp+158h+var_138], rax
lea esi, [r14+1]
mov esi, esi
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
movzx r14d, r14b
add r14, [rsp+158h+var_138]
jmp loc_1B50
loc_1C8F:
mov rax, [rsp+158h+var_40]
sub rax, fs:28h
jnz short loc_1CB7
mov rax, r13
add rsp, 128h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1CB7:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, char ***a2, int a3, char *a4)
{
char **v5; // rbp
char **v6; // r15
char *v7; // rax
_QWORD *v8; // rdi
long long v9; // rax
char *v10; // rbx
char *v11; // rdi
long long v12; // rax
signed long long v13; // rax
int *v14; // r12
int v15; // r14d
long long v16; // rax
int v17; // eax
unsigned int v18; // r14d
unsigned int v19; // r12d
unsigned int v20; // eax
unsigned int v21; // ebx
unsigned int v22; // edx
char *v23; // r14
int v24; // r12d
char v25; // r12
void **v26; // rsi
_QWORD *v27; // rdx
unsigned int v28; // eax
unsigned int v29; // ecx
unsigned int v30; // eax
unsigned long long v31; // rdi
char *v32; // rdx
unsigned int v33; // eax
unsigned int v34; // eax
unsigned int v35; // edx
char *v38; // [rsp+18h] [rbp-140h] BYREF
void *v39; // [rsp+20h] [rbp-138h] BYREF
void *v40; // [rsp+28h] [rbp-130h]
_QWORD v41[2]; // [rsp+30h] [rbp-128h] BYREF
char v42[216]; // [rsp+40h] [rbp-118h] BYREF
unsigned long long v43; // [rsp+118h] [rbp-40h]
v43 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v5 = *a2;
v6 = a2[1];
if ( v6 != *a2 )
{
do
{
v9 = (long long)v5[1];
if ( !v9 )
goto LABEL_5;
v10 = *v5;
v11 = &(*v5)[v9];
v12 = v9 >> 2;
if ( v12 <= 0 )
{
a4 = *v5;
LABEL_29:
v13 = v11 - a4;
if ( v11 - a4 != 2 )
{
if ( v13 != 3 )
{
if ( v13 != 1 )
{
LABEL_32:
v14 = __errno_location();
v15 = *v14;
*v14 = 0;
v16 = __isoc23_strtol(v10, &v38, 10LL);
if ( v10 == v38 )
std::__throw_invalid_argument("stoi");
if ( *v14 == 34 || (unsigned long long)(v16 + 0x80000000LL) > 0xFFFFFFFF )
std::__throw_out_of_range("stoi");
if ( !*v14 )
*v14 = v15;
v17 = a3 + v16;
v18 = (unsigned int)v17 >> 31;
v19 = -v17;
if ( v17 > 0 )
v19 = v17;
if ( v19 <= 9 )
{
v39 = v41;
std::string::_M_construct(&v39, v18 + 1, 45LL);
v23 = (char *)v39 + (unsigned __int8)v18;
goto LABEL_62;
}
if ( v19 <= 0x63 )
{
v21 = 1;
LABEL_51:
v39 = v41;
std::string::_M_construct(&v39, v21 + v18 + 1, 45LL);
v23 = (char *)v39 + (unsigned __int8)v18;
strcpy(
v42,
"000102030405060708091011121314151617181920212223242526272829303132333435363738394041424344454647484950"
"51525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899");
if ( v19 > 0x63 )
goto LABEL_60;
}
else
{
if ( v19 <= 0x3E7 )
{
v21 = 1;
LABEL_58:
v21 += 2;
}
else if ( v19 <= 0x270F )
{
v21 = 1;
LABEL_48:
v21 += 3;
}
else
{
v20 = v19;
v21 = 1;
while ( 1 )
{
v22 = v20 / 0x2710;
v20 = v22;
v21 += 4;
if ( v22 <= 9 )
break;
if ( v22 <= 0x63 )
goto LABEL_51;
if ( v22 <= 0x3E7 )
goto LABEL_58;
if ( v22 <= 0x270F )
goto LABEL_48;
}
}
v39 = v41;
std::string::_M_construct(&v39, v18 + v21, 45LL);
v23 = (char *)v39 + (unsigned __int8)v18;
strcpy(
v42,
"000102030405060708091011121314151617181920212223242526272829303132333435363738394041424344454647484950"
"51525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899");
--v21;
do
{
LABEL_60:
v28 = 2 * (v19 % 0x64);
v29 = v19;
v19 /= 0x64u;
v23[v21] = v42[v28 + 1];
v23[v21 - 1] = v42[v28];
v21 -= 2;
}
while ( v29 > 0x270F );
if ( v29 <= 0x3E7 )
{
LABEL_62:
v25 = v19 + 48;
LABEL_53:
*v23 = v25;
v26 = (void **)a1[1];
if ( v26 == (void **)a1[2] )
{
std::vector<std::string>::_M_realloc_insert<std::string>(a1, v26, &v39);
if ( v39 != v41 )
operator delete(v39, v41[0] + 1LL);
}
else
{
v27 = v26 + 2;
*v26 = v26 + 2;
a4 = (char *)v41;
if ( v39 == v41 )
{
v30 = (_DWORD)v40 + 1;
if ( (unsigned int)((_DWORD)v40 + 1) >= 8 )
{
v26[2] = (void *)v41[0];
*(_QWORD *)((char *)v27 + v30 - 8) = *(_QWORD *)((char *)&v41[-1] + v30);
v31 = (unsigned long long)(v26 + 3) & 0xFFFFFFFFFFFFFFF8LL;
v32 = (char *)v27 - v31;
a4 = (char *)((char *)v41 - v32);
v33 = ((_DWORD)v32 + v30) & 0xFFFFFFF8;
if ( v33 >= 8 )
{
v34 = v33 & 0xFFFFFFF8;
v35 = 0;
do
{
*(_QWORD *)(v31 + v35) = *(_QWORD *)&a4[v35];
v35 += 8;
}
while ( v35 < v34 );
}
}
else if ( (v30 & 4) != 0 )
{
*((_DWORD *)v26 + 4) = v41[0];
a4 = (char *)*(unsigned int *)((char *)&v40 + v30 + 4);
*(_DWORD *)((char *)v27 + v30 - 4) = (_DWORD)a4;
}
else if ( (_DWORD)v40 != -1 )
{
*((_BYTE *)v26 + 16) = v41[0];
if ( (v30 & 2) != 0 )
{
a4 = (char *)*(unsigned __int16 *)((char *)&v40 + v30 + 6);
*(_WORD *)((char *)v27 + v30 - 2) = (_WORD)a4;
}
}
}
else
{
*v26 = v39;
v26[2] = (void *)v41[0];
}
v26[1] = v40;
a1[1] += 32LL;
}
goto LABEL_20;
}
}
v24 = 2 * v19;
v23[1] = v42[v24 + 1];
v25 = v42[v24];
goto LABEL_53;
}
goto LABEL_14;
}
if ( (unsigned int)(*a4 - 48) > 9 )
{
v7 = a4;
goto LABEL_4;
}
++a4;
}
if ( (unsigned int)(*a4 - 48) <= 9 )
{
++a4;
LABEL_14:
if ( (unsigned int)(*a4 - 48) <= 9 )
goto LABEL_32;
v7 = a4;
goto LABEL_4;
}
v7 = a4;
}
else
{
a4 = &v10[4 * v12];
v7 = *v5;
while ( (unsigned int)(*v7 - 48) <= 9 )
{
if ( (unsigned int)(v7[1] - 48) > 9 )
{
++v7;
break;
}
if ( (unsigned int)(v7[2] - 48) > 9 )
{
v7 += 2;
break;
}
if ( (unsigned int)(v7[3] - 48) > 9 )
{
v7 += 3;
break;
}
v7 += 4;
if ( a4 == v7 )
goto LABEL_29;
}
}
LABEL_4:
if ( v11 == v7 )
goto LABEL_32;
LABEL_5:
v8 = (_QWORD *)a1[1];
if ( v8 == (_QWORD *)a1[2] )
{
std::vector<std::string>::_M_realloc_insert<std::string const&>(a1, a1[1], v5, a4);
}
else
{
*v8 = v8 + 2;
std::string::_M_construct<char *>(v8, *v5, &(*v5)[(_QWORD)v5[1]]);
a1[1] += 32LL;
}
LABEL_20:
v5 += 4;
}
while ( v6 != v5 );
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x128
MOV R13,RDI
MOV dword ptr [RSP + 0x4],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x118],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBP,qword ptr [RSI]
MOV R15,qword ptr [RSI + 0x8]
CMP R15,RBP
JZ 0x00101c8f
LEA RAX,[RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0010152a
LAB_0010140e:
ADD RAX,0x1
LAB_00101412:
CMP RDI,RAX
JZ 0x001015c2
LAB_0010141b:
MOV RDI,qword ptr [R13 + 0x8]
CMP RDI,qword ptr [R13 + 0x10]
JZ 0x001016a9
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI]
MOV RDX,RAX
ADD RDX,qword ptr [RSI + 0x8]
MOV RSI,RAX
LAB_0010143d:
CALL 0x001022b0
JMP 0x00101518
LAB_00101447:
ADD RAX,0x2
JMP 0x00101412
LAB_0010144d:
ADD RAX,0x3
JMP 0x00101412
LAB_00101453:
MOV RCX,RBX
JMP 0x0010159e
LAB_0010145b:
MOVSX EAX,byte ptr [RCX]
SUB EAX,0x30
CMP EAX,0x9
JA 0x0010148d
ADD RCX,0x1
LAB_0010146a:
MOVSX EAX,byte ptr [RCX]
SUB EAX,0x30
CMP EAX,0x9
JA 0x00101492
ADD RCX,0x1
LAB_00101479:
MOVSX EAX,byte ptr [RCX]
SUB EAX,0x30
CMP EAX,0x9
JBE 0x001015c2
MOV RAX,RCX
JMP 0x00101412
LAB_0010148d:
MOV RAX,RCX
JMP 0x00101412
LAB_00101492:
MOV RAX,RCX
JMP 0x00101412
LAB_0010149a:
MOV RAX,qword ptr [RSP + 0x118]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014b9
LEA RDI,[0x10301e]
LAB_001014b4:
CALL 0x001011d0
LAB_001014b9:
CALL 0x00101230
LAB_001014be:
MOV RAX,qword ptr [RSP + 0x118]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101513
LEA RDI,[0x10301e]
CALL 0x00101260
LAB_001014dd:
ENDBR64
MOV RBX,RAX
CMP dword ptr [R12],0x0
JNZ 0x001014ef
MOV dword ptr [R12],R14D
LAB_001014ef:
MOV RDI,R13
CALL 0x001021de
MOV RAX,qword ptr [RSP + 0x118]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101c5a
CALL 0x00101230
LAB_00101513:
CALL 0x00101230
LAB_00101518:
ADD qword ptr [R13 + 0x8],0x20
LAB_0010151d:
ADD RBP,0x20
CMP R15,RBP
JZ 0x00101c8f
LAB_0010152a:
MOV RSI,RBP
MOV RAX,qword ptr [RBP + 0x8]
TEST RAX,RAX
JZ 0x0010141b
MOV RBX,qword ptr [RBP]
LEA RDI,[RBX + RAX*0x1]
SAR RAX,0x2
TEST RAX,RAX
JLE 0x00101453
LEA RCX,[RBX + RAX*0x4]
MOV RAX,RBX
LAB_00101556:
MOVSX EDX,byte ptr [RAX]
SUB EDX,0x30
CMP EDX,0x9
JA 0x00101412
MOVSX EDX,byte ptr [RAX + 0x1]
SUB EDX,0x30
CMP EDX,0x9
JA 0x0010140e
MOVSX EDX,byte ptr [RAX + 0x2]
SUB EDX,0x30
CMP EDX,0x9
JA 0x00101447
MOVSX EDX,byte ptr [RAX + 0x3]
SUB EDX,0x30
CMP EDX,0x9
JA 0x0010144d
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x00101556
LAB_0010159e:
MOV RAX,RDI
SUB RAX,RCX
CMP RAX,0x2
JZ 0x0010146a
CMP RAX,0x3
JZ 0x0010145b
CMP RAX,0x1
JZ 0x00101479
LAB_001015c2:
CALL 0x00101180
MOV R12,RAX
MOV R14D,dword ptr [RAX]
MOV dword ptr [RAX],0x0
MOV EDX,0xa
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,RBX
CALL 0x001012b0
CMP RBX,qword ptr [RSP + 0x18]
JZ 0x0010149a
MOV EDX,dword ptr [R12]
CMP EDX,0x22
JZ 0x001014be
MOV EBX,0x80000000
LEA RCX,[RAX + RBX*0x1]
LEA RBX,[RBX + 0x7fffffff]
CMP RBX,RCX
JC 0x001014be
TEST EDX,EDX
JNZ 0x0010161e
MOV dword ptr [R12],R14D
LAB_0010161e:
MOV EDI,dword ptr [RSP + 0x4]
ADD EAX,EDI
MOV R14D,EAX
SHR R14D,0x1f
MOV R12D,EAX
NEG R12D
CMOVS R12D,EAX
CMP R12D,0x9
JBE 0x00101c62
CMP R12D,0x63
JBE 0x001016bc
CMP R12D,0x3e7
JBE 0x00101912
CMP R12D,0x270f
JBE 0x00101b59
MOV EAX,R12D
MOV EBX,0x1
MOV RCX,0x346dc5d63886594b
LAB_00101671:
MOV EAX,EAX
MUL RCX
SHR RDX,0xb
MOV EAX,EDX
ADD EBX,0x4
CMP EDX,0x9
JBE 0x0010191a
CMP EDX,0x63
JBE 0x001016c1
CMP EDX,0x3e7
JBE 0x00101917
CMP EDX,0x270f
JA 0x00101671
LAB_001016a1:
ADD EBX,0x3
JMP 0x0010191a
LAB_001016a9:
MOV RDX,RSI
MOV RSI,RDI
MOV RDI,R13
LAB_001016b2:
CALL 0x0010234c
JMP 0x0010151d
LAB_001016bc:
MOV EBX,0x1
LAB_001016c1:
LEA RDI,[RSP + 0x20]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LEA ESI,[RBX + R14*0x1 + 0x1]
MOV EDX,0x2d
CALL 0x00101240
MOVZX R14D,R14B
ADD R14,qword ptr [RSP + 0x20]
MOV RAX,0x3330323031303030
MOV RDX,0x3730363035303430
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,0x3131303139303830
MOV RDX,0x3531343133313231
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,0x3931383137313631
MOV RDX,0x3332323231323032
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
MOV RAX,0x3732363235323432
MOV RDX,0x3133303339323832
MOV qword ptr [RSP + 0x70],RAX
MOV qword ptr [RSP + 0x78],RDX
MOV RAX,0x3533343333333233
MOV RDX,0x3933383337333633
MOV qword ptr [RSP + 0x80],RAX
MOV qword ptr [RSP + 0x88],RDX
MOV RAX,0x3334323431343034
MOV RDX,0x3734363435343434
MOV qword ptr [RSP + 0x90],RAX
MOV qword ptr [RSP + 0x98],RDX
MOV RAX,0x3135303539343834
MOV RDX,0x3535343533353235
MOV qword ptr [RSP + 0xa0],RAX
MOV qword ptr [RSP + 0xa8],RDX
MOV RAX,0x3935383537353635
MOV RDX,0x3336323631363036
MOV qword ptr [RSP + 0xb0],RAX
MOV qword ptr [RSP + 0xb8],RDX
MOV RAX,0x3736363635363436
MOV RDX,0x3137303739363836
MOV qword ptr [RSP + 0xc0],RAX
MOV qword ptr [RSP + 0xc8],RDX
MOV RAX,0x3537343733373237
MOV RDX,0x3937383737373637
MOV qword ptr [RSP + 0xd0],RAX
MOV qword ptr [RSP + 0xd8],RDX
MOV RAX,0x3338323831383038
MOV RDX,0x3738363835383438
MOV qword ptr [RSP + 0xe0],RAX
MOV qword ptr [RSP + 0xe8],RDX
MOV RAX,0x3139303939383838
MOV RDX,0x3539343933393239
MOV qword ptr [RSP + 0xf0],RAX
MOV qword ptr [RSP + 0xf8],RDX
MOV RAX,0x3935393439333932
MOV RDX,0x39393839373936
MOV qword ptr [RSP + 0xf9],RAX
MOV qword ptr [RSP + 0x101],RDX
CMP R12D,0x63
JA 0x00101aff
LAB_001018ae:
ADD R12D,R12D
LEA EAX,[R12 + 0x1]
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x40]
MOV byte ptr [R14 + 0x1],AL
MOV R12D,R12D
MOVZX R12D,byte ptr [RSP + R12*0x1 + 0x40]
LAB_001018c8:
MOV byte ptr [R14],R12B
MOV RSI,qword ptr [R13 + 0x8]
CMP RSI,qword ptr [R13 + 0x10]
JZ 0x00101c05
LEA RDX,[RSI + 0x10]
MOV qword ptr [RSI],RDX
MOV RAX,qword ptr [RSP + 0x20]
LEA RCX,[RSP + 0x30]
CMP RAX,RCX
JZ 0x00101b63
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSI + 0x10],RAX
LAB_001018ff:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSI + 0x8],RAX
ADD qword ptr [R13 + 0x8],0x20
JMP 0x0010151d
LAB_00101912:
MOV EBX,0x1
LAB_00101917:
ADD EBX,0x2
LAB_0010191a:
LEA RDI,[RSP + 0x20]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LEA ESI,[R14 + RBX*0x1]
MOV EDX,0x2d
CALL 0x00101240
MOVZX R14D,R14B
ADD R14,qword ptr [RSP + 0x20]
MOV RAX,0x3330323031303030
MOV RDX,0x3730363035303430
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,0x3131303139303830
MOV RDX,0x3531343133313231
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,0x3931383137313631
MOV RDX,0x3332323231323032
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
MOV RAX,0x3732363235323432
MOV RDX,0x3133303339323832
MOV qword ptr [RSP + 0x70],RAX
MOV qword ptr [RSP + 0x78],RDX
MOV RAX,0x3533343333333233
MOV RDX,0x3933383337333633
MOV qword ptr [RSP + 0x80],RAX
MOV qword ptr [RSP + 0x88],RDX
MOV RAX,0x3334323431343034
MOV RDX,0x3734363435343434
MOV qword ptr [RSP + 0x90],RAX
MOV qword ptr [RSP + 0x98],RDX
MOV RAX,0x3135303539343834
MOV RDX,0x3535343533353235
MOV qword ptr [RSP + 0xa0],RAX
MOV qword ptr [RSP + 0xa8],RDX
MOV RAX,0x3935383537353635
MOV RDX,0x3336323631363036
MOV qword ptr [RSP + 0xb0],RAX
MOV qword ptr [RSP + 0xb8],RDX
MOV RAX,0x3736363635363436
MOV RDX,0x3137303739363836
MOV qword ptr [RSP + 0xc0],RAX
MOV qword ptr [RSP + 0xc8],RDX
MOV RAX,0x3537343733373237
MOV RDX,0x3937383737373637
MOV qword ptr [RSP + 0xd0],RAX
MOV qword ptr [RSP + 0xd8],RDX
MOV RAX,0x3338323831383038
MOV RDX,0x3738363835383438
MOV qword ptr [RSP + 0xe0],RAX
MOV qword ptr [RSP + 0xe8],RDX
MOV RAX,0x3139303939383838
MOV RDX,0x3539343933393239
MOV qword ptr [RSP + 0xf0],RAX
MOV qword ptr [RSP + 0xf8],RDX
MOV RAX,0x3935393439333932
MOV RDX,0x39393839373936
MOV qword ptr [RSP + 0xf9],RAX
MOV qword ptr [RSP + 0x101],RDX
SUB EBX,0x1
LAB_00101aff:
MOV EDX,R12D
IMUL RDX,RDX,0x51eb851f
SHR RDX,0x25
IMUL ECX,EDX,0x64
MOV EAX,R12D
SUB EAX,ECX
ADD EAX,EAX
MOV ECX,R12D
MOV R12D,EDX
MOV EDX,EBX
LEA ESI,[RAX + 0x1]
MOVZX ESI,byte ptr [RSP + RSI*0x1 + 0x40]
MOV byte ptr [R14 + RDX*0x1],SIL
LEA EDX,[RBX + -0x1]
MOV EAX,EAX
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x40]
MOV byte ptr [R14 + RDX*0x1],AL
SUB EBX,0x2
CMP ECX,0x270f
JA 0x00101aff
CMP ECX,0x3e7
JA 0x001018ae
LAB_00101b50:
ADD R12D,0x30
JMP 0x001018c8
LAB_00101b59:
MOV EBX,0x1
JMP 0x001016a1
LAB_00101b63:
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x1
CMP EAX,0x8
JNC 0x00101bb5
TEST AL,0x4
JNZ 0x00101b9f
TEST EAX,EAX
JZ 0x001018ff
MOVZX EDI,byte ptr [RSP + 0x30]
MOV byte ptr [RSI + 0x10],DIL
TEST AL,0x2
JZ 0x001018ff
MOV EAX,EAX
MOVZX ECX,word ptr [RCX + RAX*0x1 + -0x2]
MOV word ptr [RDX + RAX*0x1 + -0x2],CX
JMP 0x001018ff
LAB_00101b9f:
MOV EDI,dword ptr [RSP + 0x30]
MOV dword ptr [RSI + 0x10],EDI
MOV EAX,EAX
MOV ECX,dword ptr [RCX + RAX*0x1 + -0x4]
MOV dword ptr [RDX + RAX*0x1 + -0x4],ECX
JMP 0x001018ff
LAB_00101bb5:
MOV RDI,qword ptr [RSP + 0x30]
MOV qword ptr [RSI + 0x10],RDI
MOV EDI,EAX
MOV R8,qword ptr [RCX + RDI*0x1 + -0x8]
MOV qword ptr [RDX + RDI*0x1 + -0x8],R8
LEA RDI,[RDX + 0x8]
AND RDI,-0x8
SUB RDX,RDI
SUB RCX,RDX
ADD EAX,EDX
AND EAX,0xfffffff8
CMP EAX,0x8
JC 0x001018ff
AND EAX,0xfffffff8
MOV EDX,0x0
LAB_00101bee:
MOV R8D,EDX
MOV R9,qword ptr [RCX + R8*0x1]
MOV qword ptr [RDI + R8*0x1],R9
ADD EDX,0x8
CMP EDX,EAX
JC 0x00101bee
JMP 0x001018ff
LAB_00101c05:
LEA RDX,[RSP + 0x20]
MOV RDI,R13
LAB_00101c0d:
CALL 0x00102696
MOV RDI,qword ptr [RSP + 0x20]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x0010151d
MOV RAX,qword ptr [RSP + 0x30]
LEA RSI,[RAX + 0x1]
CALL 0x00101220
JMP 0x0010151d
LAB_00101c5a:
MOV RDI,RBX
LAB_00101c5d:
CALL 0x00101290
LAB_00101c62:
LEA RDI,[RSP + 0x20]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LEA ESI,[R14 + 0x1]
MOV ESI,ESI
MOV EDX,0x2d
CALL 0x00101240
MOVZX R14D,R14B
ADD R14,qword ptr [RSP + 0x20]
JMP 0x00101b50
LAB_00101c8f:
MOV RAX,qword ptr [RSP + 0x118]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101cb7
MOV RAX,R13
ADD RSP,0x128
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101cb7:
CALL 0x00101230 | /* func0(std::vector<std::string, std::allocator<std::string > > const&, int) */
vector * func0(vector *param_1,int param_2)
{
int iVar1;
string *psVar2;
long *plVar3;
char *pcVar4;
uint uVar5;
uint uVar6;
uint uVar7;
int8 uVar8;
char *pcVar9;
long lVar10;
int *piVar11;
long lVar12;
int in_EDX;
ulong uVar13;
string *psVar14;
int4 in_register_00000034;
char cVar15;
ulong uVar16;
uint uVar17;
char *pcVar18;
long in_FS_OFFSET;
char *local_140;
int8 *local_138;
int8 local_130;
int8 local_128;
char local_118 [216];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
psVar14 = *(string **)CONCAT44(in_register_00000034,param_2);
psVar2 = (string *)((long *)CONCAT44(in_register_00000034,param_2))[1];
if (psVar2 != psVar14) {
do {
lVar12 = *(long *)(psVar14 + 8);
if (lVar12 == 0) {
LAB_0010141b:
plVar3 = *(long **)(param_1 + 8);
if (plVar3 == *(long **)(param_1 + 0x10)) {
/* try { // try from 001016b2 to 001016b6 has its CatchHandler @ 00101c4e */
std::vector<std::string,std::allocator<std::string>>::
_M_realloc_insert<std::string_const&>
((vector<std::string,std::allocator<std::string>> *)param_1,
(__normal_iterator)plVar3,psVar14);
}
else {
*plVar3 = (long)(plVar3 + 2);
/* try { // try from 0010143d to 00101441 has its CatchHandler @ 00101c4e */
std::string::_M_construct<char*>
((char *)plVar3,*(char **)psVar14,
(int)*(char **)psVar14 + (int)*(int8 *)(psVar14 + 8));
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x20;
}
}
else {
pcVar18 = *(char **)psVar14;
pcVar4 = pcVar18;
if (0 < lVar12 >> 2) {
pcVar9 = pcVar18;
do {
if (9 < (int)*pcVar9 - 0x30U) goto LAB_00101412;
if (9 < (int)pcVar9[1] - 0x30U) {
pcVar9 = pcVar9 + 1;
goto LAB_00101412;
}
if (9 < (int)pcVar9[2] - 0x30U) {
pcVar9 = pcVar9 + 2;
goto LAB_00101412;
}
if (9 < (int)pcVar9[3] - 0x30U) {
pcVar9 = pcVar9 + 3;
goto LAB_00101412;
}
pcVar9 = pcVar9 + 4;
pcVar4 = pcVar18 + (lVar12 >> 2) * 4;
} while (pcVar18 + (lVar12 >> 2) * 4 != pcVar9);
}
pcVar9 = pcVar4;
lVar10 = (long)(pcVar18 + lVar12) - (long)pcVar9;
if (lVar10 == 2) {
LAB_0010146a:
if ((int)*pcVar9 - 0x30U < 10) {
pcVar9 = pcVar9 + 1;
LAB_00101479:
if ((int)*pcVar9 - 0x30U < 10) goto LAB_001015c2;
}
LAB_00101412:
if (pcVar18 + lVar12 != pcVar9) goto LAB_0010141b;
}
else {
if (lVar10 == 3) {
if ((int)*pcVar9 - 0x30U < 10) {
pcVar9 = pcVar9 + 1;
goto LAB_0010146a;
}
goto LAB_00101412;
}
if (lVar10 == 1) goto LAB_00101479;
}
LAB_001015c2:
piVar11 = __errno_location();
iVar1 = *piVar11;
*piVar11 = 0;
lVar12 = __isoc23_strtol(pcVar18,&local_140,10);
if (pcVar18 == local_140) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* try { // try from 001014b4 to 001014dc has its CatchHandler @ 001014dd */
std::__throw_invalid_argument("stoi");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
if ((*piVar11 == 0x22) || (0xffffffff < lVar12 + 0x80000000U)) {
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
uVar8 = std::__throw_out_of_range("stoi");
/* catch() { ... } // from try @ 001014b4 with catch @ 001014dd */
if (*piVar11 == 0) {
*piVar11 = iVar1;
}
std::vector<std::string,std::allocator<std::string>>::~vector
((vector<std::string,std::allocator<std::string>> *)param_1);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar8);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
if (*piVar11 == 0) {
*piVar11 = iVar1;
}
uVar5 = (int)lVar12 + in_EDX;
uVar17 = uVar5 >> 0x1f;
uVar7 = -uVar5;
if (0 < (int)uVar5) {
uVar7 = uVar5;
}
uVar16 = (ulong)uVar7;
cVar15 = (char)((int)uVar5 >> 0x1f);
if (uVar7 < 10) {
local_138 = &local_128;
std::string::_M_construct((ulong)&local_138,'\x01' - cVar15);
pcVar18 = (char *)((ulong)uVar17 + (long)local_138);
LAB_00101b50:
cVar15 = (char)uVar7 + '0';
}
else {
if (uVar7 < 100) {
uVar5 = 1;
LAB_001016c1:
local_138 = &local_128;
std::string::_M_construct((ulong)&local_138,((char)uVar5 + '\x01') - cVar15);
pcVar18 = (char *)((ulong)uVar17 + (long)local_138);
builtin_strncpy(local_118,
"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"
,0xc9);
if (99 < uVar7) goto LAB_00101aff;
}
else {
if (uVar7 < 1000) {
uVar5 = 1;
LAB_00101917:
uVar5 = uVar5 + 2;
}
else {
if (uVar7 < 10000) {
uVar5 = 1;
}
else {
uVar13 = (ulong)uVar7;
uVar5 = 1;
do {
uVar13 = uVar13 / 10000;
uVar6 = (uint)uVar13;
uVar5 = uVar5 + 4;
if (uVar6 < 10) goto LAB_0010191a;
if (uVar6 < 100) goto LAB_001016c1;
if (uVar6 < 1000) goto LAB_00101917;
} while (9999 < uVar6);
}
uVar5 = uVar5 + 3;
}
LAB_0010191a:
local_138 = &local_128;
std::string::_M_construct((ulong)&local_138,(char)uVar5 - cVar15);
pcVar18 = (char *)((ulong)uVar17 + (long)local_138);
builtin_strncpy(local_118,
"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"
,0xc9);
uVar5 = uVar5 - 1;
LAB_00101aff:
do {
builtin_strncpy(local_118,
"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"
,0xc9);
uVar7 = (uint)(uVar16 / 100);
uVar6 = (uint)uVar16;
uVar17 = (uVar6 + uVar7 * -100) * 2;
pcVar18[uVar5] = local_118[uVar17 + 1];
pcVar18[uVar5 - 1] = local_118[uVar17];
uVar5 = uVar5 - 2;
uVar16 = uVar16 / 100;
} while (9999 < uVar6);
if (uVar6 < 1000) goto LAB_00101b50;
}
builtin_strncpy(local_118,
"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"
,0xc9);
pcVar18[1] = local_118[uVar7 * 2 + 1];
cVar15 = local_118[uVar7 * 2];
}
*pcVar18 = cVar15;
plVar3 = *(long **)(param_1 + 8);
if (plVar3 == *(long **)(param_1 + 0x10)) {
/* try { // try from 00101c0d to 00101c11 has its CatchHandler @ 00101c38 */
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string>
((vector<std::string,std::allocator<std::string>> *)param_1,
(__normal_iterator)plVar3,(string *)&local_138);
if (local_138 != &local_128) {
operator_delete(local_138,CONCAT44(local_128._4_4_,(int4)local_128) + 1);
}
}
else {
*plVar3 = (long)(plVar3 + 2);
if (local_138 == &local_128) {
uVar16 = local_130 + 1;
uVar7 = (uint)uVar16;
if (uVar7 < 8) {
if ((uVar16 & 4) == 0) {
if (uVar7 != 0) {
*(int *)(plVar3 + 2) = (int)local_128;
if ((uVar16 & 2) != 0) {
*(int2 *)((long)plVar3 + (uVar16 & 0xffffffff) + 0xe) =
*(int2 *)((long)&local_130 + (uVar16 & 0xffffffff) + 6);
}
}
}
else {
*(int4 *)(plVar3 + 2) = (int4)local_128;
*(int4 *)((long)plVar3 + (uVar16 & 0xffffffff) + 0xc) =
*(int4 *)((long)&local_130 + (uVar16 & 0xffffffff) + 4);
}
}
else {
plVar3[2] = CONCAT44(local_128._4_4_,(int4)local_128);
*(int8 *)((long)plVar3 + (uVar16 & 0xffffffff) + 8) =
*(int8 *)((long)&local_130 + (uVar16 & 0xffffffff));
lVar12 = (long)(plVar3 + 2) - ((ulong)(plVar3 + 3) & 0xfffffffffffffff8);
uVar7 = uVar7 + (int)lVar12 & 0xfffffff8;
if (7 < uVar7) {
uVar5 = 0;
do {
*(int8 *)(((ulong)(plVar3 + 3) & 0xfffffffffffffff8) + (ulong)uVar5) =
*(int8 *)((long)&local_128 + ((ulong)uVar5 - lVar12));
uVar5 = uVar5 + 8;
} while (uVar5 < uVar7);
}
}
}
else {
*plVar3 = (long)local_138;
plVar3[2] = CONCAT44(local_128._4_4_,(int4)local_128);
}
plVar3[1] = local_130;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x20;
}
}
psVar14 = psVar14 + 0x20;
} while (psVar2 != psVar14);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.