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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
582 | func0 | #include <cassert>
#include <string>
| int func0(const std::string& str1) {
if (!str1.empty()) {
return static_cast<int>(str1[0]);
}
return -1; // Return -1 if string is empty
}
| int main() {
assert(func0("python") == 112);
assert(func0("Program") == 80);
assert(func0("Language") == 76);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
cmpq $0x0,0x8(%rdi)
je 1368 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x18>
mov (%rdi),%rax
movsbl (%rax),%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0xffffffff,%eax
retq
xchg %ax,%ax
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
cmp qword ptr [rdi+8], 0
jz short loc_1358
mov rax, [rdi]
movsx eax, byte ptr [rax]
retn
loc_1358:
mov eax, 0FFFFFFFFh
retn | long long func0(char **a1)
{
if ( a1[1] )
return (unsigned int)**a1;
else
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
CMP qword ptr [RDI + 0x8],0x0
JZ 0x00101358
MOV RAX,qword ptr [RDI]
MOVSX EAX,byte ptr [RAX]
RET
LAB_00101358:
MOV EAX,0xffffffff
RET | /* func0(std::string const&) */
int func0(string *param_1)
{
if (*(long *)(param_1 + 8) != 0) {
return (int)**(char **)param_1;
}
return -1;
} |
583 | func0 | #include <cassert>
#include <string>
| int func0(const std::string& str1) {
if (!str1.empty()) {
return static_cast<int>(str1[0]);
}
return -1; // Return -1 if string is empty
}
| int main() {
assert(func0("python") == 112);
assert(func0("Program") == 80);
assert(func0("Language") == 76);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
cmpq $0x0,0x8(%rdi)
je 1368 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x18>
mov (%rdi),%rax
movsbl (%rax),%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0xffffffff,%eax
retq
xchg %ax,%ax
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
cmp qword ptr [rdi+8], 0
jz short loc_1358
mov rax, [rdi]
movsx eax, byte ptr [rax]
retn
loc_1358:
mov eax, 0FFFFFFFFh
retn | long long func0(char **a1)
{
if ( a1[1] )
return (unsigned int)**a1;
else
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
CMP qword ptr [RDI + 0x8],0x0
JZ 0x00101358
MOV RAX,qword ptr [RDI]
MOVSX EAX,byte ptr [RAX]
RET
LAB_00101358:
MOV EAX,0xffffffff
RET | /* func0(std::string const&) */
int func0(string *param_1)
{
if (*(long *)(param_1 + 8) != 0) {
return (int)**(char **)param_1;
}
return -1;
} |
584 | func0 |
#include <vector>
#include <cassert>
using namespace std;
| int func0(vector<vector<int>>& tri, int m, int n) {
for (int i = m - 1; i >= 0; --i) {
for (int j = 0; j <= i; ++j) {
if (tri[i+1][j] > tri[i+1][j+1]) {
tri[i][j] += tri[i+1][j];
} else {
tri[i][j] += tri[i+1][j+1];
}
}
}
return tri[0][0];
}
| int main() {
vector<vector<int>> triangle1{{1, 0, 0}, {4, 8, 0}, {1, 5, 3}};
assert(func0(triangle1, 2, 2) == 14);
vector<vector<int>> triangle2{{13, 0, 0}, {7, 4, 0}, {2, 4, 6}};
assert(func0(triangle2, 2, 2) == 24);
vector<vector<int>> triangle3{{2, 0, 0}, {11, 18, 0}, {21, 25, 33}};
assert(func0(triangle3, 2, 2) == 53);
return 0;
}
| O0 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >&, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x18(%rbp)
cmpl $0x0,-0x18(%rbp)
js 13f9 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x170>
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jg 13f0 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x167>
mov -0x18(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1d84 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x14(%rbp),%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 1db2 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x18(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1d84 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x14(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 1db2 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
cmp %eax,%ebx
setg %al
test %al,%al
je 1389 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x100>
mov -0x18(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1d84 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x14(%rbp),%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 1db2 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1d84 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x14(%rbp),%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 1db2 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%edx
add %ebx,%edx
mov %edx,(%rax)
jmp 13e7 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x15e>
mov -0x18(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1d84 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x14(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 1db2 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1d84 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x14(%rbp),%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 1db2 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%edx
add %ebx,%edx
mov %edx,(%rax)
addl $0x1,-0x14(%rbp)
jmpq 12ba <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x31>
subl $0x1,-0x18(%rbp)
jmpq 12a9 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x20>
mov -0x28(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 1d84 <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov $0x0,%esi
mov %rax,%rdi
callq 1db2 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov eax, [rbp+var_2C]
sub eax, 1
mov [rbp+var_18], eax
jmp loc_140F
loc_12CE:
mov [rbp+var_14], 0
jmp loc_13FF
loc_12DA:
mov eax, [rbp+var_18]
add eax, 1
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_14]
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_18]
add eax, 1
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_14]
add eax, 1
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
cmp ebx, eax
setnle al
test al, al
jz short loc_139D
mov eax, [rbp+var_18]
add eax, 1
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_14]
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_14]
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov edx, [rax]
add edx, ebx
mov [rax], edx
jmp short loc_13FB
loc_139D:
mov eax, [rbp+var_18]
add eax, 1
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_14]
add eax, 1
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_14]
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov edx, [rax]
add edx, ebx
mov [rax], edx
loc_13FB:
add [rbp+var_14], 1
loc_13FF:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jle loc_12DA
sub [rbp+var_18], 1
loc_140F:
cmp [rbp+var_18], 0
jns loc_12CE
mov rax, [rbp+var_28]
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 eax, [rax]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2)
{
long long v2; // rax
int v3; // ebx
long long v4; // rax
long long v5; // rax
int v6; // ebx
long long v7; // rax
_DWORD *v8; // rax
long long v9; // rax
long long v10; // rax
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
for ( i = a2 - 1; i >= 0; --i )
{
for ( j = 0; j <= i; ++j )
{
v2 = std::vector<std::vector<int>>::operator[](a1, i + 1);
v3 = *(_DWORD *)std::vector<int>::operator[](v2, j);
v4 = std::vector<std::vector<int>>::operator[](a1, i + 1);
if ( v3 <= *(_DWORD *)std::vector<int>::operator[](v4, j + 1) )
{
v9 = std::vector<std::vector<int>>::operator[](a1, i + 1);
v6 = *(_DWORD *)std::vector<int>::operator[](v9, j + 1);
}
else
{
v5 = std::vector<std::vector<int>>::operator[](a1, i + 1);
v6 = *(_DWORD *)std::vector<int>::operator[](v5, j);
}
v7 = std::vector<std::vector<int>>::operator[](a1, i);
v8 = (_DWORD *)std::vector<int>::operator[](v7, j);
*v8 += v6;
}
}
v10 = std::vector<std::vector<int>>::operator[](a1, 0LL);
return *(unsigned int *)std::vector<int>::operator[](v10, 0LL);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
JMP 0x0010140f
LAB_001012ce:
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001013ff
LAB_001012da:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101dae
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00101ddc
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101dae
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00101ddc
MOV EAX,dword ptr [RAX]
CMP EBX,EAX
SETG AL
TEST AL,AL
JZ 0x0010139d
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101dae
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00101ddc
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101dae
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00101ddc
MOV EDX,dword ptr [RAX]
ADD EDX,EBX
MOV dword ptr [RAX],EDX
JMP 0x001013fb
LAB_0010139d:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101dae
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00101ddc
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101dae
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00101ddc
MOV EDX,dword ptr [RAX]
ADD EDX,EBX
MOV dword ptr [RAX],EDX
LAB_001013fb:
ADD dword ptr [RBP + -0x14],0x1
LAB_001013ff:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JLE 0x001012da
SUB dword ptr [RBP + -0x18],0x1
LAB_0010140f:
CMP dword ptr [RBP + -0x18],0x0
JNS 0x001012ce
MOV RAX,qword ptr [RBP + -0x28]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101dae
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101ddc
MOV EAX,dword ptr [RAX]
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> > > >&, int, int) */
int4 func0(vector *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
vector<int,std::allocator<int>> *pvVar3;
int4 *puVar4;
int4 local_20;
int4 local_1c;
for (local_20 = param_2 + -1; -1 < local_20; local_20 = local_20 + -1) {
for (local_1c = 0; local_1c <= local_20; local_1c = local_1c + 1) {
pvVar3 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[]((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)param_1,(long)(local_20 + 1));
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar3,(long)local_1c);
iVar1 = *piVar2;
pvVar3 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[]((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)param_1,(long)(local_20 + 1));
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar3,(long)(local_1c + 1));
if (*piVar2 < iVar1) {
pvVar3 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[]((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)param_1,(long)(local_20 + 1));
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar3,(long)local_1c);
iVar1 = *piVar2;
pvVar3 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[]((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)param_1,(long)local_20);
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar3,(long)local_1c);
*piVar2 = *piVar2 + iVar1;
}
else {
pvVar3 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[]((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)param_1,(long)(local_20 + 1));
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[]
(pvVar3,(long)(local_1c + 1));
iVar1 = *piVar2;
pvVar3 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[]((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)param_1,(long)local_20);
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar3,(long)local_1c);
*piVar2 = *piVar2 + iVar1;
}
}
}
pvVar3 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[]((vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)param_1,0);
puVar4 = (int4 *)std::vector<int,std::allocator<int>>::operator[](pvVar3,0);
return *puVar4;
} |
585 | func0 |
#include <vector>
#include <cassert>
using namespace std;
| int func0(vector<vector<int>>& tri, int m, int n) {
for (int i = m - 1; i >= 0; --i) {
for (int j = 0; j <= i; ++j) {
if (tri[i+1][j] > tri[i+1][j+1]) {
tri[i][j] += tri[i+1][j];
} else {
tri[i][j] += tri[i+1][j+1];
}
}
}
return tri[0][0];
}
| int main() {
vector<vector<int>> triangle1{{1, 0, 0}, {4, 8, 0}, {1, 5, 3}};
assert(func0(triangle1, 2, 2) == 14);
vector<vector<int>> triangle2{{13, 0, 0}, {7, 4, 0}, {2, 4, 6}};
assert(func0(triangle2, 2, 2) == 24);
vector<vector<int>> triangle3{{2, 0, 0}, {11, 18, 0}, {21, 25, 33}};
assert(func0(triangle3, 2, 2) == 53);
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >&, int, int):
endbr64
push %rbx
mov %esi,%ebx
sub $0x1,%ebx
js 131e <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x75>
movslq %ebx,%rax
lea (%rax,%rax,2),%r10
shl $0x3,%r10
jmp 12fc <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x53>
add (%rcx,%r10,1),%rdx
add %esi,(%rdx)
cmp %r11,%rax
je 12f0 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x47>
mov (%rdi),%rcx
mov (%rcx,%r9,1),%rsi
mov (%rsi,%rax,1),%r8d
mov %rax,%rdx
add $0x4,%rax
mov (%rsi,%rax,1),%esi
cmp %esi,%r8d
jle 12c2 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x19>
add (%rcx,%r10,1),%rdx
add %r8d,(%rdx)
jmp 12c8 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x1f>
sub $0x1,%ebx
sub $0x18,%r10
cmp $0xffffffff,%ebx
je 131e <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x75>
test %ebx,%ebx
js 12f0 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x47>
lea 0x1(%rbx),%eax
cltq
lea (%rax,%rax,2),%r9
shl $0x3,%r9
mov %ebx,%eax
lea 0x4(,%rax,4),%r11
mov $0x0,%eax
jmp 12cd <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x24>
mov (%rdi),%rax
mov (%rax),%rax
mov (%rax),%eax
pop %rbx
retq
| _Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
push rbx
mov r11, rdi
mov ebx, esi
sub ebx, 1
js short loc_130F
movsxd rax, ebx
lea r8, [rax+rax*2]
shl r8, 3
jmp short loc_12FC
loc_12C5:
add rdx, [rcx+r8]
add [rdx], esi
loc_12CB:
cmp rax, r9
jz short loc_12F0
loc_12D0:
mov rcx, [r11]
mov rsi, [rcx+r10]
mov edi, [rsi+rax]
mov rdx, rax
add rax, 4
mov esi, [rsi+rax]
cmp edi, esi
jle short loc_12C5
add rdx, [rcx+r8]
add [rdx], edi
jmp short loc_12CB
loc_12F0:
sub ebx, 1
sub r8, 18h
cmp ebx, 0FFFFFFFFh
jz short loc_130F
loc_12FC:
lea r10, [r8+18h]
lea r9d, [rbx+1]
shl r9, 2
mov eax, 0
jmp short loc_12D0
loc_130F:
mov rax, [r11]
mov rax, [rax]
mov eax, [rax]
pop rbx
retn | long long func0(unsigned int ***a1, int a2)
{
int v3; // ebx
long long v4; // r8
long long v5; // rcx
unsigned int *v6; // rsi
signed int v7; // edi
long long v8; // rdx
long long v9; // rax
signed int v10; // esi
v3 = a2 - 1;
if ( a2 - 1 >= 0 )
{
v4 = 3LL * v3;
do
{
v9 = 0LL;
do
{
v5 = (long long)*a1;
v6 = (*a1)[v4 + 3];
v7 = v6[v9];
v8 = v9 * 4;
v10 = v6[++v9];
if ( v7 <= v10 )
*(_DWORD *)(*(_QWORD *)(v5 + v4 * 8) + v8) += v10;
else
*(_DWORD *)(*(_QWORD *)(v5 + v4 * 8) + v8) += v7;
}
while ( v9 != v3 + 1 );
--v3;
v4 -= 3LL;
}
while ( v3 != -1 );
}
return ***a1;
} | func0:
ENDBR64
PUSH RBX
MOV R11,RDI
MOV EBX,ESI
SUB EBX,0x1
JS 0x0010130f
MOVSXD RAX,EBX
LEA R8,[RAX + RAX*0x2]
SHL R8,0x3
JMP 0x001012fc
LAB_001012c5:
ADD RDX,qword ptr [RCX + R8*0x1]
ADD dword ptr [RDX],ESI
LAB_001012cb:
CMP RAX,R9
JZ 0x001012f0
LAB_001012d0:
MOV RCX,qword ptr [R11]
MOV RSI,qword ptr [RCX + R10*0x1]
MOV EDI,dword ptr [RSI + RAX*0x1]
MOV RDX,RAX
ADD RAX,0x4
MOV ESI,dword ptr [RSI + RAX*0x1]
CMP EDI,ESI
JLE 0x001012c5
ADD RDX,qword ptr [RCX + R8*0x1]
ADD dword ptr [RDX],EDI
JMP 0x001012cb
LAB_001012f0:
SUB EBX,0x1
SUB R8,0x18
CMP EBX,-0x1
JZ 0x0010130f
LAB_001012fc:
LEA R10,[R8 + 0x18]
LEA R9D,[RBX + 0x1]
SHL R9,0x2
MOV EAX,0x0
JMP 0x001012d0
LAB_0010130f:
MOV RAX,qword ptr [R11]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
POP RBX
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >&, int, int) */
int [16] func0(vector *param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
int4 in_register_00000014;
int *piVar7;
int iVar8;
long lVar9;
int auVar10 [16];
piVar7 = (int *)CONCAT44(in_register_00000014,param_3);
iVar8 = param_2 + -1;
if (-1 < iVar8) {
lVar9 = (long)iVar8 * 0x18;
do {
lVar5 = 0;
do {
lVar3 = *(long *)param_1;
lVar4 = *(long *)(lVar3 + lVar9 + 0x18);
iVar1 = *(int *)(lVar4 + lVar5);
lVar6 = lVar5 + 4;
iVar2 = *(int *)(lVar4 + lVar6);
if (iVar2 < iVar1) {
piVar7 = (int *)(lVar5 + *(long *)(lVar3 + lVar9));
*piVar7 = *piVar7 + iVar1;
}
else {
piVar7 = (int *)(lVar5 + *(long *)(lVar3 + lVar9));
*piVar7 = *piVar7 + iVar2;
}
lVar5 = lVar6;
} while (lVar6 != (ulong)(iVar8 + 1) << 2);
iVar8 = iVar8 + -1;
lVar9 = lVar9 + -0x18;
} while (iVar8 != -1);
}
auVar10._4_4_ = 0;
auVar10._0_4_ = *(uint *)**(int8 **)param_1;
auVar10._8_8_ = piVar7;
return auVar10;
} |
586 | func0 |
#include <vector>
#include <cassert>
using namespace std;
| int func0(vector<vector<int>>& tri, int m, int n) {
for (int i = m - 1; i >= 0; --i) {
for (int j = 0; j <= i; ++j) {
if (tri[i+1][j] > tri[i+1][j+1]) {
tri[i][j] += tri[i+1][j];
} else {
tri[i][j] += tri[i+1][j+1];
}
}
}
return tri[0][0];
}
| int main() {
vector<vector<int>> triangle1{{1, 0, 0}, {4, 8, 0}, {1, 5, 3}};
assert(func0(triangle1, 2, 2) == 14);
vector<vector<int>> triangle2{{13, 0, 0}, {7, 4, 0}, {2, 4, 6}};
assert(func0(triangle2, 2, 2) == 24);
vector<vector<int>> triangle3{{2, 0, 0}, {11, 18, 0}, {21, 25, 33}};
assert(func0(triangle3, 2, 2) == 53);
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >&, int, int):
endbr64
push %rbx
mov (%rdi),%rbx
sub $0x1,%esi
js 17c2 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x62>
movslq %esi,%rax
mov %esi,%r10d
lea (%rax,%rax,2),%rax
lea (%rbx,%rax,8),%r11
nopl 0x0(%rax,%rax,1)
mov 0x18(%r11),%r8
mov (%r11),%rdi
xor %eax,%eax
nopl 0x0(%rax)
mov (%r8,%rax,4),%esi
mov 0x4(%r8,%rax,4),%ecx
mov (%rdi,%rax,4),%edx
lea (%rcx,%rdx,1),%r9d
add %esi,%edx
cmp %ecx,%esi
cmovle %r9d,%edx
mov %edx,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%r10d
jge 1790 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x30>
sub $0x1,%r10d
sub $0x18,%r11
cmp $0xffffffff,%r10d
jne 1780 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x20>
mov (%rbx),%rax
pop %rbx
mov (%rax),%eax
retq
nopl 0x0(%rax)
| _Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
push r12
push rbp
push rbx
mov ebx, esi
mov rbp, [rdi]
sub ebx, 1
js short loc_18BA
movsxd rsi, esi
lea rax, [rsi+rsi*2]
lea r11, [rbp+rax*8+0]
xchg ax, ax
loc_1870:
lea r10d, [rbx+1]
mov r8, [r11]
mov r12, [r11-18h]
xor edx, edx
movsxd r10, r10d
shl r10, 2
nop dword ptr [rax+00h]
loc_1888:
lea rcx, [r12+rdx]
mov edi, [r8+rdx]
mov esi, [r8+rdx+4]
mov eax, [rcx]
lea r9d, [rsi+rax]
add eax, edi
cmp edi, esi
cmovle eax, r9d
add rdx, 4
mov [rcx], eax
cmp r10, rdx
jnz short loc_1888
sub ebx, 1
sub r11, 18h
cmp ebx, 0FFFFFFFFh
jnz short loc_1870
loc_18BA:
mov rax, [rbp+0]
pop rbx
pop rbp
pop r12
mov eax, [rax]
retn | long long func0(unsigned int ***a1, int a2)
{
unsigned int **v2; // rbp
int v3; // ebx
unsigned int **v4; // r11
unsigned int *v5; // r8
long long v6; // r12
long long v7; // rdx
_DWORD *v8; // rcx
signed int v9; // edi
signed int v10; // esi
int v11; // eax
int v12; // r9d
int v13; // eax
v2 = *a1;
v3 = a2 - 1;
if ( a2 - 1 >= 0 )
{
v4 = &v2[3 * a2];
do
{
v5 = *v4;
v6 = (long long)*(v4 - 3);
v7 = 0LL;
do
{
v8 = (_DWORD *)(v6 + v7 * 4);
v9 = v5[v7];
v10 = v5[v7 + 1];
v11 = *(_DWORD *)(v6 + v7 * 4);
v12 = v10 + v11;
v13 = v9 + v11;
if ( v9 <= v10 )
v13 = v12;
++v7;
*v8 = v13;
}
while ( v3 + 1 != v7 );
--v3;
v4 -= 3;
}
while ( v3 != -1 );
}
return **v2;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
MOV RBP,qword ptr [RDI]
SUB EBX,0x1
JS 0x001018ba
MOVSXD RSI,ESI
LEA RAX,[RSI + RSI*0x2]
LEA R11,[RBP + RAX*0x8]
NOP
LAB_00101870:
LEA R10D,[RBX + 0x1]
MOV R8,qword ptr [R11]
MOV R12,qword ptr [R11 + -0x18]
XOR EDX,EDX
MOVSXD R10,R10D
SHL R10,0x2
NOP dword ptr [RAX]
LAB_00101888:
LEA RCX,[R12 + RDX*0x1]
MOV EDI,dword ptr [R8 + RDX*0x1]
MOV ESI,dword ptr [R8 + RDX*0x1 + 0x4]
MOV EAX,dword ptr [RCX]
LEA R9D,[RSI + RAX*0x1]
ADD EAX,EDI
CMP EDI,ESI
CMOVLE EAX,R9D
ADD RDX,0x4
MOV dword ptr [RCX],EAX
CMP R10,RDX
JNZ 0x00101888
SUB EBX,0x1
SUB R11,0x18
CMP EBX,-0x1
JNZ 0x00101870
LAB_001018ba:
MOV RAX,qword ptr [RBP]
POP RBX
POP RBP
POP R12
MOV EAX,dword ptr [RAX]
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >&, int, int) */
int4 func0(vector *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int8 *puVar4;
long lVar5;
long lVar6;
long lVar7;
int iVar8;
long *plVar9;
puVar4 = *(int8 **)param_1;
iVar8 = param_2 + -1;
if (-1 < iVar8) {
plVar9 = puVar4 + (long)param_2 * 3;
do {
lVar5 = *plVar9;
lVar6 = plVar9[-3];
lVar7 = 0;
do {
piVar1 = (int *)(lVar6 + lVar7);
iVar2 = *(int *)(lVar5 + lVar7);
iVar3 = *(int *)(lVar5 + 4 + lVar7);
if (iVar2 <= iVar3) {
iVar2 = iVar3;
}
lVar7 = lVar7 + 4;
*piVar1 = *piVar1 + iVar2;
} while ((long)(iVar8 + 1) * 4 != lVar7);
iVar8 = iVar8 + -1;
plVar9 = plVar9 + -3;
} while (iVar8 != -1);
}
return *(int4 *)*puVar4;
} |
587 | func0 |
#include <vector>
#include <cassert>
using namespace std;
| int func0(vector<vector<int>>& tri, int m, int n) {
for (int i = m - 1; i >= 0; --i) {
for (int j = 0; j <= i; ++j) {
if (tri[i+1][j] > tri[i+1][j+1]) {
tri[i][j] += tri[i+1][j];
} else {
tri[i][j] += tri[i+1][j+1];
}
}
}
return tri[0][0];
}
| int main() {
vector<vector<int>> triangle1{{1, 0, 0}, {4, 8, 0}, {1, 5, 3}};
assert(func0(triangle1, 2, 2) == 14);
vector<vector<int>> triangle2{{13, 0, 0}, {7, 4, 0}, {2, 4, 6}};
assert(func0(triangle2, 2, 2) == 24);
vector<vector<int>> triangle3{{2, 0, 0}, {11, 18, 0}, {21, 25, 33}};
assert(func0(triangle3, 2, 2) == 53);
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >&, int, int):
endbr64
mov (%rdi),%r10
sub $0x1,%esi
js 1995 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x195>
push %r15
movslq %esi,%rax
mov %esi,%r8d
push %r14
lea (%rax,%rax,2),%rax
push %r13
lea (%r10,%rax,8),%r9
push %r12
push %rbp
push %rbx
nopl 0x0(%rax,%rax,1)
mov (%r9),%rdi
mov 0x18(%r9),%rsi
lea 0x10(%rdi),%rax
cmp %rax,%rsi
lea 0x14(%rsi),%rax
setae %dl
cmp %rax,%rdi
setae %al
or %al,%dl
je 1968 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x168>
cmp $0x2,%r8d
jbe 1968 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x168>
lea 0x1(%r8),%r11d
mov %rsi,%rax
mov %rdi,%rdx
mov %r11d,%ecx
shr $0x2,%ecx
shl $0x4,%rcx
add %rsi,%rcx
nopl 0x0(%rax)
movdqu (%rax),%xmm0
movdqu (%rdx),%xmm3
add $0x10,%rax
add $0x10,%rdx
movdqu -0xc(%rax),%xmm5
movdqu -0x10(%rax),%xmm2
movdqu -0xc(%rax),%xmm1
pcmpgtd %xmm5,%xmm0
paddd %xmm3,%xmm2
paddd %xmm3,%xmm1
pand %xmm0,%xmm2
pandn %xmm1,%xmm0
por %xmm2,%xmm0
movups %xmm0,-0x10(%rdx)
cmp %rcx,%rax
jne 1878 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x78>
mov %r11d,%edx
and $0xfffffffc,%edx
and $0x3,%r11d
je 1943 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x143>
mov %edx,%eax
lea 0x1(%rdx),%r14d
lea 0x0(,%rax,4),%r11
mov (%rsi,%rax,4),%ebp
lea 0x4(%r11),%rcx
lea (%rdi,%r11,1),%rbx
lea (%rsi,%rcx,1),%r13
mov (%rbx),%eax
mov 0x0(%r13),%r12d
lea (%rax,%rbp,1),%r15d
add %r12d,%eax
cmp %ebp,%r12d
cmovl %r15d,%eax
mov %eax,(%rbx)
cmp %r8d,%r14d
jg 1943 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x143>
lea 0x8(%r11),%rbx
add %rdi,%rcx
mov 0x0(%r13),%ebp
add $0x2,%edx
lea (%rsi,%rbx,1),%r12
mov (%rcx),%eax
mov (%r12),%r13d
lea (%rax,%rbp,1),%r14d
add %r13d,%eax
cmp %ebp,%r13d
cmovl %r14d,%eax
mov %eax,(%rcx)
cmp %edx,%r8d
jl 1943 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x143>
add %rbx,%rdi
mov 0xc(%rsi,%r11,1),%edx
mov (%r12),%ecx
mov (%rdi),%eax
lea (%rcx,%rax,1),%esi
add %edx,%eax
cmp %edx,%ecx
cmovg %esi,%eax
mov %eax,(%rdi)
sub $0x1,%r8d
sub $0x18,%r9
cmp $0xffffffff,%r8d
jne 1830 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x30>
mov (%r10),%rax
pop %rbx
pop %rbp
pop %r12
mov (%rax),%eax
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rsi,%rax,4),%r11d
mov 0x4(%rsi,%rax,4),%ecx
mov (%rdi,%rax,4),%edx
lea (%rcx,%rdx,1),%ebx
add %r11d,%edx
cmp %ecx,%r11d
cmovle %ebx,%edx
mov %edx,(%rdi,%rax,4)
add $0x1,%rax
cmp %eax,%r8d
jge 1970 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x170>
jmp 1943 <_Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii+0x143>
mov (%r10),%rax
mov (%rax),%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0RSt6vectorIS_IiSaIiEESaIS1_EEii:
endbr64
mov r10, [rdi]
mov edi, esi
sub edi, 1
js loc_1A1D
push r12
movsxd rax, esi
mov r8d, esi
push rbp
lea rax, [rax+rax*2]
push rbx
lea r9, [r10+rax*8]
nop dword ptr [rax+00h]
loc_18B8:
mov rcx, [r9]
mov rsi, [r9-18h]
test edi, edi
jz short loc_18D3
lea rdx, [rcx+4]
mov rax, rsi
sub rax, rdx
cmp rax, 0Ch
ja short loc_1920
loc_18D3:
lea ebp, [rdi+1]
xor eax, eax
movsxd rbp, ebp
shl rbp, 2
nop
loc_18E0:
mov ebx, [rcx+rax]
mov r11d, [rcx+rax+4]
mov edx, [rsi+rax]
lea r12d, [r11+rdx]
add edx, ebx
cmp ebx, r11d
cmovle edx, r12d
mov [rsi+rax], edx
add rax, 4
cmp rbp, rax
jnz short loc_18E0
sub edi, 1
jnb loc_1A23
mov rax, [r10]
pop rbx
pop rbp
pop r12
mov eax, [rax]
retn
loc_1920:
cmp edi, 2
jle loc_1A10
mov edx, r8d
xor eax, eax
shr edx, 2
shl rdx, 4
loc_1935:
movdqu xmm0, xmmword ptr [rcx+rax]
movdqu xmm6, xmmword ptr [rcx+rax+4]
movdqu xmm4, xmmword ptr [rsi+rax]
movdqu xmm2, xmmword ptr [rcx+rax]
movdqu xmm1, xmmword ptr [rcx+rax+4]
pcmpgtd xmm0, xmm6
paddd xmm2, xmm4
paddd xmm1, xmm4
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movups xmmword ptr [rsi+rax], xmm0
add rax, 10h
cmp rax, rdx
jnz short loc_1935
mov edx, r8d
and edx, 0FFFFFFFCh
mov eax, edx
test r8b, 3
jz short loc_19FB
lea r11d, [rdi+1]
sub r11d, edx
cmp edi, edx
jz short loc_19D6
loc_198E:
lea rbp, ds:0[rdx*4]
movq xmm0, qword ptr [rcx+rdx*4]
lea rbx, [rsi+rbp]
movq xmm3, qword ptr [rcx+rbp+4]
movq xmm1, qword ptr [rbx]
movdqa xmm2, xmm0
pcmpgtd xmm0, xmm3
paddd xmm2, xmm1
paddd xmm1, xmm3
pand xmm2, xmm0
pandn xmm0, xmm1
por xmm0, xmm2
movq qword ptr [rbx], xmm0
test r11b, 1
jz short loc_19FB
and r11d, 0FFFFFFFEh
add eax, r11d
loc_19D6:
cdqe
lea rdx, ds:0[rax*4]
mov r11d, [rcx+rax*4]
mov ecx, [rcx+rdx+4]
add rdx, rsi
mov eax, [rdx]
lea esi, [rcx+rax]
add eax, r11d
cmp r11d, ecx
cmovle eax, esi
mov [rdx], eax
loc_19FB:
sub edi, 1
sub r9, 18h
sub r8d, 1
jmp loc_18B8
loc_1A10:
lea r11d, [rdi+1]
xor edx, edx
xor eax, eax
jmp loc_198E
loc_1A1D:
mov rax, [r10]
mov eax, [rax]
retn
loc_1A23:
sub r9, 18h
sub r8d, 1
jmp loc_18B8 | long long func0(unsigned int ***a1, unsigned int a2)
{
unsigned int **v2; // r10
int v3; // edi
unsigned int v4; // r8d
unsigned int **i; // r9
unsigned int *v6; // rcx
long long v7; // rsi
long long v8; // rax
signed int v9; // ebx
signed int v10; // r11d
int v11; // edx
int v12; // r12d
int v13; // edx
long long v16; // rax
__m128i v17; // xmm4
__m128i v18; // xmm0
long long v19; // rdx
signed int v20; // eax
int v21; // r11d
__m128i *v22; // rbx
__m128i v23; // xmm3
__m128i v24; // xmm1
__m128i v25; // xmm2
__m128i v26; // xmm0
long long v27; // rdx
signed int v28; // r11d
signed int v29; // ecx
_DWORD *v30; // rdx
int v31; // eax
v2 = *a1;
v3 = a2 - 1;
if ( (int)(a2 - 1) >= 0 )
{
v4 = a2;
for ( i = &v2[3 * (int)a2]; ; i -= 3 )
{
while ( 1 )
{
v6 = *i;
v7 = (long long)*(i - 3);
if ( v3 )
{
if ( (unsigned long long)(v7 - (_QWORD)(v6 + 1)) > 0xC )
break;
}
v8 = 0LL;
do
{
v9 = v6[v8];
v10 = v6[v8 + 1];
v11 = *(_DWORD *)(v7 + v8 * 4);
v12 = v10 + v11;
v13 = v9 + v11;
if ( v9 <= v10 )
v13 = v12;
*(_DWORD *)(v7 + v8 * 4) = v13;
++v8;
}
while ( v3 + 1 != v8 );
if ( v3-- == 0 )
return **v2;
i -= 3;
--v4;
}
if ( v3 <= 2 )
break;
v16 = 0LL;
do
{
v17 = _mm_loadu_si128((const __m128i *)(v7 + v16 * 4));
v18 = _mm_cmpgt_epi32(
_mm_loadu_si128((const __m128i *)&v6[v16]),
_mm_loadu_si128((const __m128i *)&v6[v16 + 1]));
*(__m128i *)(v7 + v16 * 4) = _mm_or_si128(
_mm_andnot_si128(
v18,
_mm_add_epi32(_mm_loadu_si128((const __m128i *)&v6[v16 + 1]), v17)),
_mm_and_si128(
_mm_add_epi32(_mm_loadu_si128((const __m128i *)&v6[v16]), v17),
v18));
v16 += 4LL;
}
while ( v16 != 4LL * (v4 >> 2) );
v19 = v4 & 0xFFFFFFFC;
v20 = v4 & 0xFFFFFFFC;
if ( (v4 & 3) == 0 )
goto LABEL_21;
v21 = v3 + 1 - v19;
if ( v3 != (_DWORD)v19 )
goto LABEL_16;
LABEL_18:
v27 = v20;
v28 = v6[v27];
v29 = v6[v27 + 1];
v30 = (_DWORD *)(v7 + v27 * 4);
v31 = v28 + *v30;
if ( v28 <= v29 )
v31 = v29 + *v30;
*v30 = v31;
LABEL_21:
--v3;
--v4;
}
v21 = v3 + 1;
v19 = 0LL;
v20 = 0;
LABEL_16:
v22 = (__m128i *)(v7 + 4 * v19);
v23 = _mm_loadl_epi64((const __m128i *)&v6[v19 + 1]);
v24 = _mm_loadl_epi64(v22);
v25 = _mm_loadl_epi64((const __m128i *)&v6[v19]);
v26 = _mm_cmpgt_epi32(v25, v23);
v22->m128i_i64[0] = _mm_or_si128(
_mm_andnot_si128(v26, _mm_add_epi32(v24, v23)),
_mm_and_si128(_mm_add_epi32(v25, v24), v26)).m128i_u64[0];
if ( (v21 & 1) == 0 )
goto LABEL_21;
v20 += v21 & 0xFFFFFFFE;
goto LABEL_18;
}
return **v2;
} | func0:
ENDBR64
MOV R10,qword ptr [RDI]
MOV EDI,ESI
SUB EDI,0x1
JS 0x00101a1d
PUSH R12
MOVSXD RAX,ESI
MOV R8D,ESI
PUSH RBP
LEA RAX,[RAX + RAX*0x2]
PUSH RBX
LEA R9,[R10 + RAX*0x8]
NOP dword ptr [RAX]
LAB_001018b8:
MOV RCX,qword ptr [R9]
MOV RSI,qword ptr [R9 + -0x18]
TEST EDI,EDI
JZ 0x001018d3
LEA RDX,[RCX + 0x4]
MOV RAX,RSI
SUB RAX,RDX
CMP RAX,0xc
JA 0x00101920
LAB_001018d3:
LEA EBP,[RDI + 0x1]
XOR EAX,EAX
MOVSXD RBP,EBP
SHL RBP,0x2
NOP
LAB_001018e0:
MOV EBX,dword ptr [RCX + RAX*0x1]
MOV R11D,dword ptr [RCX + RAX*0x1 + 0x4]
MOV EDX,dword ptr [RSI + RAX*0x1]
LEA R12D,[R11 + RDX*0x1]
ADD EDX,EBX
CMP EBX,R11D
CMOVLE EDX,R12D
MOV dword ptr [RSI + RAX*0x1],EDX
ADD RAX,0x4
CMP RBP,RAX
JNZ 0x001018e0
SUB EDI,0x1
JNC 0x00101a23
MOV RAX,qword ptr [R10]
POP RBX
POP RBP
POP R12
MOV EAX,dword ptr [RAX]
RET
LAB_00101920:
CMP EDI,0x2
JLE 0x00101a10
MOV EDX,R8D
XOR EAX,EAX
SHR EDX,0x2
SHL RDX,0x4
LAB_00101935:
MOVDQU XMM0,xmmword ptr [RCX + RAX*0x1]
MOVDQU XMM6,xmmword ptr [RCX + RAX*0x1 + 0x4]
MOVDQU XMM4,xmmword ptr [RSI + RAX*0x1]
MOVDQU XMM2,xmmword ptr [RCX + RAX*0x1]
MOVDQU XMM1,xmmword ptr [RCX + RAX*0x1 + 0x4]
PCMPGTD XMM0,XMM6
PADDD XMM2,XMM4
PADDD XMM1,XMM4
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVUPS xmmword ptr [RSI + RAX*0x1],XMM0
ADD RAX,0x10
CMP RAX,RDX
JNZ 0x00101935
MOV EDX,R8D
AND EDX,0xfffffffc
MOV EAX,EDX
TEST R8B,0x3
JZ 0x001019fb
LEA R11D,[RDI + 0x1]
SUB R11D,EDX
CMP EDI,EDX
JZ 0x001019d6
LAB_0010198e:
LEA RBP,[RDX*0x4]
MOVQ XMM0,qword ptr [RCX + RDX*0x4]
LEA RBX,[RSI + RBP*0x1]
MOVQ XMM3,qword ptr [RCX + RBP*0x1 + 0x4]
MOVQ XMM1,qword ptr [RBX]
MOVDQA XMM2,XMM0
PCMPGTD XMM0,XMM3
PADDD XMM2,XMM1
PADDD XMM1,XMM3
PAND XMM2,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM2
MOVQ qword ptr [RBX],XMM0
TEST R11B,0x1
JZ 0x001019fb
AND R11D,0xfffffffe
ADD EAX,R11D
LAB_001019d6:
CDQE
LEA RDX,[RAX*0x4]
MOV R11D,dword ptr [RCX + RAX*0x4]
MOV ECX,dword ptr [RCX + RDX*0x1 + 0x4]
ADD RDX,RSI
MOV EAX,dword ptr [RDX]
LEA ESI,[RCX + RAX*0x1]
ADD EAX,R11D
CMP R11D,ECX
CMOVLE EAX,ESI
MOV dword ptr [RDX],EAX
LAB_001019fb:
SUB EDI,0x1
SUB R9,0x18
SUB R8D,0x1
JMP 0x001018b8
LAB_00101a10:
LEA R11D,[RDI + 0x1]
XOR EDX,EDX
XOR EAX,EAX
JMP 0x0010198e
LAB_00101a1d:
MOV RAX,qword ptr [R10]
MOV EAX,dword ptr [RAX]
RET
LAB_00101a23:
SUB R9,0x18
SUB R8D,0x1
JMP 0x001018b8 | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >&, int, int) */
int [16] func0(vector *param_1,int param_2,int param_3)
{
int *piVar1;
int *piVar2;
uint *puVar3;
ulong *puVar4;
int *piVar5;
int *piVar6;
int8 uVar7;
int8 uVar8;
int iVar9;
int8 *puVar10;
long lVar11;
long lVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int iVar19;
int iVar20;
int iVar21;
long lVar22;
int4 in_register_00000014;
uint uVar23;
int *piVar25;
uint uVar26;
long *plVar27;
uint uVar28;
bool bVar29;
int iVar30;
int iVar32;
int iVar33;
int iVar34;
int iVar35;
int auVar36 [16];
int auVar37 [16];
ulong uVar24;
ulong uVar31;
auVar37._12_4_ = in_register_00000014;
auVar37._8_4_ = param_3;
puVar10 = *(int8 **)param_1;
uVar26 = param_2 - 1;
if ((int)uVar26 < 0) {
auVar37._4_4_ = 0;
auVar37._0_4_ = *(uint *)*puVar10;
return auVar37;
}
plVar27 = puVar10 + (long)param_2 * 3;
do {
while( true ) {
lVar11 = *plVar27;
lVar12 = plVar27[-3];
if ((uVar26 != 0) && (0xc < (ulong)(lVar12 - (lVar11 + 4)))) break;
lVar22 = 0;
do {
iVar9 = *(int *)(lVar11 + 4 + lVar22);
iVar30 = *(int *)(lVar11 + lVar22);
if (*(int *)(lVar11 + lVar22) <= iVar9) {
iVar30 = iVar9;
}
iVar30 = *(int *)(lVar12 + lVar22) + iVar30;
*(int *)(lVar12 + lVar22) = iVar30;
lVar22 = lVar22 + 4;
} while ((long)(int)(uVar26 + 1) * 4 != lVar22);
bVar29 = uVar26 == 0;
uVar26 = uVar26 - 1;
if (bVar29) {
auVar36._4_4_ = 0;
auVar36._0_4_ = *(uint *)*puVar10;
auVar36._8_4_ = iVar30;
auVar36._12_4_ = 0;
return auVar36;
}
plVar27 = plVar27 + -3;
param_2 = param_2 - 1;
}
if ((int)uVar26 < 3) {
uVar28 = uVar26 + 1;
uVar24 = 0;
uVar23 = 0;
LAB_0010198e:
uVar7 = *(int8 *)(lVar11 + uVar24 * 4);
puVar4 = (ulong *)(lVar12 + uVar24 * 4);
uVar8 = *(int8 *)(lVar11 + 4 + uVar24 * 4);
uVar24 = *puVar4;
iVar30 = (int)uVar7;
iVar34 = (int)uVar8;
iVar9 = (int)((ulong)uVar7 >> 0x20);
iVar35 = (int)((ulong)uVar8 >> 0x20);
uVar31 = CONCAT44(-(uint)(iVar35 < iVar9),-(uint)(iVar34 < iVar30));
iVar32 = (int)uVar24;
iVar33 = (int)(uVar24 >> 0x20);
*puVar4 = ~uVar31 & CONCAT44(iVar33 + iVar35,iVar32 + iVar34) |
CONCAT44(iVar9 + iVar33,iVar30 + iVar32) & uVar31;
if ((uVar28 & 1) != 0) {
uVar23 = uVar23 + (uVar28 & 0xfffffffe);
LAB_001019d6:
lVar22 = (long)(int)uVar23 * 4;
iVar30 = *(int *)(lVar11 + (long)(int)uVar23 * 4);
iVar9 = *(int *)(lVar11 + 4 + lVar22);
piVar25 = (int *)(lVar22 + lVar12);
if (iVar30 <= iVar9) {
iVar30 = iVar9;
}
*piVar25 = *piVar25 + iVar30;
}
}
else {
lVar22 = 0;
do {
piVar25 = (int *)(lVar11 + lVar22);
iVar9 = piVar25[1];
iVar30 = piVar25[2];
iVar32 = piVar25[3];
piVar5 = (int *)(lVar11 + 4 + lVar22);
iVar33 = piVar5[1];
iVar34 = piVar5[2];
iVar35 = piVar5[3];
piVar1 = (int *)(lVar12 + lVar22);
iVar13 = piVar1[1];
iVar14 = piVar1[2];
iVar15 = piVar1[3];
piVar2 = (int *)(lVar11 + lVar22);
iVar16 = piVar2[1];
iVar17 = piVar2[2];
iVar18 = piVar2[3];
piVar6 = (int *)(lVar11 + 4 + lVar22);
iVar19 = piVar6[1];
iVar20 = piVar6[2];
iVar21 = piVar6[3];
puVar3 = (uint *)(lVar12 + lVar22);
*puVar3 = ~-(uint)(*piVar5 < *piVar25) & *piVar6 + *piVar1 |
*piVar2 + *piVar1 & -(uint)(*piVar5 < *piVar25);
puVar3[1] = ~-(uint)(iVar33 < iVar9) & iVar19 + iVar13 |
iVar16 + iVar13 & -(uint)(iVar33 < iVar9);
puVar3[2] = ~-(uint)(iVar34 < iVar30) & iVar20 + iVar14 |
iVar17 + iVar14 & -(uint)(iVar34 < iVar30);
puVar3[3] = ~-(uint)(iVar35 < iVar32) & iVar21 + iVar15 |
iVar18 + iVar15 & -(uint)(iVar35 < iVar32);
lVar22 = lVar22 + 0x10;
} while (lVar22 != (ulong)((uint)param_2 >> 2) << 4);
uVar23 = param_2 & 0xfffffffc;
uVar24 = (ulong)uVar23;
if ((param_2 & 3U) != 0) {
uVar28 = (uVar26 + 1) - uVar23;
if (uVar26 != uVar23) goto LAB_0010198e;
goto LAB_001019d6;
}
}
uVar26 = uVar26 - 1;
plVar27 = plVar27 + -3;
param_2 = param_2 - 1;
} while( true );
} |
588 | func0 |
#include <iostream>
#include <assert.h>
int sum_digits_single(int x) {
int ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
int closest(int x) {
int ans = 0;
while (ans * 10 + 9 <= x) {
ans = ans * 10 + 9;
}
return ans;
}
| int func0(int N) {
int A = closest(N);
return sum_digits_single(A) + sum_digits_single(N - A);
}
| int main() {
assert(func0(35) == 17);
assert(func0(7) == 7);
assert(func0(100) == 19);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %edi,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,%edi
callq 11f3 <_Z7closesti>
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
mov %eax,%edi
callq 1189 <_Z17sum_digits_singlei>
mov %eax,%ebx
mov -0x1c(%rbp),%eax
sub -0xc(%rbp),%eax
mov %eax,%edi
callq 1189 <_Z17sum_digits_singlei>
add %ebx,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_1C], edi
mov eax, [rbp+var_1C]
mov edi, eax; int
call _Z7closesti; closest(int)
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
mov edi, eax; int
call _Z17sum_digits_singlei; sum_digits_single(int)
mov ebx, eax
mov eax, [rbp+var_1C]
sub eax, [rbp+var_C]
mov edi, eax; int
call _Z17sum_digits_singlei; sum_digits_single(int)
add eax, ebx
mov rbx, [rbp+var_8]
leave
retn | long long func0(int a1)
{
int v1; // ebx
int v3; // [rsp+14h] [rbp-Ch]
v3 = closest(a1);
v1 = sum_digits_single(v3);
return v1 + (unsigned int)sum_digits_single(a1 - v3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x1c],EDI
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDI,EAX
CALL 0x001011b3
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
MOV EDI,EAX
CALL 0x00101149
MOV EBX,EAX
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,dword ptr [RBP + -0xc]
MOV EDI,EAX
CALL 0x00101149
ADD EAX,EBX
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = closest(param_1);
iVar2 = sum_digits_single(iVar1);
iVar1 = sum_digits_single(param_1 - iVar1);
return iVar1 + iVar2;
} |
589 | func0 |
#include <iostream>
#include <assert.h>
int sum_digits_single(int x) {
int ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
int closest(int x) {
int ans = 0;
while (ans * 10 + 9 <= x) {
ans = ans * 10 + 9;
}
return ans;
}
| int func0(int N) {
int A = closest(N);
return sum_digits_single(A) + sum_digits_single(N - A);
}
| int main() {
assert(func0(35) == 17);
assert(func0(7) == 7);
assert(func0(100) == 19);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %r12
push %rbp
push %rbx
mov %edi,%ebx
callq 11c1 <_Z7closesti>
mov %eax,%r12d
mov %eax,%edi
callq 1189 <_Z17sum_digits_singlei>
mov %eax,%ebp
sub %r12d,%ebx
mov %ebx,%edi
callq 1189 <_Z17sum_digits_singlei>
add %ebp,%eax
pop %rbx
pop %rbp
pop %r12
retq
| _Z5func0i:
endbr64
push r12
push rbp
push rbx
mov ebx, edi
call _Z7closesti; closest(int)
mov r12d, eax
mov edi, eax; int
call _Z17sum_digits_singlei; sum_digits_single(int)
mov ebp, eax
sub ebx, r12d
mov edi, ebx; int
call _Z17sum_digits_singlei; sum_digits_single(int)
add eax, ebp
pop rbx
pop rbp
pop r12
retn | long long func0(int a1)
{
int v1; // r12d
int v2; // ebp
v1 = closest(a1);
v2 = sum_digits_single(v1);
return v2 + (unsigned int)sum_digits_single(a1 - v1);
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDI
CALL 0x00101181
MOV R12D,EAX
MOV EDI,EAX
CALL 0x00101149
MOV EBP,EAX
SUB EBX,R12D
MOV EDI,EBX
CALL 0x00101149
ADD EAX,EBP
POP RBX
POP RBP
POP R12
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
iVar1 = closest(param_1);
iVar2 = sum_digits_single(iVar1);
iVar1 = sum_digits_single(param_1 - iVar1);
return iVar1 + iVar2;
} |
590 | func0 |
#include <iostream>
#include <assert.h>
int sum_digits_single(int x) {
int ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
int closest(int x) {
int ans = 0;
while (ans * 10 + 9 <= x) {
ans = ans * 10 + 9;
}
return ans;
}
| int func0(int N) {
int A = closest(N);
return sum_digits_single(A) + sum_digits_single(N - A);
}
| int main() {
assert(func0(35) == 17);
assert(func0(7) == 7);
assert(func0(100) == 19);
return 0;
}
| O2 | cpp | func0(int):
endbr64
cmp $0x8,%edi
jle 1328 <_Z5func0i+0x88>
xor %eax,%eax
nopl 0x0(%rax,%rax,1)
lea 0x9(%rax),%esi
lea (%rsi,%rsi,4),%eax
add %eax,%eax
lea 0x8(%rax),%edx
cmp %edx,%edi
jg 12b0 <_Z5func0i+0x10>
mov %esi,%edx
xor %r8d,%r8d
mov $0xcccccccd,%r9d
nopw 0x0(%rax,%rax,1)
mov %edx,%eax
imul %r9,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%edx
add %edx,%r8d
mov %eax,%edx
test %eax,%eax
jne 12d0 <_Z5func0i+0x30>
sub %esi,%edi
test %edi,%edi
je 131f <_Z5func0i+0x7f>
xor %ecx,%ecx
nopw 0x0(%rax,%rax,1)
movslq %edi,%rax
mov %edi,%edx
imul $0x66666667,%rax,%rax
sar $0x1f,%edx
sar $0x22,%rax
sub %edx,%eax
lea (%rax,%rax,4),%edx
add %edx,%edx
sub %edx,%edi
add %edi,%ecx
mov %eax,%edi
test %eax,%eax
jne 12f8 <_Z5func0i+0x58>
add %ecx,%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
jmp 12ec <_Z5func0i+0x4c>
nopl (%rax)
| _Z5func0i:
endbr64
mov edx, edi
cmp edi, 8
jle loc_12F0
xor eax, eax
nop dword ptr [rax+00000000h]
loc_1278:
lea r8d, [rax+9]
lea eax, [r8+r8*4]
add eax, eax
lea ecx, [rax+8]
cmp edx, ecx
jg short loc_1278
mov ecx, r8d
xor edi, edi
xchg ax, ax
loc_1290:
movsxd rax, ecx
mov esi, ecx
imul rax, 66666667h
sar esi, 1Fh
sar rax, 22h
sub eax, esi
lea esi, [rax+rax*4]
add esi, esi
sub ecx, esi
add edi, ecx
mov ecx, eax
test eax, eax
jnz short loc_1290
sub edx, r8d
loc_12B7:
test edx, edx
jz short loc_12E6
xor esi, esi
nop dword ptr [rax]
loc_12C0:
movsxd rax, edx
mov ecx, edx
imul rax, 66666667h
sar ecx, 1Fh
sar rax, 22h
sub eax, ecx
lea ecx, [rax+rax*4]
add ecx, ecx
sub edx, ecx
add esi, edx
mov edx, eax
test eax, eax
jnz short loc_12C0
add edi, esi
loc_12E6:
mov eax, edi
retn
loc_12F0:
xor edi, edi
jmp short loc_12B7 | long long func0(int a1)
{
int v1; // edx
int v2; // eax
int v3; // r8d
int v4; // ecx
unsigned int v5; // edi
int v6; // esi
v1 = a1;
if ( a1 <= 8 )
{
v5 = 0;
}
else
{
v2 = 0;
do
{
v3 = v2 + 9;
v2 = 10 * (v2 + 9);
}
while ( a1 > v2 + 8 );
v4 = v3;
v5 = 0;
do
{
v5 += v4 % 10;
v4 /= 10;
}
while ( v4 );
v1 -= v3;
}
if ( v1 )
{
v6 = 0;
do
{
v6 += v1 % 10;
v1 /= 10;
}
while ( v1 );
v5 += v6;
}
return v5;
} | func0:
ENDBR64
MOV EDX,EDI
CMP EDI,0x8
JLE 0x001012f0
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101278:
LEA R8D,[RAX + 0x9]
LEA EAX,[R8 + R8*0x4]
ADD EAX,EAX
LEA ECX,[RAX + 0x8]
CMP EDX,ECX
JG 0x00101278
MOV ECX,R8D
XOR EDI,EDI
NOP
LAB_00101290:
MOVSXD RAX,ECX
MOV ESI,ECX
IMUL RAX,RAX,0x66666667
SAR ESI,0x1f
SAR RAX,0x22
SUB EAX,ESI
LEA ESI,[RAX + RAX*0x4]
ADD ESI,ESI
SUB ECX,ESI
ADD EDI,ECX
MOV ECX,EAX
TEST EAX,EAX
JNZ 0x00101290
SUB EDX,R8D
LAB_001012b7:
TEST EDX,EDX
JZ 0x001012e6
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_001012c0:
MOVSXD RAX,EDX
MOV ECX,EDX
IMUL RAX,RAX,0x66666667
SAR ECX,0x1f
SAR RAX,0x22
SUB EAX,ECX
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EDX,ECX
ADD ESI,EDX
MOV EDX,EAX
TEST EAX,EAX
JNZ 0x001012c0
ADD EDI,ESI
LAB_001012e6:
MOV EAX,EDI
RET
LAB_001012f0:
XOR EDI,EDI
JMP 0x001012b7 | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_1 < 9) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
iVar4 = iVar3 + 9;
iVar3 = iVar4 * 10;
} while (iVar3 + 8 < param_1);
iVar3 = 0;
iVar2 = iVar4;
do {
iVar1 = iVar2 / 10;
iVar3 = iVar3 + iVar2 % 10;
iVar2 = iVar1;
} while (iVar1 != 0);
param_1 = param_1 - iVar4;
}
if (param_1 != 0) {
iVar4 = 0;
do {
iVar2 = param_1 / 10;
iVar4 = iVar4 + param_1 % 10;
param_1 = iVar2;
} while (iVar2 != 0);
iVar3 = iVar3 + iVar4;
}
return iVar3;
} |
591 | func0 |
#include <iostream>
#include <assert.h>
int sum_digits_single(int x) {
int ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
int closest(int x) {
int ans = 0;
while (ans * 10 + 9 <= x) {
ans = ans * 10 + 9;
}
return ans;
}
| int func0(int N) {
int A = closest(N);
return sum_digits_single(A) + sum_digits_single(N - A);
}
| int main() {
assert(func0(35) == 17);
assert(func0(7) == 7);
assert(func0(100) == 19);
return 0;
}
| O3 | cpp | func0(int):
endbr64
cmp $0x8,%edi
jle 1328 <_Z5func0i+0x88>
xor %eax,%eax
nopl 0x0(%rax,%rax,1)
lea 0x9(%rax),%esi
lea (%rsi,%rsi,4),%eax
add %eax,%eax
lea 0x8(%rax),%edx
cmp %edx,%edi
jg 12b0 <_Z5func0i+0x10>
mov %esi,%edx
xor %r8d,%r8d
mov $0xcccccccd,%r9d
nopw 0x0(%rax,%rax,1)
mov %edx,%eax
imul %r9,%rax
shr $0x23,%rax
lea (%rax,%rax,4),%ecx
add %ecx,%ecx
sub %ecx,%edx
add %edx,%r8d
mov %eax,%edx
test %eax,%eax
jne 12d0 <_Z5func0i+0x30>
sub %esi,%edi
test %edi,%edi
je 131f <_Z5func0i+0x7f>
xor %ecx,%ecx
nopw 0x0(%rax,%rax,1)
movslq %edi,%rax
mov %edi,%edx
imul $0x66666667,%rax,%rax
sar $0x1f,%edx
sar $0x22,%rax
sub %edx,%eax
lea (%rax,%rax,4),%edx
add %edx,%edx
sub %edx,%edi
add %edi,%ecx
mov %eax,%edi
test %eax,%eax
jne 12f8 <_Z5func0i+0x58>
add %ecx,%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
jmp 12ec <_Z5func0i+0x4c>
nopl (%rax)
| _Z5func0i:
endbr64
mov edx, edi
cmp edi, 8
jle loc_12B0
xor eax, eax
nop dword ptr [rax+00000000h]
loc_1238:
lea r8d, [rax+9]
lea eax, [r8+r8*4]
add eax, eax
lea ecx, [rax+8]
cmp edx, ecx
jg short loc_1238
mov ecx, r8d
xor edi, edi
xchg ax, ax
loc_1250:
movsxd rax, ecx
mov esi, ecx
imul rax, 66666667h
sar esi, 1Fh
sar rax, 22h
sub eax, esi
lea esi, [rax+rax*4]
add esi, esi
sub ecx, esi
add edi, ecx
mov ecx, eax
test eax, eax
jnz short loc_1250
sub edx, r8d
loc_1277:
test edx, edx
jz short loc_12A6
xor esi, esi
nop dword ptr [rax]
loc_1280:
movsxd rax, edx
mov ecx, edx
imul rax, 66666667h
sar ecx, 1Fh
sar rax, 22h
sub eax, ecx
lea ecx, [rax+rax*4]
add ecx, ecx
sub edx, ecx
add esi, edx
mov edx, eax
test eax, eax
jnz short loc_1280
add edi, esi
loc_12A6:
mov eax, edi
retn
loc_12B0:
xor edi, edi
jmp short loc_1277 | long long func0(int a1)
{
int v1; // edx
int v2; // eax
int v3; // r8d
int v4; // ecx
unsigned int v5; // edi
int v6; // esi
v1 = a1;
if ( a1 <= 8 )
{
v5 = 0;
}
else
{
v2 = 0;
do
{
v3 = v2 + 9;
v2 = 10 * (v2 + 9);
}
while ( a1 > v2 + 8 );
v4 = v3;
v5 = 0;
do
{
v5 += v4 % 10;
v4 /= 10;
}
while ( v4 );
v1 -= v3;
}
if ( v1 )
{
v6 = 0;
do
{
v6 += v1 % 10;
v1 /= 10;
}
while ( v1 );
v5 += v6;
}
return v5;
} | func0:
ENDBR64
MOV EDX,EDI
CMP EDI,0x8
JLE 0x001012b0
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101238:
LEA R8D,[RAX + 0x9]
LEA EAX,[R8 + R8*0x4]
ADD EAX,EAX
LEA ECX,[RAX + 0x8]
CMP EDX,ECX
JG 0x00101238
MOV ECX,R8D
XOR EDI,EDI
NOP
LAB_00101250:
MOVSXD RAX,ECX
MOV ESI,ECX
IMUL RAX,RAX,0x66666667
SAR ESI,0x1f
SAR RAX,0x22
SUB EAX,ESI
LEA ESI,[RAX + RAX*0x4]
ADD ESI,ESI
SUB ECX,ESI
ADD EDI,ECX
MOV ECX,EAX
TEST EAX,EAX
JNZ 0x00101250
SUB EDX,R8D
LAB_00101277:
TEST EDX,EDX
JZ 0x001012a6
XOR ESI,ESI
NOP dword ptr [RAX]
LAB_00101280:
MOVSXD RAX,EDX
MOV ECX,EDX
IMUL RAX,RAX,0x66666667
SAR ECX,0x1f
SAR RAX,0x22
SUB EAX,ECX
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
SUB EDX,ECX
ADD ESI,EDX
MOV EDX,EAX
TEST EAX,EAX
JNZ 0x00101280
ADD EDI,ESI
LAB_001012a6:
MOV EAX,EDI
RET
LAB_001012b0:
XOR EDI,EDI
JMP 0x00101277 | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_1 < 9) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
iVar4 = iVar3 + 9;
iVar3 = iVar4 * 10;
} while (iVar3 + 8 < param_1);
iVar3 = 0;
iVar2 = iVar4;
do {
iVar1 = iVar2 / 10;
iVar3 = iVar3 + iVar2 % 10;
iVar2 = iVar1;
} while (iVar1 != 0);
param_1 = param_1 - iVar4;
}
if (param_1 != 0) {
iVar4 = 0;
do {
iVar2 = param_1 / 10;
iVar4 = iVar4 + param_1 % 10;
param_1 = iVar2;
} while (iVar2 != 0);
iVar3 = iVar3 + iVar4;
}
return iVar3;
} |
592 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<int> arr, int n) {
std::vector<int> dp(n, 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] == arr[j] + 1 || arr[i] == arr[j] - 1) {
dp[i] = std::max(dp[i], dp[j] + 1);
}
}
}
int result = 1;
for (int i = 0; i < n; i++) {
if (result < dp[i]) {
result = dp[i];
}
}
return result;
}
| int main() {
assert(func0({1, 2, 3, 4, 5, 3, 2}, 7) == 6);
assert(func0({10, 9, 4, 5, 4, 8, 6}, 7) == 3);
assert(func0({1, 2, 3, 2, 3, 7, 2, 1}, 8) == 7);
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,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x45(%rbp),%rax
mov %rax,%rdi
callq 1796 <_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 17d6 <_ZNSt6vectorIiSaIiEEC1EmRKiRKS0_>
lea -0x45(%rbp),%rax
mov %rax,%rdi
callq 17b6 <_ZNSaIiED1Ev>
movl $0x0,-0x40(%rbp)
mov -0x40(%rbp),%eax
cmp -0x5c(%rbp),%eax
jge 1394 <_Z5func0St6vectorIiSaIiEEi+0x16b>
movl $0x0,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cmp -0x40(%rbp),%eax
jge 138b <_Z5func0St6vectorIiSaIiEEi+0x162>
mov -0x40(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 18a6 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 18a6 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
add $0x1,%eax
cmp %eax,%ebx
je 1315 <_Z5func0St6vectorIiSaIiEEi+0xec>
mov -0x40(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 18a6 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 18a6 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
sub $0x1,%eax
cmp %eax,%ebx
jne 131c <_Z5func0St6vectorIiSaIiEEi+0xf3>
mov $0x1,%eax
jmp 1321 <_Z5func0St6vectorIiSaIiEEi+0xf8>
mov $0x0,%eax
test %al,%al
je 1382 <_Z5func0St6vectorIiSaIiEEi+0x159>
mov -0x3c(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 18a6 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
add $0x1,%eax
mov %eax,-0x44(%rbp)
mov -0x40(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 18a6 <_ZNSt6vectorIiSaIiEEixEm>
mov %rax,%rdx
lea -0x44(%rbp),%rax
mov %rax,%rsi
mov %rdx,%rdi
callq 18ca <_ZSt3maxIiERKT_S2_S2_>
mov (%rax),%ebx
mov -0x40(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 18a6 <_ZNSt6vectorIiSaIiEEixEm>
mov %ebx,(%rax)
addl $0x1,-0x3c(%rbp)
jmpq 129f <_Z5func0St6vectorIiSaIiEEi+0x76>
addl $0x1,-0x40(%rbp)
jmpq 128c <_Z5func0St6vectorIiSaIiEEi+0x63>
movl $0x1,-0x38(%rbp)
movl $0x0,-0x34(%rbp)
mov -0x34(%rbp),%eax
cmp -0x5c(%rbp),%eax
jge 13eb <_Z5func0St6vectorIiSaIiEEi+0x1c2>
mov -0x34(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 18a6 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
cmp %eax,-0x38(%rbp)
setl %al
test %al,%al
je 13e5 <_Z5func0St6vectorIiSaIiEEi+0x1bc>
mov -0x34(%rbp),%eax
movslq %eax,%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 18a6 <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
mov %eax,-0x38(%rbp)
addl $0x1,-0x34(%rbp)
jmp 13a2 <_Z5func0St6vectorIiSaIiEEi+0x179>
mov -0x38(%rbp),%ebx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 185e <_ZNSt6vectorIiSaIiEED1Ev>
mov %ebx,%eax
mov -0x18(%rbp),%rcx
xor %fs:0x28,%rcx
je 1430 <_Z5func0St6vectorIiSaIiEEi+0x207>
jmp 142b <_Z5func0St6vectorIiSaIiEEi+0x202>
endbr64
mov %rax,%rbx
lea -0x45(%rbp),%rax
mov %rax,%rdi
callq 17b6 <_ZNSaIiED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1130 <_Unwind_Resume@plt>
callq 1110 <__stack_chk_fail@plt>
add $0x58,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0St6vectorIiSaIiEEi:
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_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_48], 0
jmp loc_13A7
loc_12B0:
mov [rbp+var_44], 0
jmp loc_1397
loc_12BC:
mov eax, [rbp+var_48]
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_44]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
add eax, 1
cmp ebx, eax
jz short loc_1326
mov eax, [rbp+var_48]
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_44]
movsxd rdx, eax
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
sub eax, 1
cmp ebx, eax
jnz short loc_132D
loc_1326:
mov eax, 1
jmp short loc_1332
loc_132D:
mov eax, 0
loc_1332:
test al, al
jz short loc_1393
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]
add eax, 1
mov [rbp+var_4C], eax
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 rdx, rax
lea rax, [rbp+var_4C]
mov rsi, rax
mov rdi, rdx
call _ZSt3maxIiERKT_S2_S2_; std::max<int>(int const&,int const&)
mov ebx, [rax]
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
loc_1393:
add [rbp+var_44], 1
loc_1397:
mov eax, [rbp+var_44]
cmp eax, [rbp+var_48]
jl loc_12BC
add [rbp+var_48], 1
loc_13A7:
mov eax, [rbp+var_48]
cmp eax, [rbp+var_5C]
jl loc_12B0
mov [rbp+var_40], 1
mov [rbp+var_3C], 0
jmp short loc_1402
loc_13C3:
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_40], eax
setl al
test al, al
jz short loc_13FE
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_40], eax
loc_13FE:
add [rbp+var_3C], 1
loc_1402:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_5C]
jl short loc_13C3
mov ebx, [rbp+var_40]
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_1464
jmp short loc_145F
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_1457
call ___stack_chk_fail
loc_1457:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_145F:
call ___stack_chk_fail
loc_1464:
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
int *v7; // rax
unsigned int v8; // ebx
char v10; // [rsp+13h] [rbp-4Dh] BYREF
int v11; // [rsp+14h] [rbp-4Ch] BYREF
int i; // [rsp+18h] [rbp-48h]
int j; // [rsp+1Ch] [rbp-44h]
int v14; // [rsp+20h] [rbp-40h]
int k; // [rsp+24h] [rbp-3Ch]
char *v16; // [rsp+28h] [rbp-38h]
_BYTE v17[24]; // [rsp+30h] [rbp-30h] BYREF
unsigned long long v18; // [rsp+48h] [rbp-18h]
v18 = __readfsqword(0x28u);
v16 = &v10;
v11 = 1;
std::vector<int>::vector(v17, a2, &v11, &v10);
std::__new_allocator<int>::~__new_allocator(&v10);
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < i; ++j )
{
v2 = *(_DWORD *)std::vector<int>::operator[](a1, i);
if ( v2 != *(_DWORD *)std::vector<int>::operator[](a1, j) + 1 )
{
v3 = *(_DWORD *)std::vector<int>::operator[](a1, i);
if ( v3 != *(_DWORD *)std::vector<int>::operator[](a1, j) - 1 )
continue;
}
v11 = *(_DWORD *)std::vector<int>::operator[](v17, j) + 1;
v5 = std::vector<int>::operator[](v17, i);
v6 = *(_DWORD *)std::max<int>(v5, &v11);
*(_DWORD *)std::vector<int>::operator[](v17, i) = v6;
}
}
v14 = 1;
for ( k = 0; k < a2; ++k )
{
v7 = (int *)std::vector<int>::operator[](v17, k);
if ( v14 < *v7 )
v14 = *(_DWORD *)std::vector<int>::operator[](v17, k);
}
v8 = v14;
std::vector<int>::~vector(v17);
return v8;
} | 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 + -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_00101292:
CALL 0x0010181a
LEA RAX,[RBP + -0x4d]
MOV RDI,RAX
CALL 0x00101a10
NOP
MOV dword ptr [RBP + -0x48],0x0
JMP 0x001013a7
LAB_001012b0:
MOV dword ptr [RBP + -0x44],0x0
JMP 0x00101397
LAB_001012bc:
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018fa
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 0x001018fa
MOV EAX,dword ptr [RAX]
ADD EAX,0x1
CMP EBX,EAX
JZ 0x00101326
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018fa
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 0x001018fa
MOV EAX,dword ptr [RAX]
SUB EAX,0x1
CMP EBX,EAX
JNZ 0x0010132d
LAB_00101326:
MOV EAX,0x1
JMP 0x00101332
LAB_0010132d:
MOV EAX,0x0
LAB_00101332:
TEST AL,AL
JZ 0x00101393
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018fa
MOV EAX,dword ptr [RAX]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4c],EAX
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018fa
MOV RDX,RAX
LEA RAX,[RBP + -0x4c]
MOV RSI,RAX
MOV RDI,RDX
CALL 0x0010191e
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018fa
MOV dword ptr [RAX],EBX
LAB_00101393:
ADD dword ptr [RBP + -0x44],0x1
LAB_00101397:
MOV EAX,dword ptr [RBP + -0x44]
CMP EAX,dword ptr [RBP + -0x48]
JL 0x001012bc
ADD dword ptr [RBP + -0x48],0x1
LAB_001013a7:
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x001012b0
MOV dword ptr [RBP + -0x40],0x1
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x00101402
LAB_001013c3:
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018fa
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x40],EAX
SETL AL
TEST AL,AL
JZ 0x001013fe
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018fa
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x40],EAX
LAB_001013fe:
ADD dword ptr [RBP + -0x3c],0x1
LAB_00101402:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x5c]
JL 0x001013c3
MOV EBX,dword ptr [RBP + -0x40]
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x001018a0
MOV EAX,EBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101464
JMP 0x0010145f
LAB_0010145f:
CALL 0x00101130
LAB_00101464:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
bool bVar2;
int *piVar3;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
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;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = &local_55;
local_54 = 1;
/* try { // try from 00101292 to 00101296 has its CatchHandler @ 0010142c */
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_50 = 0;
do {
if (param_2 <= local_50) {
local_48 = 1;
for (local_44 = 0; iVar1 = local_48, local_44 < param_2; local_44 = local_44 + 1) {
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_44);
if (local_48 < *piVar3) {
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_44);
local_48 = *piVar3;
}
}
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_4c = 0; local_4c < local_50; local_4c = local_4c + 1) {
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[](this,(long)local_50);
iVar1 = *piVar3;
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[](this,(long)local_4c);
if (iVar1 == *piVar3 + 1) {
LAB_00101326:
bVar2 = true;
}
else {
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[](this,(long)local_50);
iVar1 = *piVar3;
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[](this,(long)local_4c);
if (iVar1 == *piVar3 + -1) goto LAB_00101326;
bVar2 = false;
}
if (bVar2) {
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_4c);
local_54 = *piVar3 + 1;
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_50);
piVar3 = std::max<int>(piVar3,&local_54);
iVar1 = *piVar3;
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[](local_38,(long)local_50);
*piVar3 = iVar1;
}
}
local_50 = local_50 + 1;
} while( true );
} |
593 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<int> arr, int n) {
std::vector<int> dp(n, 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] == arr[j] + 1 || arr[i] == arr[j] - 1) {
dp[i] = std::max(dp[i], dp[j] + 1);
}
}
}
int result = 1;
for (int i = 0; i < n; i++) {
if (result < dp[i]) {
result = dp[i];
}
}
return result;
}
| int main() {
assert(func0({1, 2, 3, 4, 5, 3, 2}, 7) == 6);
assert(func0({10, 9, 4, 5, 4, 8, 6}, 7) == 3);
assert(func0({1, 2, 3, 2, 3, 7, 2, 1}, 8) == 7);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
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 1290 <_Z5func0St6vectorIiSaIiEEi+0x87>
mov %rdi,%rbx
mov %esi,%ebp
mov $0x1,%r12d
test %rax,%rax
je 1329 <_Z5func0St6vectorIiSaIiEEi+0x120>
lea 0x0(,%rax,4),%r12
mov %r12,%rdi
callq 10f0 <_Znwm@plt>
lea (%rax,%r12,1),%rcx
mov %rax,%rdx
movl $0x1,(%rdx)
add $0x4,%rdx
cmp %rcx,%rdx
jne 1264 <_Z5func0St6vectorIiSaIiEEi+0x5b>
test %ebp,%ebp
jle 1347 <_Z5func0St6vectorIiSaIiEEi+0x13e>
lea 0x4(%rax),%r12
mov $0x4,%edi
mov $0x0,%ecx
lea 0x4(%rsp),%r10
jmp 12e4 <_Z5func0St6vectorIiSaIiEEi+0xdb>
lea 0xd71(%rip),%rdi
callq 10b0 <_ZSt20__throw_length_errorPKc@plt>
mov (%rax,%rdx,1),%esi
lea 0x1(%rsi),%ecx
mov %ecx,0x4(%rsp)
cmp (%r8),%ecx
mov %r9,%rcx
cmovg %r10,%rcx
mov (%rcx),%ecx
mov %ecx,(%r8)
add $0x4,%rdx
cmp %rdx,%rdi
je 12d9 <_Z5func0St6vectorIiSaIiEEi+0xd0>
mov (%rbx),%rcx
mov (%rcx,%rdi,1),%esi
mov (%rcx,%rdx,1),%ecx
lea 0x1(%rcx),%r13d
cmp %r13d,%esi
je 129c <_Z5func0St6vectorIiSaIiEEi+0x93>
sub $0x1,%ecx
cmp %ecx,%esi
jne 12b5 <_Z5func0St6vectorIiSaIiEEi+0xac>
jmp 129c <_Z5func0St6vectorIiSaIiEEi+0x93>
add $0x4,%rdi
add $0x4,%r12
mov %r11d,%ecx
lea 0x1(%rcx),%r11d
cmp %r11d,%ebp
je 12ff <_Z5func0St6vectorIiSaIiEEi+0xf6>
test %r11d,%r11d
jle 12d9 <_Z5func0St6vectorIiSaIiEEi+0xd0>
mov %r12,%r8
mov $0x0,%edx
mov %r12,%r9
jmp 12be <_Z5func0St6vectorIiSaIiEEi+0xb5>
mov %rax,%rdx
mov %ecx,%ecx
lea 0x4(%rax,%rcx,4),%rsi
mov $0x1,%r12d
mov (%rdx),%ecx
cmp %ecx,%r12d
cmovl %ecx,%r12d
add $0x4,%rdx
cmp %rsi,%rdx
jne 130f <_Z5func0St6vectorIiSaIiEEi+0x106>
mov %rax,%rdi
callq 10e0 <_ZdlPv@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 134f <_Z5func0St6vectorIiSaIiEEi+0x146>
mov %r12d,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x1,%r12d
jmp 1321 <_Z5func0St6vectorIiSaIiEEi+0x118>
callq 1100 <__stack_chk_fail@plt>
| _Z5func0St6vectorIiSaIiEEi:
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
movsxd rax, esi
mov rcx, rax
shr rcx, 3Dh
jnz short loc_128D
mov rbp, rdi
mov ebx, esi
mov r12d, 1
test rax, rax
jz loc_1354
lea r15, ds:0[rax*4]
mov rdi, r15; unsigned __int64
call __Znwm; operator new(ulong)
mov r11, rax
lea rdx, [rax+r15]
loc_1262:
mov dword ptr [rax], 1
add rax, 4
cmp rdx, rax
jnz short loc_1262
mov r12, r11
mov esi, 0
mov r8d, 0
mov r14d, 0
mov rcx, r15
mov r15, r11
jmp short loc_12F9
loc_128D:
mov rax, [rsp+58h+var_40]
sub rax, fs:28h
jnz short loc_12A9
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_12A9:
call ___stack_chk_fail
loc_12AE:
mov edi, [r11+rax]
lea edx, [rdi+1]
mov [rsp+58h+var_44], edx
lea rsi, [rsp+58h+var_44]
cmp edx, [r9]
cmovle rsi, r9
mov edx, [rsi]
mov [r9], edx
loc_12CA:
lea rdx, [rax+4]
cmp r8, rax
jz short loc_12EE
mov rax, rdx
loc_12D6:
mov esi, [r13+0]
mov edx, [r10+rax]
lea edi, [rdx+1]
cmp esi, edi
jz short loc_12AE
sub edx, 1
cmp esi, edx
jnz short loc_12CA
jmp short loc_12AE
loc_12EE:
mov rdi, [rsp+58h+var_58]
mov esi, [rsp+58h+var_4C]
loc_12F6:
mov r8, rdi
loc_12F9:
add esi, 1
lea rdi, [r8+4]
add r12, 4
cmp ebx, esi
jz short loc_1324
test esi, esi
jle short loc_12F6
mov r10, [rbp+0]
lea r13, [r10+rdi]
mov r9, r12
mov rax, r14
mov [rsp+58h+var_58], rdi
mov [rsp+58h+var_4C], esi
jmp short loc_12D6
loc_1324:
mov rax, r15
mov r15, rcx
mov rcx, rax
lea rdx, [r11+r15]
mov r12d, 1
loc_1337:
mov eax, [rcx]
cmp r12d, eax
cmovl r12d, eax
add rcx, 4
cmp rdx, rcx
jnz short loc_1337
mov rsi, r15; unsigned __int64
mov rdi, r11; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1354:
mov rax, [rsp+58h+var_40]
sub rax, fs:28h
jnz short loc_1376
mov eax, r12d
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1376:
call ___stack_chk_fail | long long func0(long long *a1, int a2)
{
int v4; // r12d
unsigned long long v5; // r15
int *v6; // rax
int *v7; // r11
int *v8; // rdx
int *v9; // r12
int v10; // esi
long long i; // r8
int *v12; // rsi
unsigned long long v13; // rax
int v14; // edx
long long v15; // rdi
long long v16; // r10
_DWORD *v17; // r13
int *v18; // rcx
int v20; // [rsp+Ch] [rbp-4Ch]
int v21; // [rsp+14h] [rbp-44h] BYREF
unsigned long long v22; // [rsp+18h] [rbp-40h]
v22 = __readfsqword(0x28u);
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v4 = 1;
if ( a2 )
{
v5 = a2;
v6 = (int *)operator new(v5 * 4);
v7 = v6;
v8 = &v6[v5];
do
*v6++ = 1;
while ( v8 != v6 );
v9 = v7;
v10 = 0;
for ( i = 0LL; ; i = v15 )
{
++v10;
v15 = i + 4;
++v9;
if ( a2 == v10 )
break;
if ( v10 > 0 )
{
v16 = *a1;
v17 = (_DWORD *)(*a1 + v15);
v13 = 0LL;
v20 = v10;
while ( 1 )
{
v14 = *(_DWORD *)(v16 + v13);
if ( *v17 == v14 + 1 || *v17 == v14 - 1 )
{
v21 = v7[v13 / 4] + 1;
v12 = &v21;
if ( v21 <= *v9 )
v12 = v9;
*v9 = *v12;
}
if ( i == v13 )
break;
v13 += 4LL;
}
v15 = i + 4;
v10 = v20;
}
}
v18 = v7;
v4 = 1;
do
{
if ( v4 < *v18 )
v4 = *v18;
++v18;
}
while ( &v7[v5] != v18 );
operator delete(v7, v5 * 4);
}
return (unsigned int)v4;
} | 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
MOVSXD RAX,ESI
MOV RCX,RAX
SHR RCX,0x3d
JNZ 0x0010128d
MOV RBP,RDI
MOV EBX,ESI
MOV R12D,0x1
TEST RAX,RAX
JZ 0x00101354
LEA R15,[RAX*0x4]
MOV RDI,R15
CALL 0x001010e0
MOV R11,RAX
LEA RDX,[RAX + R15*0x1]
LAB_00101262:
MOV dword ptr [RAX],0x1
ADD RAX,0x4
CMP RDX,RAX
JNZ 0x00101262
MOV R12,R11
MOV ESI,0x0
MOV R8D,0x0
MOV R14D,0x0
MOV RCX,R15
MOV R15,R11
JMP 0x001012f9
LAB_0010128d:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001012a9
LEA RDI,[0x102008]
CALL 0x001010b0
LAB_001012a9:
CALL 0x00101100
LAB_001012ae:
MOV EDI,dword ptr [R11 + RAX*0x1]
LEA EDX,[RDI + 0x1]
MOV dword ptr [RSP + 0x14],EDX
LEA RSI,[RSP + 0x14]
CMP EDX,dword ptr [R9]
CMOVLE RSI,R9
MOV EDX,dword ptr [RSI]
MOV dword ptr [R9],EDX
LAB_001012ca:
LEA RDX,[RAX + 0x4]
CMP R8,RAX
JZ 0x001012ee
MOV RAX,RDX
LAB_001012d6:
MOV ESI,dword ptr [R13]
MOV EDX,dword ptr [R10 + RAX*0x1]
LEA EDI,[RDX + 0x1]
CMP ESI,EDI
JZ 0x001012ae
SUB EDX,0x1
CMP ESI,EDX
JNZ 0x001012ca
JMP 0x001012ae
LAB_001012ee:
MOV RDI,qword ptr [RSP]
MOV ESI,dword ptr [RSP + 0xc]
LAB_001012f6:
MOV R8,RDI
LAB_001012f9:
ADD ESI,0x1
LEA RDI,[R8 + 0x4]
ADD R12,0x4
CMP EBX,ESI
JZ 0x00101324
TEST ESI,ESI
JLE 0x001012f6
MOV R10,qword ptr [RBP]
LEA R13,[R10 + RDI*0x1]
MOV R9,R12
MOV RAX,R14
MOV qword ptr [RSP],RDI
MOV dword ptr [RSP + 0xc],ESI
JMP 0x001012d6
LAB_00101324:
MOV RAX,R15
MOV R15,RCX
MOV RCX,RAX
LEA RDX,[R11 + R15*0x1]
MOV R12D,0x1
LAB_00101337:
MOV EAX,dword ptr [RCX]
CMP R12D,EAX
CMOVL R12D,EAX
ADD RCX,0x4
CMP RDX,RCX
JNZ 0x00101337
MOV RSI,R15
MOV RDI,R11
CALL 0x001010f0
LAB_00101354:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101376
MOV EAX,R12D
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101376:
CALL 0x00101100 | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
long lVar1;
int iVar2;
int iVar3;
long lVar4;
ulong uVar5;
int *piVar6;
int *piVar7;
long lVar8;
int iVar9;
int *piVar10;
int4 in_register_0000003c;
long lVar11;
long in_FS_OFFSET;
bool bVar12;
int local_44;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = (ulong)param_2;
if (uVar5 >> 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();
}
iVar9 = 1;
if (uVar5 != 0) {
piVar6 = (int *)operator_new(uVar5 * 4);
piVar7 = piVar6;
do {
*piVar7 = 1;
piVar7 = piVar7 + 1;
} while (piVar6 + uVar5 != piVar7);
iVar9 = 0;
lVar1 = 0;
piVar7 = piVar6;
while( true ) {
lVar11 = lVar1;
iVar9 = iVar9 + 1;
lVar1 = lVar11 + 4;
piVar7 = piVar7 + 1;
if (param_2 == iVar9) break;
if (0 < iVar9) {
lVar4 = *(long *)CONCAT44(in_register_0000003c,param_1);
lVar8 = 0;
do {
iVar2 = *(int *)(lVar4 + lVar1);
iVar3 = *(int *)(lVar4 + lVar8);
if ((iVar2 == iVar3 + 1) || (iVar2 == iVar3 + -1)) {
local_44 = *(int *)((long)piVar6 + lVar8) + 1;
piVar10 = &local_44;
if (local_44 <= *piVar7) {
piVar10 = piVar7;
}
*piVar7 = *piVar10;
}
bVar12 = lVar11 != lVar8;
lVar8 = lVar8 + 4;
} while (bVar12);
}
}
iVar9 = 1;
piVar7 = piVar6;
do {
if (iVar9 < *piVar7) {
iVar9 = *piVar7;
}
piVar7 = piVar7 + 1;
} while (piVar6 + uVar5 != piVar7);
operator_delete(piVar6,uVar5 * 4);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar9;
} |
594 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<int> arr, int n) {
std::vector<int> dp(n, 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] == arr[j] + 1 || arr[i] == arr[j] - 1) {
dp[i] = std::max(dp[i], dp[j] + 1);
}
}
}
int result = 1;
for (int i = 0; i < n; i++) {
if (result < dp[i]) {
result = dp[i];
}
}
return result;
}
| int main() {
assert(func0({1, 2, 3, 4, 5, 3, 2}, 7) == 6);
assert(func0({10, 9, 4, 5, 4, 8, 6}, 7) == 3);
assert(func0({1, 2, 3, 2, 3, 7, 2, 1}, 8) == 7);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
movabs $0x1fffffffffffffff,%rdx
push %r13
movslq %esi,%rax
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
cmp %rdx,%rax
ja 1578 <_Z5func0St6vectorIiSaIiEEi+0x128>
mov $0x1,%r13d
test %rax,%rax
je 155a <_Z5func0St6vectorIiSaIiEEi+0x10a>
lea 0x0(,%rax,4),%r13
mov %rdi,%rbx
mov %rax,%rbp
mov %r13,%rdi
callq 10f0 <_Znwm@plt>
mov %rax,%r12
lea (%rax,%r13,1),%rdx
movl $0x1,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 14a0 <_Z5func0St6vectorIiSaIiEEi+0x50>
test %ebp,%ebp
jle 1568 <_Z5func0St6vectorIiSaIiEEi+0x118>
xor %edx,%edx
lea 0x4(%r12),%r9
mov $0x4,%r10d
lea 0x1(%rdx),%eax
cmp %eax,%ebp
je 1529 <_Z5func0St6vectorIiSaIiEEi+0xd9>
nopl 0x0(%rax,%rax,1)
mov (%rbx),%r11
xor %edx,%edx
mov (%r11,%r10,1),%r8d
jmp 14f1 <_Z5func0St6vectorIiSaIiEEi+0xa1>
nopl 0x0(%rax,%rax,1)
sub $0x1,%ecx
cmp %r8d,%ecx
je 14fd <_Z5func0St6vectorIiSaIiEEi+0xad>
add $0x4,%rdx
cmp %rdx,%r10
je 1518 <_Z5func0St6vectorIiSaIiEEi+0xc8>
mov (%r11,%rdx,1),%ecx
lea 0x1(%rcx),%edi
cmp %r8d,%edi
jne 14e0 <_Z5func0St6vectorIiSaIiEEi+0x90>
mov (%r12,%rdx,1),%esi
mov (%r9),%edi
lea 0x1(%rsi),%ecx
cmp %edi,%ecx
cmovl %edi,%ecx
add $0x4,%rdx
mov %ecx,(%r9)
cmp %rdx,%r10
jne 14f1 <_Z5func0St6vectorIiSaIiEEi+0xa1>
mov %eax,%edx
add $0x4,%r10
add $0x4,%r9
lea 0x1(%rdx),%eax
cmp %eax,%ebp
jne 14d0 <_Z5func0St6vectorIiSaIiEEi+0x80>
mov %r12,%rax
lea 0x4(%r12,%rdx,4),%rcx
mov $0x1,%r13d
nopw 0x0(%rax,%rax,1)
mov (%rax),%edx
cmp %edx,%r13d
cmovl %edx,%r13d
add $0x4,%rax
cmp %rax,%rcx
jne 1540 <_Z5func0St6vectorIiSaIiEEi+0xf0>
mov %r12,%rdi
callq 10e0 <_ZdlPv@plt>
add $0x8,%rsp
mov %r13d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov %r12,%rdi
mov $0x1,%r13d
callq 10e0 <_ZdlPv@plt>
jmp 155a <_Z5func0St6vectorIiSaIiEEi+0x10a>
lea 0xa89(%rip),%rdi
callq 10b0 <_ZSt20__throw_length_errorPKc@plt>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0St6vectorIiSaIiEEi:
endbr64
push r15
movsxd rax, esi
push r14
mov rsi, rax
push r13
push r12
push rbp
push rbx
sub rsp, 18h
shr rsi, 3Dh
jnz loc_1547
mov ebx, 1
test rax, rax
jz loc_1523
lea r13, ds:0[rax*4]
mov rbp, rdi
mov r12, rax
mov rdi, r13; unsigned __int64
call __Znwm; operator new(ulong)
mov r11, rax
lea r8, [rax+r13]
test r13b, 4
jz short loc_1468
mov dword ptr [rax], 1
lea rax, [rax+4]
cmp r8, rax
jz short loc_147E
nop word ptr [rax+rax+00h]
loc_1468:
mov dword ptr [rax], 1
add rax, 8
mov dword ptr [rax-4], 1
cmp r8, rax
jnz short loc_1468
loc_147E:
mov [rsp+48h+var_40], r11
mov rdi, r11
xor esi, esi
xor ebx, ebx
nop word ptr [rax+rax+00h]
loc_1490:
add ebx, 1
mov r14, rsi
add rdi, 4
add rsi, 4
cmp r12d, ebx
jle short loc_14E8
mov r10, [rbp+0]
xor eax, eax
lea r15, [r10+rsi]
jmp short loc_14C3
loc_14B0:
sub edx, 1
cmp ecx, edx
jz short loc_14D3
loc_14B7:
lea rdx, [rax+4]
cmp rax, r14
jz short loc_1490
mov rax, rdx
loc_14C3:
mov edx, [r10+rax]
mov ecx, [r15]
lea r9d, [rdx+1]
cmp ecx, r9d
jnz short loc_14B0
loc_14D3:
mov edx, [r11+rax]
mov ecx, [rdi]
add edx, 1
cmp edx, ecx
cmovl edx, ecx
mov [rdi], edx
jmp short loc_14B7
loc_14E8:
mov rax, r8
mov rcx, [rsp+48h+var_40]
mov ebx, 1
sub rax, r11
test al, 4
jnz short loc_1534
nop dword ptr [rax+00h]
loc_1500:
mov eax, [rcx]
cmp ebx, eax
cmovl ebx, eax
mov eax, [rcx+4]
cmp ebx, eax
cmovl ebx, eax
add rcx, 8
cmp rcx, r8
jnz short loc_1500
loc_1518:
mov rsi, r13; unsigned __int64
mov rdi, r11; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1523:
add rsp, 18h
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1534:
mov eax, [r11]
lea rcx, [r11+4]
cmp ebx, eax
cmovl ebx, eax
cmp rcx, r8
jnz short loc_1500
jmp short loc_1518
loc_1547:
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; // ebx
unsigned long long v3; // r13
int *v6; // rax
int *v7; // r11
int *v8; // r8
int *v9; // rdi
long long v10; // rsi
int v11; // ebx
long long v12; // r14
long long v13; // r10
unsigned long long v14; // rax
_DWORD *v15; // r15
int v16; // edx
int v17; // edx
int *v18; // rcx
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v2 = 1;
if ( a2 )
{
v3 = 4LL * a2;
v6 = (int *)operator new(v3);
v7 = v6;
v8 = &v6[v3 / 4];
if ( (v3 & 4) == 0 || (*v6 = 1, ++v6, v8 != v6) )
{
do
{
*v6 = 1;
v6 += 2;
*(v6 - 1) = 1;
}
while ( v8 != v6 );
}
v9 = v7;
v10 = 0LL;
v11 = 0;
while ( 1 )
{
++v11;
v12 = v10;
++v9;
v10 += 4LL;
if ( a2 <= v11 )
break;
v13 = *a1;
v14 = 0LL;
v15 = (_DWORD *)(*a1 + v10);
while ( 1 )
{
v16 = *(_DWORD *)(v13 + v14);
if ( *v15 == v16 + 1 || *v15 == v16 - 1 )
{
v17 = v7[v14 / 4] + 1;
if ( v17 < *v9 )
v17 = *v9;
*v9 = v17;
}
if ( v14 == v12 )
break;
v14 += 4LL;
}
}
v18 = v7;
v2 = 1;
if ( (((_BYTE)v8 - (_BYTE)v7) & 4) == 0 )
goto LABEL_31;
v18 = v7 + 1;
if ( *v7 > 1 )
v2 = *v7;
if ( v18 != v8 )
{
LABEL_31:
do
{
if ( v2 < *v18 )
v2 = *v18;
if ( v2 < v18[1] )
v2 = v18[1];
v18 += 2;
}
while ( v18 != v8 );
}
operator delete(v7, v3);
}
return (unsigned int)v2;
} | func0:
ENDBR64
PUSH R15
MOVSXD RAX,ESI
PUSH R14
MOV RSI,RAX
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
SHR RSI,0x3d
JNZ 0x00101547
MOV EBX,0x1
TEST RAX,RAX
JZ 0x00101523
LEA R13,[RAX*0x4]
MOV RBP,RDI
MOV R12,RAX
MOV RDI,R13
CALL 0x001010e0
MOV R11,RAX
LEA R8,[RAX + R13*0x1]
TEST R13B,0x4
JZ 0x00101468
MOV dword ptr [RAX],0x1
LEA RAX,[RAX + 0x4]
CMP R8,RAX
JZ 0x0010147e
NOP word ptr [RAX + RAX*0x1]
LAB_00101468:
MOV dword ptr [RAX],0x1
ADD RAX,0x8
MOV dword ptr [RAX + -0x4],0x1
CMP R8,RAX
JNZ 0x00101468
LAB_0010147e:
MOV qword ptr [RSP + 0x8],R11
MOV RDI,R11
XOR ESI,ESI
XOR EBX,EBX
NOP word ptr [RAX + RAX*0x1]
LAB_00101490:
ADD EBX,0x1
MOV R14,RSI
ADD RDI,0x4
ADD RSI,0x4
CMP R12D,EBX
JLE 0x001014e8
MOV R10,qword ptr [RBP]
XOR EAX,EAX
LEA R15,[R10 + RSI*0x1]
JMP 0x001014c3
LAB_001014b0:
SUB EDX,0x1
CMP ECX,EDX
JZ 0x001014d3
LAB_001014b7:
LEA RDX,[RAX + 0x4]
CMP RAX,R14
JZ 0x00101490
MOV RAX,RDX
LAB_001014c3:
MOV EDX,dword ptr [R10 + RAX*0x1]
MOV ECX,dword ptr [R15]
LEA R9D,[RDX + 0x1]
CMP ECX,R9D
JNZ 0x001014b0
LAB_001014d3:
MOV EDX,dword ptr [R11 + RAX*0x1]
MOV ECX,dword ptr [RDI]
ADD EDX,0x1
CMP EDX,ECX
CMOVL EDX,ECX
MOV dword ptr [RDI],EDX
JMP 0x001014b7
LAB_001014e8:
MOV RAX,R8
MOV RCX,qword ptr [RSP + 0x8]
MOV EBX,0x1
SUB RAX,R11
TEST AL,0x4
JNZ 0x00101534
NOP dword ptr [RAX]
LAB_00101500:
MOV EAX,dword ptr [RCX]
CMP EBX,EAX
CMOVL EBX,EAX
MOV EAX,dword ptr [RCX + 0x4]
CMP EBX,EAX
CMOVL EBX,EAX
ADD RCX,0x8
CMP RCX,R8
JNZ 0x00101500
LAB_00101518:
MOV RSI,R13
MOV RDI,R11
CALL 0x001010f0
LAB_00101523:
ADD RSP,0x18
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101534:
MOV EAX,dword ptr [R11]
LEA RCX,[R11 + 0x4]
CMP EBX,EAX
CMOVL EBX,EAX
CMP RCX,R8
JNZ 0x00101500
JMP 0x00101518
LAB_00101547:
LEA RDI,[0x102008]
CALL 0x001010b0
NOP word ptr CS:[RAX + RAX*0x1]
NOP dword ptr [RAX] | /* func0(std::vector<int, std::allocator<int> >, int) */
void * func0(vector param_1,int param_2)
{
uint *puVar1;
ulong uVar2;
int iVar3;
int iVar4;
long lVar5;
void *pvVar6;
ulong uVar7;
uint *puVar8;
uint *puVar9;
long lVar10;
void *extraout_RAX;
uint uVar11;
int iVar12;
long lVar13;
long lVar14;
int4 in_register_0000003c;
char *pcVar15;
bool bVar16;
uVar7 = (ulong)param_2;
if (uVar7 >> 0x3d != 0) {
pcVar15 = "cannot create std::vector larger than max_size()";
std::__throw_length_error("cannot create std::vector larger than max_size()");
pvVar6 = *(void **)pcVar15;
if (pvVar6 == (void *)0x0) {
return pvVar6;
}
operator_delete(pvVar6,*(long *)(pcVar15 + 0x10) - (long)pvVar6);
return extraout_RAX;
}
uVar11 = 1;
if (uVar7 != 0) {
uVar2 = uVar7 * 4;
puVar8 = (uint *)operator_new(uVar2);
puVar1 = puVar8 + uVar7;
puVar9 = puVar8;
if ((uVar2 & 4) == 0) goto LAB_00101468;
*puVar8 = 1;
for (puVar9 = puVar8 + 1; puVar1 != puVar9; puVar9 = puVar9 + 2) {
LAB_00101468:
*puVar9 = 1;
puVar9[1] = 1;
}
iVar12 = 0;
lVar14 = 0;
puVar9 = puVar8;
while( true ) {
lVar13 = lVar14;
iVar12 = iVar12 + 1;
puVar9 = puVar9 + 1;
lVar14 = lVar13 + 4;
if (param_2 <= iVar12) break;
lVar5 = *(long *)CONCAT44(in_register_0000003c,param_1);
lVar10 = 0;
do {
iVar3 = *(int *)(lVar5 + lVar10);
iVar4 = *(int *)(lVar5 + lVar14);
if ((iVar4 == iVar3 + 1) || (iVar4 == iVar3 + -1)) {
uVar11 = *(int *)((long)puVar8 + lVar10) + 1;
if ((int)uVar11 < (int)*puVar9) {
uVar11 = *puVar9;
}
*puVar9 = uVar11;
}
bVar16 = lVar10 != lVar13;
lVar10 = lVar10 + 4;
} while (bVar16);
}
uVar11 = 1;
puVar9 = puVar8;
if (((long)puVar1 - (long)puVar8 & 4U) != 0) {
puVar9 = puVar8 + 1;
uVar11 = 1;
if ((int)*puVar8 < 2) goto joined_r0x00101543;
uVar11 = *puVar8;
goto joined_r0x00101543;
}
do {
if ((int)uVar11 < (int)*puVar9) {
uVar11 = *puVar9;
}
if ((int)uVar11 < (int)puVar9[1]) {
uVar11 = puVar9[1];
}
puVar9 = puVar9 + 2;
joined_r0x00101543:
} while (puVar9 != puVar1);
operator_delete(puVar8,uVar2);
}
return (void *)(ulong)uVar11;
} |
595 | func0 |
#include <vector>
#include <cassert>
| int func0(std::vector<int> arr, int n) {
std::vector<int> dp(n, 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] == arr[j] + 1 || arr[i] == arr[j] - 1) {
dp[i] = std::max(dp[i], dp[j] + 1);
}
}
}
int result = 1;
for (int i = 0; i < n; i++) {
if (result < dp[i]) {
result = dp[i];
}
}
return result;
}
| int main() {
assert(func0({1, 2, 3, 4, 5, 3, 2}, 7) == 6);
assert(func0({10, 9, 4, 5, 4, 8, 6}, 7) == 3);
assert(func0({1, 2, 3, 2, 3, 7, 2, 1}, 8) == 7);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r14
movslq %esi,%r14
push %r13
push %r12
push %rbp
push %rbx
cmp %rax,%r14
ja 1633 <_Z5func0St6vectorIiSaIiEEi+0x223>
mov $0x1,%r13d
test %r14,%r14
je 160d <_Z5func0St6vectorIiSaIiEEi+0x1fd>
mov %rdi,%r12
lea 0x0(,%r14,4),%rdi
mov %r14,%rbx
callq 10f0 <_Znwm@plt>
mov %rax,%rbp
lea -0x1(%r14),%rax
cmp $0x2,%rax
mov %rbp,%rax
jbe 162b <_Z5func0St6vectorIiSaIiEEi+0x21b>
mov %r14,%rdx
movdqa 0xc9d(%rip),%xmm0
shr $0x2,%rdx
shl $0x4,%rdx
add %rbp,%rdx
xchg %ax,%ax
movups %xmm0,(%rax)
add $0x10,%rax
cmp %rdx,%rax
jne 1480 <_Z5func0St6vectorIiSaIiEEi+0x70>
mov %r14,%rdx
mov %r14,%rcx
and $0xfffffffffffffffc,%rdx
and $0x3,%ecx
lea 0x0(%rbp,%rdx,4),%rax
cmp %rdx,%r14
je 14c3 <_Z5func0St6vectorIiSaIiEEi+0xb3>
movl $0x1,(%rax)
cmp $0x1,%rcx
je 14c3 <_Z5func0St6vectorIiSaIiEEi+0xb3>
movl $0x1,0x4(%rax)
cmp $0x2,%rcx
je 14c3 <_Z5func0St6vectorIiSaIiEEi+0xb3>
movl $0x1,0x8(%rax)
test %ebx,%ebx
jle 1619 <_Z5func0St6vectorIiSaIiEEi+0x209>
cmp $0x1,%ebx
je 1537 <_Z5func0St6vectorIiSaIiEEi+0x127>
mov (%r12),%r11
lea 0x4(%rbp),%r9
mov $0x4,%r10d
mov $0x1,%eax
nopl 0x0(%rax,%rax,1)
mov (%r11,%r10,1),%r8d
xor %edx,%edx
jmp 1501 <_Z5func0St6vectorIiSaIiEEi+0xf1>
sub $0x1,%ecx
cmp %r8d,%ecx
je 150d <_Z5func0St6vectorIiSaIiEEi+0xfd>
add $0x4,%rdx
cmp %r10,%rdx
je 1528 <_Z5func0St6vectorIiSaIiEEi+0x118>
mov (%r11,%rdx,1),%ecx
lea 0x1(%rcx),%edi
cmp %r8d,%edi
jne 14f0 <_Z5func0St6vectorIiSaIiEEi+0xe0>
mov 0x0(%rbp,%rdx,1),%esi
mov (%r9),%edi
lea 0x1(%rsi),%ecx
cmp %edi,%ecx
cmovl %edi,%ecx
add $0x4,%rdx
mov %ecx,(%r9)
cmp %r10,%rdx
jne 1501 <_Z5func0St6vectorIiSaIiEEi+0xf1>
add $0x1,%eax
add $0x4,%r10
add $0x4,%r9
cmp %eax,%ebx
jne 14e8 <_Z5func0St6vectorIiSaIiEEi+0xd8>
lea -0x1(%rbx),%eax
cmp $0x2,%eax
jbe 1621 <_Z5func0St6vectorIiSaIiEEi+0x211>
mov %ebx,%edx
movdqa 0xbc3(%rip),%xmm2
mov %rbp,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rbp,%rdx
nopw 0x0(%rax,%rax,1)
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 1560 <_Z5func0St6vectorIiSaIiEEi+0x150>
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,%r13d
test $0x3,%bl
je 1605 <_Z5func0St6vectorIiSaIiEEi+0x1f5>
movslq %eax,%rdx
mov 0x0(%rbp,%rdx,4),%edx
cmp %edx,%r13d
cmovl %edx,%r13d
lea 0x1(%rax),%edx
cmp %edx,%ebx
jle 1605 <_Z5func0St6vectorIiSaIiEEi+0x1f5>
movslq %edx,%rdx
mov 0x0(%rbp,%rdx,4),%edx
cmp %edx,%r13d
cmovl %edx,%r13d
add $0x2,%eax
cmp %eax,%ebx
jle 1605 <_Z5func0St6vectorIiSaIiEEi+0x1f5>
cltq
mov 0x0(%rbp,%rax,4),%eax
cmp %eax,%r13d
cmovl %eax,%r13d
mov %rbp,%rdi
callq 10e0 <_ZdlPv@plt>
pop %rbx
mov %r13d,%eax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov $0x1,%r13d
jmp 1605 <_Z5func0St6vectorIiSaIiEEi+0x1f5>
xor %eax,%eax
mov $0x1,%r13d
jmp 15ce <_Z5func0St6vectorIiSaIiEEi+0x1be>
mov %r14,%rcx
jmpq 14a3 <_Z5func0St6vectorIiSaIiEEi+0x93>
lea 0x9ce(%rip),%rdi
callq 10b0 <_ZSt20__throw_length_errorPKc@plt>
| _Z5func0St6vectorIiSaIiEEi:
endbr64
push r13
push r12
movsxd r12, esi
push rbp
mov rax, r12
push rbx
sub rsp, 8
shr rax, 3Dh
jnz loc_164E
mov ebx, 1
test r12, r12
jz loc_161F
mov rbp, r12
shl r12, 2
mov r13, rdi
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
mov r9, rax
lea rdi, [rax+r12]
lea rax, [r12-4]
mov rdx, rax
shr rdx, 2
add rdx, 1
cmp rax, 8
mov rax, r9
jbe short loc_14AD
mov rcx, rdx
movdqa xmm0, cs:xmmword_20F0
shr rcx, 2
shl rcx, 4
lea rsi, [rcx+r9]
and ecx, 10h
jz short loc_1490
lea rax, [r9+10h]
movups xmmword ptr [r9], xmm0
cmp rax, rsi
jz short loc_14A0
nop word ptr [rax+rax+00000000h]
loc_1490:
movups xmmword ptr [rax], xmm0
add rax, 20h ; ' '
movups xmmword ptr [rax-10h], xmm0
cmp rax, rsi
jnz short loc_1490
loc_14A0:
test dl, 3
jz short loc_14D3
and rdx, 0FFFFFFFFFFFFFFFCh
lea rax, [r9+rdx*4]
loc_14AD:
lea rdx, [rax+4]
mov dword ptr [rax], 1
cmp rdi, rdx
jz short loc_14D3
lea rdx, [rax+8]
mov dword ptr [rax+4], 1
cmp rdi, rdx
jz short loc_14D3
mov dword ptr [rax+8], 1
loc_14D3:
cmp ebp, 1
jz loc_162C
mov r11, [r13+0]
lea rsi, [r9+4]
mov r10d, ebp
mov edx, 1
nop dword ptr [rax+00h]
loc_14F0:
lea rbx, [r11+rdx*4]
xor eax, eax
jmp short loc_150F
loc_1500:
sub ecx, 1
cmp ecx, edi
jz short loc_151E
add rax, 1
cmp eax, edx
jge short loc_1536
loc_150F:
mov ecx, [r11+rax*4]
mov edi, [rbx]
lea r8d, [rcx+1]
cmp r8d, edi
jnz short loc_1500
loc_151E:
mov ecx, [r9+rax*4]
mov edi, [rsi]
add ecx, 1
cmp ecx, edi
cmovl ecx, edi
add rax, 1
mov [rsi], ecx
cmp eax, edx
jl short loc_150F
loc_1536:
add rdx, 1
add rsi, 4
cmp rdx, r10
jnz short loc_14F0
lea eax, [rbp-1]
cmp eax, 2
jbe loc_163B
mov edx, ebp
movdqa xmm2, cs:xmmword_20F0
mov rax, r9
shr edx, 2
shl rdx, 4
add rdx, r9
nop word ptr [rax+rax+00000000h]
loc_1570:
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 rdx, rax
jnz short loc_1570
movdqa xmm1, xmm2
psrldq xmm1, 8
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_1614
mov eax, ebp
and eax, 0FFFFFFFCh
movsxd rcx, eax
lea rdx, ds:0[rcx*4]
mov ecx, [r9+rcx*4]
cmp ebx, ecx
cmovl ebx, ecx
lea ecx, [rax+1]
cmp ebp, ecx
jle short loc_1614
loc_15F9:
mov ecx, [r9+rdx+4]
cmp ebx, ecx
cmovl ebx, ecx
add eax, 2
cmp ebp, eax
jle short loc_1614
mov eax, [r9+rdx+8]
cmp ebx, eax
cmovl ebx, eax
loc_1614:
mov rsi, r12; unsigned __int64
mov rdi, r9; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_161F:
add rsp, 8
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
retn
loc_162C:
mov ebx, [r9]
mov eax, 1
test ebx, ebx
cmovle ebx, eax
jmp short loc_1614
loc_163B:
mov ebx, [r9]
mov eax, 1
test ebx, ebx
cmovle ebx, eax
xor edx, edx
xor eax, eax
jmp short loc_15F9
loc_164E:
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, signed int a2)
{
int v2; // ebx
unsigned long long v4; // r12
__m128i *v6; // rax
__m128i *v7; // r9
char *v8; // rdi
unsigned long long v9; // rdx
__m128i si128; // xmm0
long long v11; // rcx
__m128i *v12; // rsi
long long v13; // r11
int *v14; // rsi
long long v15; // rdx
long long v16; // rax
int v17; // ecx
int v18; // edi
int v19; // ecx
__m128i v20; // xmm2
const __m128i *v21; // rax
__m128i v22; // xmm0
__m128i v23; // xmm1
__m128i v24; // xmm1
__m128i v25; // xmm0
__m128i v26; // xmm0
__m128i v27; // xmm2
__m128i v28; // xmm1
unsigned int v29; // eax
long long v30; // rdx
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v2 = 1;
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_20F0);
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 = 1;
goto LABEL_34;
}
v13 = *a1;
v14 = &v7->m128i_i32[1];
v15 = 1LL;
do
{
v16 = 0LL;
do
{
while ( 1 )
{
v17 = *(_DWORD *)(v13 + 4 * v16);
v18 = *(_DWORD *)(v13 + 4 * v15);
if ( v17 + 1 == v18 || v17 - 1 == v18 )
break;
if ( (int)++v16 >= (int)v15 )
goto LABEL_21;
}
v19 = v7->m128i_i32[v16] + 1;
if ( v19 < *v14 )
v19 = *v14;
++v16;
*v14 = v19;
}
while ( (int)v16 < (int)v15 );
LABEL_21:
++v15;
++v14;
}
while ( v15 != a2 );
if ( (unsigned int)(a2 - 1) <= 2 )
{
v2 = v7->m128i_i32[0];
if ( v7->m128i_i32[0] <= 0 )
v2 = 1;
v30 = 0LL;
v29 = 0;
}
else
{
v20 = _mm_load_si128((const __m128i *)&xmmword_20F0);
v21 = v7;
do
{
v22 = _mm_loadu_si128(v21++);
v23 = _mm_cmpgt_epi32(v22, v20);
v20 = _mm_or_si128(_mm_andnot_si128(v23, v20), _mm_and_si128(v22, v23));
}
while ( &v7[(unsigned int)a2 >> 2] != v21 );
v24 = _mm_srli_si128(v20, 8);
v25 = _mm_cmpgt_epi32(v24, v20);
v26 = _mm_or_si128(_mm_andnot_si128(v25, v20), _mm_and_si128(v24, v25));
v27 = _mm_srli_si128(v26, 4);
v28 = _mm_cmpgt_epi32(v27, v26);
v2 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v28, v26), _mm_and_si128(v27, v28)));
if ( (a2 & 3) == 0 )
goto LABEL_34;
v29 = a2 & 0xFFFFFFFC;
v30 = (int)(a2 & 0xFFFFFFFC);
if ( v2 < v7->m128i_i32[v30] )
v2 = v7->m128i_i32[a2 & 0xFFFFFFFC];
if ( a2 <= (int)(v29 + 1) )
goto LABEL_34;
}
if ( v2 < v7->m128i_i32[v30 + 1] )
v2 = v7->m128i_i32[v30 + 1];
if ( a2 > (int)(v29 + 2) && v2 < v7->m128i_i32[v30 + 2] )
v2 = v7->m128i_i32[v30 + 2];
LABEL_34:
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 0x0010164e
MOV EBX,0x1
TEST R12,R12
JZ 0x0010161f
MOV RBP,R12
SHL R12,0x2
MOV R13,RDI
MOV RDI,R12
CALL 0x001010e0
MOV R9,RAX
LEA RDI,[RAX + R12*0x1]
LEA RAX,[R12 + -0x4]
MOV RDX,RAX
SHR RDX,0x2
ADD RDX,0x1
CMP RAX,0x8
MOV RAX,R9
JBE 0x001014ad
MOV RCX,RDX
MOVDQA XMM0,xmmword ptr [0x001020f0]
SHR RCX,0x2
SHL RCX,0x4
LEA RSI,[RCX + R9*0x1]
AND ECX,0x10
JZ 0x00101490
LEA RAX,[R9 + 0x10]
MOVUPS xmmword ptr [R9],XMM0
CMP RAX,RSI
JZ 0x001014a0
NOP word ptr [RAX + RAX*0x1]
LAB_00101490:
MOVUPS xmmword ptr [RAX],XMM0
ADD RAX,0x20
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP RAX,RSI
JNZ 0x00101490
LAB_001014a0:
TEST DL,0x3
JZ 0x001014d3
AND RDX,-0x4
LEA RAX,[R9 + RDX*0x4]
LAB_001014ad:
LEA RDX,[RAX + 0x4]
MOV dword ptr [RAX],0x1
CMP RDI,RDX
JZ 0x001014d3
LEA RDX,[RAX + 0x8]
MOV dword ptr [RAX + 0x4],0x1
CMP RDI,RDX
JZ 0x001014d3
MOV dword ptr [RAX + 0x8],0x1
LAB_001014d3:
CMP EBP,0x1
JZ 0x0010162c
MOV R11,qword ptr [R13]
LEA RSI,[R9 + 0x4]
MOV R10D,EBP
MOV EDX,0x1
NOP dword ptr [RAX]
LAB_001014f0:
LEA RBX,[R11 + RDX*0x4]
XOR EAX,EAX
JMP 0x0010150f
LAB_00101500:
SUB ECX,0x1
CMP ECX,EDI
JZ 0x0010151e
ADD RAX,0x1
CMP EAX,EDX
JGE 0x00101536
LAB_0010150f:
MOV ECX,dword ptr [R11 + RAX*0x4]
MOV EDI,dword ptr [RBX]
LEA R8D,[RCX + 0x1]
CMP R8D,EDI
JNZ 0x00101500
LAB_0010151e:
MOV ECX,dword ptr [R9 + RAX*0x4]
MOV EDI,dword ptr [RSI]
ADD ECX,0x1
CMP ECX,EDI
CMOVL ECX,EDI
ADD RAX,0x1
MOV dword ptr [RSI],ECX
CMP EAX,EDX
JL 0x0010150f
LAB_00101536:
ADD RDX,0x1
ADD RSI,0x4
CMP RDX,R10
JNZ 0x001014f0
LEA EAX,[RBP + -0x1]
CMP EAX,0x2
JBE 0x0010163b
MOV EDX,EBP
MOVDQA XMM2,xmmword ptr [0x001020f0]
MOV RAX,R9
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,R9
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101570:
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 RDX,RAX
JNZ 0x00101570
MOVDQA XMM1,XMM2
PSRLDQ XMM1,0x8
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 0x00101614
MOV EAX,EBP
AND EAX,0xfffffffc
MOVSXD RCX,EAX
LEA RDX,[RCX*0x4]
MOV ECX,dword ptr [R9 + RCX*0x4]
CMP EBX,ECX
CMOVL EBX,ECX
LEA ECX,[RAX + 0x1]
CMP EBP,ECX
JLE 0x00101614
LAB_001015f9:
MOV ECX,dword ptr [R9 + RDX*0x1 + 0x4]
CMP EBX,ECX
CMOVL EBX,ECX
ADD EAX,0x2
CMP EBP,EAX
JLE 0x00101614
MOV EAX,dword ptr [R9 + RDX*0x1 + 0x8]
CMP EBX,EAX
CMOVL EBX,EAX
LAB_00101614:
MOV RSI,R12
MOV RDI,R9
CALL 0x001010f0
LAB_0010161f:
ADD RSP,0x8
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_0010162c:
MOV EBX,dword ptr [R9]
MOV EAX,0x1
TEST EBX,EBX
CMOVLE EBX,EAX
JMP 0x00101614
LAB_0010163b:
MOV EBX,dword ptr [R9]
MOV EAX,0x1
TEST EBX,EBX
CMOVLE EBX,EAX
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001015f9
LAB_0010164e:
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<int, std::allocator<int> >, int) */
void * func0(vector param_1,int param_2)
{
int iVar1;
int iVar2;
void *pvVar3;
uint uVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
int8 uVar8;
int8 uVar9;
uint uVar10;
uint *puVar11;
long lVar12;
uint *puVar13;
void *extraout_RAX;
ulong uVar14;
long lVar15;
uint uVar16;
int4 in_register_0000003c;
char *pcVar17;
ulong uVar18;
ulong uVar19;
uint uVar20;
uint uVar21;
uint uVar22;
uint uVar23;
uint uVar24;
uint uVar25;
uVar18 = (ulong)param_2;
if (uVar18 >> 0x3d != 0) {
pcVar17 = "cannot create std::vector larger than max_size()";
std::__throw_length_error("cannot create std::vector larger than max_size()");
pvVar3 = *(void **)pcVar17;
if (pvVar3 != (void *)0x0) {
operator_delete(pvVar3,*(long *)(pcVar17 + 0x10) - (long)pvVar3);
return extraout_RAX;
}
return pvVar3;
}
uVar16 = 1;
if (uVar18 == 0) goto LAB_0010161f;
uVar19 = uVar18 * 4;
puVar11 = (uint *)operator_new(uVar19);
uVar14 = (uVar19 - 4 >> 2) + 1;
puVar13 = puVar11;
if (uVar19 - 4 < 9) {
LAB_001014ad:
*puVar13 = 1;
if ((puVar11 + uVar18 != puVar13 + 1) && (puVar13[1] = 1, puVar11 + uVar18 != puVar13 + 2)) {
puVar13[2] = 1;
}
}
else {
uVar8 = CONCAT44(_UNK_001020f4,_DAT_001020f0);
uVar9 = CONCAT44(_UNK_001020fc,_UNK_001020f8);
if (((uVar14 >> 2) * 0x10 & 0x10) == 0) goto LAB_00101490;
*(int8 *)puVar11 = uVar8;
*(int8 *)(puVar11 + 2) = uVar9;
for (puVar13 = puVar11 + 4; puVar13 != puVar11 + (uVar14 >> 2) * 4; puVar13 = puVar13 + 8) {
LAB_00101490:
*(int8 *)puVar13 = uVar8;
*(int8 *)(puVar13 + 2) = uVar9;
*(int8 *)(puVar13 + 4) = uVar8;
*(int8 *)(puVar13 + 6) = uVar9;
}
if ((uVar14 & 3) != 0) {
puVar13 = puVar11 + (uVar14 & 0xfffffffffffffffc);
goto LAB_001014ad;
}
}
if (param_2 == 1) {
uVar16 = *puVar11;
if ((int)uVar16 < 1) {
uVar16 = 1;
}
}
else {
lVar15 = *(long *)CONCAT44(in_register_0000003c,param_1);
uVar14 = 1;
puVar13 = puVar11;
do {
puVar13 = puVar13 + 1;
lVar12 = 0;
do {
while( true ) {
iVar1 = *(int *)(lVar15 + lVar12 * 4);
iVar2 = *(int *)(lVar15 + uVar14 * 4);
if ((iVar1 + 1 != iVar2) && (iVar1 + -1 != iVar2)) break;
uVar16 = puVar11[lVar12] + 1;
if ((int)(puVar11[lVar12] + 1) < (int)*puVar13) {
uVar16 = *puVar13;
}
lVar12 = lVar12 + 1;
*puVar13 = uVar16;
if ((int)uVar14 <= (int)lVar12) goto LAB_00101536;
}
lVar12 = lVar12 + 1;
} while ((int)lVar12 < (int)uVar14);
LAB_00101536:
uVar14 = uVar14 + 1;
} while (uVar14 != (uint)param_2);
if (param_2 - 1U < 3) {
uVar16 = *puVar11;
if ((int)uVar16 < 1) {
uVar16 = 1;
}
lVar15 = 0;
uVar10 = 0;
LAB_001015f9:
uVar21 = *(uint *)((long)puVar11 + lVar15 + 4);
if ((int)uVar16 < (int)uVar21) {
uVar16 = uVar21;
}
if (((int)(uVar10 + 2) < param_2) &&
(uVar10 = *(uint *)((long)puVar11 + lVar15 + 8), (int)uVar16 < (int)uVar10)) {
uVar16 = uVar10;
}
}
else {
puVar13 = puVar11;
uVar16 = _DAT_001020f0;
uVar10 = _UNK_001020f4;
uVar21 = _UNK_001020f8;
uVar25 = _UNK_001020fc;
do {
uVar4 = *puVar13;
puVar5 = puVar13 + 1;
puVar6 = puVar13 + 2;
puVar7 = puVar13 + 3;
puVar13 = puVar13 + 4;
uVar20 = -(uint)((int)uVar16 < (int)uVar4);
uVar22 = -(uint)((int)uVar10 < (int)*puVar5);
uVar23 = -(uint)((int)uVar21 < (int)*puVar6);
uVar24 = -(uint)((int)uVar25 < (int)*puVar7);
uVar16 = ~uVar20 & uVar16 | uVar4 & uVar20;
uVar10 = ~uVar22 & uVar10 | *puVar5 & uVar22;
uVar21 = ~uVar23 & uVar21 | *puVar6 & uVar23;
uVar25 = ~uVar24 & uVar25 | *puVar7 & uVar24;
} while (puVar11 + (ulong)((uint)param_2 >> 2) * 4 != puVar13);
uVar16 = ~-(uint)((int)uVar16 < (int)uVar21) & uVar16 |
uVar21 & -(uint)((int)uVar16 < (int)uVar21);
uVar10 = ~-(uint)((int)uVar10 < (int)uVar25) & uVar10 |
uVar25 & -(uint)((int)uVar10 < (int)uVar25);
uVar21 = -(uint)((int)uVar16 < (int)uVar10);
uVar16 = ~uVar21 & uVar16 | uVar10 & uVar21;
if ((uVar18 & 3) != 0) {
uVar10 = param_2 & 0xfffffffc;
lVar15 = (long)(int)uVar10 * 4;
if ((int)uVar16 < (int)puVar11[(int)uVar10]) {
uVar16 = puVar11[(int)uVar10];
}
if ((int)(uVar10 + 1) < param_2) goto LAB_001015f9;
}
}
}
operator_delete(puVar11,uVar19);
LAB_0010161f:
return (void *)(ulong)uVar16;
} |
596 | func0 |
#include <assert.h>
| bool func0(int a, int b, int c) {
if (a == b) {
return true;
}
if ((b - a) * c > 0 && (b - a) % c == 0) {
return true;
}
return false;
}
| int main() {
assert(func0(1, 7, 3) == true);
assert(func0(1, -3, 5) == false);
assert(func0(3, 2, 5) == false);
return 0;
}
| O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov %edx,-0xc(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jne 1169 <_Z5func0iii+0x20>
mov $0x1,%eax
jmp 1193 <_Z5func0iii+0x4a>
mov -0x8(%rbp),%eax
sub -0x4(%rbp),%eax
imul -0xc(%rbp),%eax
test %eax,%eax
jle 118e <_Z5func0iii+0x45>
mov -0x8(%rbp),%eax
sub -0x4(%rbp),%eax
cltd
idivl -0xc(%rbp)
mov %edx,%eax
test %eax,%eax
jne 118e <_Z5func0iii+0x45>
mov $0x1,%eax
jmp 1193 <_Z5func0iii+0x4a>
mov $0x0,%eax
pop %rbp
retq
| _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jnz short loc_1169
mov eax, 1
jmp short loc_1193
loc_1169:
mov eax, [rbp+var_8]
sub eax, [rbp+var_4]
imul eax, [rbp+var_C]
test eax, eax
jle short loc_118E
mov eax, [rbp+var_8]
sub eax, [rbp+var_4]
cdq
idiv [rbp+var_C]
mov eax, edx
test eax, eax
jnz short loc_118E
mov eax, 1
jmp short loc_1193
loc_118E:
mov eax, 0
loc_1193:
pop rbp
retn | _BOOL8 func0(int a1, int a2, int a3)
{
if ( a1 == a2 )
return 1LL;
return a3 * (a2 - a1) > 0 && !((a2 - a1) % a3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JNZ 0x00101169
MOV EAX,0x1
JMP 0x00101193
LAB_00101169:
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0xc]
TEST EAX,EAX
JLE 0x0010118e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,dword ptr [RBP + -0x4]
CDQ
IDIV dword ptr [RBP + -0xc]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x0010118e
MOV EAX,0x1
JMP 0x00101193
LAB_0010118e:
MOV EAX,0x0
LAB_00101193:
POP RBP
RET | /* func0(int, int, int) */
int8 func0(int param_1,int param_2,int param_3)
{
int8 uVar1;
if (param_1 == param_2) {
uVar1 = 1;
}
else if (((param_2 - param_1) * param_3 < 1) || ((param_2 - param_1) % param_3 != 0)) {
uVar1 = 0;
}
else {
uVar1 = 1;
}
return uVar1;
} |
597 | func0 |
#include <assert.h>
| bool func0(int a, int b, int c) {
if (a == b) {
return true;
}
if ((b - a) * c > 0 && (b - a) % c == 0) {
return true;
}
return false;
}
| int main() {
assert(func0(1, 7, 3) == true);
assert(func0(1, -3, 5) == false);
assert(func0(3, 2, 5) == false);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
mov %esi,%eax
mov %edx,%ecx
mov $0x1,%edx
cmp %esi,%edi
je 1152 <_Z5func0iii+0x29>
sub %edi,%eax
mov %eax,%esi
imul %ecx,%esi
mov $0x0,%edx
test %esi,%esi
jle 1152 <_Z5func0iii+0x29>
cltd
idiv %ecx
test %edx,%edx
sete %dl
mov %edx,%eax
retq
| _Z5func0iii:
endbr64
mov eax, esi
mov ecx, edx
mov edx, 1
cmp edi, esi
jz short loc_1152
sub eax, edi
mov esi, eax
imul esi, ecx
mov edx, 0
test esi, esi
jle short loc_1152
cdq
idiv ecx
test edx, edx
setz dl
loc_1152:
mov eax, edx
retn | long long func0(int a1, int a2, int a3)
{
unsigned int v4; // edx
int v5; // eax
v4 = 1;
if ( a1 != a2 )
{
v5 = a2 - a1;
v4 = 0;
if ( a3 * (a2 - a1) > 0 )
{
v4 = v5 % a3;
LOBYTE(v4) = v5 % a3 == 0;
}
}
return v4;
} | func0:
ENDBR64
MOV EAX,ESI
MOV ECX,EDX
MOV EDX,0x1
CMP EDI,ESI
JZ 0x00101152
SUB EAX,EDI
MOV ESI,EAX
IMUL ESI,ECX
MOV EDX,0x0
TEST ESI,ESI
JLE 0x00101152
CDQ
IDIV ECX
TEST EDX,EDX
SETZ DL
LAB_00101152:
MOV EAX,EDX
RET | /* func0(int, int, int) */
ulong func0(int param_1,int param_2,int param_3)
{
long lVar1;
ulong uVar2;
uVar2 = 1;
if (param_1 != param_2) {
uVar2 = 0;
if (0 < (param_2 - param_1) * param_3) {
lVar1 = (long)(param_2 - param_1) % (long)param_3;
uVar2 = CONCAT71((int7)((ulong)lVar1 >> 8),(int)lVar1 == 0) & 0xffffffff;
}
}
return uVar2;
} |
598 | func0 |
#include <assert.h>
| bool func0(int a, int b, int c) {
if (a == b) {
return true;
}
if ((b - a) * c > 0 && (b - a) % c == 0) {
return true;
}
return false;
}
| int main() {
assert(func0(1, 7, 3) == true);
assert(func0(1, -3, 5) == false);
assert(func0(3, 2, 5) == false);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
mov %esi,%eax
mov %edx,%ecx
mov $0x1,%r8d
cmp %esi,%edi
je 1169 <_Z5func0iii+0x29>
sub %edi,%eax
xor %r8d,%r8d
mov %eax,%edx
imul %ecx,%edx
test %edx,%edx
jle 1169 <_Z5func0iii+0x29>
cltd
idiv %ecx
test %edx,%edx
sete %r8b
mov %r8d,%eax
retq
nopl (%rax)
| _Z5func0iii:
endbr64
mov ecx, edx
mov eax, esi
mov edx, 1
cmp edi, esi
jz short loc_1166
sub eax, edi
xor edx, edx
mov esi, eax
imul esi, ecx
test esi, esi
jle short loc_1166
cdq
idiv ecx
test edx, edx
setz dl
loc_1166:
mov eax, edx
retn | long long func0(int a1, int a2, int a3)
{
unsigned int v4; // edx
int v5; // eax
v4 = 1;
if ( a1 != a2 )
{
v5 = a2 - a1;
v4 = 0;
if ( a3 * (a2 - a1) > 0 )
{
v4 = v5 % a3;
LOBYTE(v4) = v5 % a3 == 0;
}
}
return v4;
} | func0:
ENDBR64
MOV ECX,EDX
MOV EAX,ESI
MOV EDX,0x1
CMP EDI,ESI
JZ 0x00101166
SUB EAX,EDI
XOR EDX,EDX
MOV ESI,EAX
IMUL ESI,ECX
TEST ESI,ESI
JLE 0x00101166
CDQ
IDIV ECX
TEST EDX,EDX
SETZ DL
LAB_00101166:
MOV EAX,EDX
RET | /* func0(int, int, int) */
ulong func0(int param_1,int param_2,int param_3)
{
long lVar1;
ulong uVar2;
uVar2 = 1;
if (param_1 != param_2) {
uVar2 = 0;
if (0 < (param_2 - param_1) * param_3) {
lVar1 = (long)(param_2 - param_1) % (long)param_3;
uVar2 = CONCAT71((int7)((ulong)lVar1 >> 8),(int)lVar1 == 0) & 0xffffffff;
}
}
return uVar2;
} |
599 | func0 |
#include <assert.h>
| bool func0(int a, int b, int c) {
if (a == b) {
return true;
}
if ((b - a) * c > 0 && (b - a) % c == 0) {
return true;
}
return false;
}
| int main() {
assert(func0(1, 7, 3) == true);
assert(func0(1, -3, 5) == false);
assert(func0(3, 2, 5) == false);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
mov %esi,%eax
mov %edx,%ecx
mov $0x1,%r8d
cmp %esi,%edi
je 1169 <_Z5func0iii+0x29>
sub %edi,%eax
xor %r8d,%r8d
mov %eax,%edx
imul %ecx,%edx
test %edx,%edx
jle 1169 <_Z5func0iii+0x29>
cltd
idiv %ecx
test %edx,%edx
sete %r8b
mov %r8d,%eax
retq
nopl (%rax)
| _Z5func0iii:
endbr64
mov ecx, edx
mov eax, esi
mov edx, 1
cmp edi, esi
jz short loc_1166
sub eax, edi
xor edx, edx
mov esi, eax
imul esi, ecx
test esi, esi
jle short loc_1166
cdq
idiv ecx
test edx, edx
setz dl
loc_1166:
mov eax, edx
retn | long long func0(int a1, int a2, int a3)
{
unsigned int v4; // edx
int v5; // eax
v4 = 1;
if ( a1 != a2 )
{
v5 = a2 - a1;
v4 = 0;
if ( a3 * (a2 - a1) > 0 )
{
v4 = v5 % a3;
LOBYTE(v4) = v5 % a3 == 0;
}
}
return v4;
} | func0:
ENDBR64
MOV ECX,EDX
MOV EAX,ESI
MOV EDX,0x1
CMP EDI,ESI
JZ 0x00101166
SUB EAX,EDI
XOR EDX,EDX
MOV ESI,EAX
IMUL ESI,ECX
TEST ESI,ESI
JLE 0x00101166
CDQ
IDIV ECX
TEST EDX,EDX
SETZ DL
LAB_00101166:
MOV EAX,EDX
RET | /* func0(int, int, int) */
ulong func0(int param_1,int param_2,int param_3)
{
long lVar1;
ulong uVar2;
uVar2 = 1;
if (param_1 != param_2) {
uVar2 = 0;
if (0 < (param_2 - param_1) * param_3) {
lVar1 = (long)(param_2 - param_1) % (long)param_3;
uVar2 = CONCAT71((int7)((ulong)lVar1 >> 8),(int)lVar1 == 0) & 0xffffffff;
}
}
return uVar2;
} |
600 | func0 |
#include <assert.h>
| bool func0(int p, int q) {
while (q != 0) {
int temp = q;
q = p % q;
p = temp;
}
return p == 1;
}
| int main() {
assert(func0(17, 13) == true);
assert(func0(15, 21) == false);
assert(func0(25, 45) == false);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
cmpl $0x0,-0x18(%rbp)
je 1175 <_Z5func0ii+0x2c>
mov -0x18(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x18(%rbp)
mov %edx,-0x18(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0x14(%rbp)
jmp 1157 <_Z5func0ii+0xe>
cmpl $0x1,-0x14(%rbp)
sete %al
pop %rbp
retq
| _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
jmp short loc_116F
loc_1159:
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_18]
mov [rbp+var_18], edx
mov eax, [rbp+var_4]
mov [rbp+var_14], eax
loc_116F:
cmp [rbp+var_18], 0
jnz short loc_1159
cmp [rbp+var_14], 1
setz al
pop rbp
retn | bool func0(int a1, int a2)
{
int v5; // [rsp+14h] [rbp-4h]
while ( a2 )
{
v5 = a2;
a2 = a1 % a2;
a1 = v5;
}
return a1 == 1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
JMP 0x0010116f
LAB_00101159:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x18],EDX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x14],EAX
LAB_0010116f:
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x00101159
CMP dword ptr [RBP + -0x14],0x1
SETZ AL
POP RBP
RET | /* func0(int, int) */
bool func0(int param_1,int param_2)
{
int iVar1;
int4 local_20;
int4 local_1c;
local_20 = param_2;
local_1c = param_1;
while (local_20 != 0) {
iVar1 = local_1c % local_20;
local_1c = local_20;
local_20 = iVar1;
}
return local_1c == 1;
} |
601 | func0 |
#include <assert.h>
| bool func0(int p, int q) {
while (q != 0) {
int temp = q;
q = p % q;
p = temp;
}
return p == 1;
}
| int main() {
assert(func0(17, 13) == true);
assert(func0(15, 21) == false);
assert(func0(25, 45) == false);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
mov %edi,%eax
test %esi,%esi
je 1167 <_Z5func0ii+0x1e>
mov %esi,%ecx
cltd
idiv %esi
mov %edx,%esi
mov %ecx,%eax
test %edx,%edx
jne 1153 <_Z5func0ii+0xa>
cmp $0x1,%ecx
sete %al
retq
mov %edi,%ecx
jmp 1160 <_Z5func0ii+0x17>
| _Z5func0ii:
endbr64
mov eax, edi
test esi, esi
jz short loc_1167
loc_1153:
mov ecx, esi
cdq
idiv esi
mov esi, edx
mov eax, ecx
test edx, edx
jnz short loc_1153
loc_1160:
cmp ecx, 1
setz al
retn
loc_1167:
mov ecx, edi
jmp short loc_1160 | bool func0(int a1, int a2)
{
int v2; // eax
int v3; // ecx
v2 = a1;
if ( a2 )
{
do
{
v3 = a2;
a2 = v2 % a2;
v2 = v3;
}
while ( a2 );
}
else
{
v3 = a1;
}
return v3 == 1;
} | func0:
ENDBR64
MOV EAX,EDI
TEST ESI,ESI
JZ 0x00101167
LAB_00101153:
MOV ECX,ESI
CDQ
IDIV ESI
MOV ESI,EDX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101153
LAB_00101160:
CMP ECX,0x1
SETZ AL
RET
LAB_00101167:
MOV ECX,EDI
JMP 0x00101160 | /* func0(int, int) */
int8 func0(int param_1,int param_2)
{
ulong uVar1;
uVar1 = (ulong)(uint)param_1;
if (param_2 != 0) {
do {
param_1 = param_2;
param_2 = (int)uVar1 % param_1;
uVar1 = (ulong)(uint)param_1;
} while (param_2 != 0);
}
return CONCAT71((int7)(uVar1 >> 8),param_1 == 1);
} |
602 | func0 |
#include <assert.h>
| bool func0(int p, int q) {
while (q != 0) {
int temp = q;
q = p % q;
p = temp;
}
return p == 1;
}
| int main() {
assert(func0(17, 13) == true);
assert(func0(15, 21) == false);
assert(func0(25, 45) == false);
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
mov %edi,%eax
mov %esi,%edx
test %esi,%esi
je 1248 <_Z5func0ii+0x28>
nopl 0x0(%rax)
mov %edx,%ecx
cltd
idiv %ecx
mov %ecx,%eax
test %edx,%edx
jne 1230 <_Z5func0ii+0x10>
cmp $0x1,%ecx
sete %al
retq
nopw 0x0(%rax,%rax,1)
mov %edi,%ecx
cmp $0x1,%ecx
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
mov eax, edi
mov edx, esi
test esi, esi
jz short loc_1248
nop dword ptr [rax+00h]
loc_1230:
mov ecx, edx
cdq
idiv ecx
mov eax, ecx
test edx, edx
jnz short loc_1230
cmp ecx, 1
setz al
retn
loc_1248:
mov ecx, edi
cmp ecx, 1
setz al
retn | bool func0(int a1, int a2)
{
int v2; // eax
int v3; // edx
int v4; // ecx
v2 = a1;
v3 = a2;
if ( !a2 )
return a1 == 1;
do
{
v4 = v3;
v3 = v2 % v3;
v2 = v4;
}
while ( v3 );
return v4 == 1;
} | func0:
ENDBR64
MOV EAX,EDI
MOV EDX,ESI
TEST ESI,ESI
JZ 0x00101248
NOP dword ptr [RAX]
LAB_00101230:
MOV ECX,EDX
CDQ
IDIV ECX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101230
CMP ECX,0x1
SETZ AL
RET
LAB_00101248:
MOV ECX,EDI
CMP ECX,0x1
SETZ AL
RET | /* func0(int, int) */
bool func0(int param_1,int param_2)
{
int iVar1;
if (param_2 != 0) {
do {
iVar1 = param_2;
param_2 = param_1 % iVar1;
param_1 = iVar1;
} while (param_2 != 0);
return iVar1 == 1;
}
return param_1 == 1;
} |
603 | func0 |
#include <assert.h>
| bool func0(int p, int q) {
while (q != 0) {
int temp = q;
q = p % q;
p = temp;
}
return p == 1;
}
| int main() {
assert(func0(17, 13) == true);
assert(func0(15, 21) == false);
assert(func0(25, 45) == false);
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
mov %edi,%eax
mov %esi,%edx
test %esi,%esi
je 1248 <_Z5func0ii+0x28>
nopl 0x0(%rax)
mov %edx,%ecx
cltd
idiv %ecx
mov %ecx,%eax
test %edx,%edx
jne 1230 <_Z5func0ii+0x10>
cmp $0x1,%ecx
sete %al
retq
nopw 0x0(%rax,%rax,1)
mov %edi,%ecx
cmp $0x1,%ecx
sete %al
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
mov eax, edi
mov edx, esi
test esi, esi
jz short loc_1248
nop dword ptr [rax+00h]
loc_1230:
mov ecx, edx
cdq
idiv ecx
mov eax, ecx
test edx, edx
jnz short loc_1230
cmp ecx, 1
setz al
retn
loc_1248:
mov ecx, edi
cmp ecx, 1
setz al
retn | bool func0(int a1, int a2)
{
int v2; // eax
int v3; // edx
int v4; // ecx
v2 = a1;
v3 = a2;
if ( !a2 )
return a1 == 1;
do
{
v4 = v3;
v3 = v2 % v3;
v2 = v4;
}
while ( v3 );
return v4 == 1;
} | func0:
ENDBR64
MOV EAX,EDI
MOV EDX,ESI
TEST ESI,ESI
JZ 0x00101248
NOP dword ptr [RAX]
LAB_00101230:
MOV ECX,EDX
CDQ
IDIV ECX
MOV EAX,ECX
TEST EDX,EDX
JNZ 0x00101230
CMP ECX,0x1
SETZ AL
RET
LAB_00101248:
MOV ECX,EDI
CMP ECX,0x1
SETZ AL
RET | /* func0(int, int) */
bool func0(int param_1,int param_2)
{
int iVar1;
if (param_2 != 0) {
do {
iVar1 = param_2;
param_2 = param_1 % iVar1;
param_1 = iVar1;
} while (param_2 != 0);
return iVar1 == 1;
}
return param_1 == 1;
} |
604 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
std::vector<int> merge(std::vector<int> a, std::vector<int> b) {
std::vector<int> c;
while (!a.empty() && !b.empty()) {
if (a.front() < b.front()) {
c.push_back(a.front());
a.erase(a.begin());
} else {
c.push_back(b.front());
b.erase(b.begin());
}
}
if (a.empty()) {
c.insert(c.end(), b.begin(), b.end());
} else {
c.insert(c.end(), a.begin(), a.end());
}
return c;
}
| std::vector<int> func0(std::vector<int> x) {
if (x.size() == 0 || x.size() == 1) {
return x;
} else {
int middle = x.size() / 2;
std::vector<int> a = func0(std::vector<int>(x.begin(), x.begin() + middle));
std::vector<int> b = func0(std::vector<int>(x.begin() + middle, x.end()));
return merge(a, b);
}
}
| int main() {
std::vector<int> v1 = {3, 4, 2, 6, 5, 7, 1, 9};
std::vector<int> r1 = {1, 2, 3, 4, 5, 6, 7, 9};
assert(func0(v1) == r1);
std::vector<int> v2 = {7, 25, 45, 78, 11, 33, 19};
std::vector<int> r2 = {7, 11, 19, 25, 33, 45, 78};
assert(func0(v2) == r2);
std::vector<int> v3 = {3, 1, 4, 9, 8};
std::vector<int> r3 = {1, 3, 4, 8, 9};
assert(func0(v3) == r3);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0xa0,%rsp
mov %rdi,-0xa8(%rbp)
mov %rsi,-0xb0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0xb0(%rbp),%rax
mov %rax,%rdi
callq 2526 <_ZNKSt6vectorIiSaIiEE4sizeEv>
test %rax,%rax
je 1589 <_Z5func0St6vectorIiSaIiEE+0x58>
mov -0xb0(%rbp),%rax
mov %rax,%rdi
callq 2526 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp $0x1,%rax
jne 1590 <_Z5func0St6vectorIiSaIiEE+0x5f>
mov $0x1,%eax
jmp 1595 <_Z5func0St6vectorIiSaIiEE+0x64>
mov $0x0,%eax
test %al,%al
je 15b7 <_Z5func0St6vectorIiSaIiEE+0x86>
mov -0xb0(%rbp),%rdx
mov -0xa8(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2060 <_ZNSt6vectorIiSaIiEEC1EOS1_>
jmpq 182d <_Z5func0St6vectorIiSaIiEE+0x2fc>
mov -0xb0(%rbp),%rax
mov %rax,%rdi
callq 2526 <_ZNKSt6vectorIiSaIiEE4sizeEv>
shr %rax
mov %eax,-0x94(%rbp)
lea -0x70(%rbp),%rax
mov %rax,%rdi
callq 25b4 <_ZNSaIiEC1Ev>
mov -0x94(%rbp),%eax
movslq %eax,%rbx
mov -0xb0(%rbp),%rax
mov %rax,%rdi
callq 22aa <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x50(%rbp)
lea -0x50(%rbp),%rax
mov %rbx,%rsi
mov %rax,%rdi
callq 254e <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEplEl>
mov %rax,%rbx
mov -0xb0(%rbp),%rax
mov %rax,%rdi
callq 22aa <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rax,%rsi
lea -0x70(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rcx
mov %rbx,%rdx
mov %rax,%rdi
callq 25d4 <_ZNSt6vectorIiSaIiEEC1IN9__gnu_cxx17__normal_iteratorIPiS1_EEvEET_S7_RKS0_>
lea -0x90(%rbp),%rax
lea -0x30(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 1531 <_Z5func0St6vectorIiSaIiEE>
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
lea -0x70(%rbp),%rax
mov %rax,%rdi
callq 20b6 <_ZNSaIiED1Ev>
lea -0x95(%rbp),%rax
mov %rax,%rdi
callq 25b4 <_ZNSaIiEC1Ev>
mov -0xb0(%rbp),%rax
mov %rax,%rdi
callq 23ba <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,%r12
mov -0x94(%rbp),%eax
movslq %eax,%rbx
mov -0xb0(%rbp),%rax
mov %rax,%rdi
callq 22aa <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x50(%rbp)
lea -0x50(%rbp),%rax
mov %rbx,%rsi
mov %rax,%rdi
callq 254e <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEplEl>
mov %rax,%rsi
lea -0x95(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rcx
mov %r12,%rdx
mov %rax,%rdi
callq 25d4 <_ZNSt6vectorIiSaIiEEC1IN9__gnu_cxx17__normal_iteratorIPiS1_EEvEET_S7_RKS0_>
lea -0x70(%rbp),%rax
lea -0x30(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 1531 <_Z5func0St6vectorIiSaIiEE>
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
lea -0x95(%rbp),%rax
mov %rax,%rdi
callq 20b6 <_ZNSaIiED1Ev>
lea -0x70(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2672 <_ZNSt6vectorIiSaIiEEC1ERKS1_>
lea -0x90(%rbp),%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2672 <_ZNSt6vectorIiSaIiEEC1ERKS1_>
mov -0xa8(%rbp),%rax
lea -0x30(%rbp),%rdx
lea -0x50(%rbp),%rcx
mov %rcx,%rsi
mov %rax,%rdi
callq 12e9 <_Z5mergeSt6vectorIiSaIiEES1_>
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
lea -0x70(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
lea -0x90(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
jmpq 182d <_Z5func0St6vectorIiSaIiEE+0x2fc>
endbr64
mov %rax,%rbx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
jmp 178c <_Z5func0St6vectorIiSaIiEE+0x25b>
endbr64
mov %rax,%rbx
lea -0x70(%rbp),%rax
mov %rax,%rdi
callq 20b6 <_ZNSaIiED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 11f0 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
jmp 17c2 <_Z5func0St6vectorIiSaIiEE+0x291>
endbr64
mov %rax,%rbx
lea -0x95(%rbp),%rax
mov %rax,%rdi
callq 20b6 <_ZNSaIiED1Ev>
jmp 1813 <_Z5func0St6vectorIiSaIiEE+0x2e2>
endbr64
mov %rax,%rbx
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
jmp 17f2 <_Z5func0St6vectorIiSaIiEE+0x2c1>
endbr64
mov %rax,%rbx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
jmp 1807 <_Z5func0St6vectorIiSaIiEE+0x2d6>
endbr64
mov %rax,%rbx
lea -0x70(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
lea -0x90(%rbp),%rax
mov %rax,%rdi
callq 2128 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 11f0 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 1841 <_Z5func0St6vectorIiSaIiEE+0x310>
callq 11a0 <__stack_chk_fail@plt>
mov -0xa8(%rbp),%rax
add $0xa0,%rsp
pop %rbx
pop %r12
pop %rbp
retq
| _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 0B0h
mov [rbp+var_B8], rdi
mov [rbp+var_C0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_C0]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
test rax, rax
jz short loc_157D
mov rax, [rbp+var_C0]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
cmp rax, 1
jnz short loc_1584
loc_157D:
mov eax, 1
jmp short loc_1589
loc_1584:
mov eax, 0
loc_1589:
test al, al
jz short loc_15AB
mov rdx, [rbp+var_C0]
mov rax, [rbp+var_B8]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2EOS1_; std::vector<int>::vector(std::vector<int>&&)
jmp loc_1849
loc_15AB:
mov rax, [rbp+var_C0]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
shr rax, 1
mov [rbp+var_A4], eax
lea rax, [rbp+var_70]
mov [rbp+var_A0], rax
nop
nop
mov eax, [rbp+var_A4]
movsxd rbx, eax
mov rax, [rbp+var_C0]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_50], rax
lea rax, [rbp+var_50]
mov rsi, rbx
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEplEl; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator+(long)
mov rbx, rax
mov rax, [rbp+var_C0]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov rsi, rax
lea rdx, [rbp+var_70]
lea rax, [rbp+var_30]
mov rcx, rdx
mov rdx, rbx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2IN9__gnu_cxx17__normal_iteratorIPiS1_EEvEET_S7_RKS0_; std::vector<int>::vector<__gnu_cxx::__normal_iterator<int *,std::vector<int>>,void>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,__gnu_cxx::__normal_iterator<int *,std::vector<int>>,std::allocator<int> const&)
lea rax, [rbp+var_90]
lea rdx, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _Z5func0St6vectorIiSaIiEE; func0(std::vector<int>)
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
lea rax, [rbp+var_70]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
lea rax, [rbp+var_A5]
mov [rbp+var_98], rax
nop
nop
mov rax, [rbp+var_C0]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov r12, rax
mov eax, [rbp+var_A4]
movsxd rbx, eax
mov rax, [rbp+var_C0]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_50], rax
lea rax, [rbp+var_50]
mov rsi, rbx
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEplEl; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator+(long)
mov rsi, rax
lea rdx, [rbp+var_A5]
lea rax, [rbp+var_30]
mov rcx, rdx
mov rdx, r12
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2IN9__gnu_cxx17__normal_iteratorIPiS1_EEvEET_S7_RKS0_; std::vector<int>::vector<__gnu_cxx::__normal_iterator<int *,std::vector<int>>,void>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,__gnu_cxx::__normal_iterator<int *,std::vector<int>>,std::allocator<int> const&)
lea rax, [rbp+var_70]
lea rdx, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _Z5func0St6vectorIiSaIiEE; func0(std::vector<int>)
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
lea rax, [rbp+var_A5]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
lea rdx, [rbp+var_70]
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2ERKS1_; std::vector<int>::vector(std::vector<int> const&)
lea rdx, [rbp+var_90]
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2ERKS1_; std::vector<int>::vector(std::vector<int> const&)
mov rax, [rbp+var_B8]
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_50]
mov rsi, rcx
mov rdi, rax
call _Z5mergeSt6vectorIiSaIiEES1_; merge(std::vector<int>,std::vector<int>)
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
lea rax, [rbp+var_70]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
lea rax, [rbp+var_90]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp loc_1849
endbr64
mov rbx, rax
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp short loc_1784
endbr64
mov rbx, rax
loc_1784:
lea rax, [rbp+var_70]
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_17A8
call ___stack_chk_fail
loc_17A8:
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()
jmp short loc_17CC
endbr64
mov rbx, rax
loc_17CC:
lea rax, [rbp+var_A5]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
jmp short loc_181B
endbr64
mov rbx, rax
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp short loc_17FA
endbr64
mov rbx, rax
loc_17FA:
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp short loc_180F
endbr64
mov rbx, rax
loc_180F:
lea rax, [rbp+var_70]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
loc_181B:
lea rax, [rbp+var_90]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1841
call ___stack_chk_fail
loc_1841:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1849:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_185D
call ___stack_chk_fail
loc_185D:
mov rax, [rbp+var_B8]
add rsp, 0B0h
pop rbx
pop r12
pop rbp
retn | long long func0(long long a1, long long a2)
{
long long v3; // rbx
long long v4; // rax
long long v5; // r12
long long v6; // rbx
long long v7; // rax
char v9; // [rsp+1Bh] [rbp-A5h] BYREF
int v10; // [rsp+1Ch] [rbp-A4h]
_BYTE *v11; // [rsp+20h] [rbp-A0h]
char *v12; // [rsp+28h] [rbp-98h]
_BYTE v13[32]; // [rsp+30h] [rbp-90h] BYREF
_BYTE v14[32]; // [rsp+50h] [rbp-70h] BYREF
_QWORD v15[4]; // [rsp+70h] [rbp-50h] BYREF
_BYTE v16[24]; // [rsp+90h] [rbp-30h] BYREF
unsigned long long v17; // [rsp+A8h] [rbp-18h]
v17 = __readfsqword(0x28u);
if ( !std::vector<int>::size(a2) || std::vector<int>::size(a2) == 1 )
{
std::vector<int>::vector(a1, a2);
}
else
{
v10 = (unsigned long long)std::vector<int>::size(a2) >> 1;
v11 = v14;
v15[0] = std::vector<int>::begin(a2);
v3 = __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator+(v15, v10);
v4 = std::vector<int>::begin(a2);
std::vector<int>::vector<__gnu_cxx::__normal_iterator<int *,std::vector<int>>,void>(v16, v4, v3, v14);
func0(v13, v16);
std::vector<int>::~vector(v16);
std::__new_allocator<int>::~__new_allocator(v14);
v12 = &v9;
v5 = std::vector<int>::end(a2);
v6 = v10;
v15[0] = std::vector<int>::begin(a2);
v7 = __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator+(v15, v6);
std::vector<int>::vector<__gnu_cxx::__normal_iterator<int *,std::vector<int>>,void>(v16, v7, v5, &v9);
func0(v14, v16);
std::vector<int>::~vector(v16);
std::__new_allocator<int>::~__new_allocator(&v9);
std::vector<int>::vector(v16, v14);
std::vector<int>::vector(v15, v13);
merge(a1, v15, v16);
std::vector<int>::~vector(v15);
std::vector<int>::~vector(v16);
std::vector<int>::~vector(v14);
std::vector<int>::~vector(v13);
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0xb0
MOV qword ptr [RBP + -0xb8],RDI
MOV qword ptr [RBP + -0xc0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0xc0]
MOV RDI,RAX
CALL 0x00102568
TEST RAX,RAX
JZ 0x0010157d
MOV RAX,qword ptr [RBP + -0xc0]
MOV RDI,RAX
CALL 0x00102568
CMP RAX,0x1
JNZ 0x00101584
LAB_0010157d:
MOV EAX,0x1
JMP 0x00101589
LAB_00101584:
MOV EAX,0x0
LAB_00101589:
TEST AL,AL
JZ 0x001015ab
MOV RDX,qword ptr [RBP + -0xc0]
MOV RAX,qword ptr [RBP + -0xb8]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102052
JMP 0x00101849
LAB_001015ab:
MOV RAX,qword ptr [RBP + -0xc0]
MOV RDI,RAX
CALL 0x00102568
SHR RAX,0x1
MOV dword ptr [RBP + -0xa4],EAX
LEA RAX,[RBP + -0x70]
MOV qword ptr [RBP + -0xa0],RAX
NOP
NOP
MOV EAX,dword ptr [RBP + -0xa4]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0xc0]
MOV RDI,RAX
CALL 0x001022e0
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[RBP + -0x50]
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00102590
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0xc0]
MOV RDI,RAX
CALL 0x001022e0
MOV RSI,RAX
LEA RDX,[RBP + -0x70]
LEA RAX,[RBP + -0x30]
MOV RCX,RDX
MOV RDX,RBX
MOV RDI,RAX
LAB_00101621:
CALL 0x001025f6
LEA RAX,[RBP + -0x90]
LEA RDX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
LAB_00101637:
CALL 0x00101525
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00102100
LEA RAX,[RBP + -0x70]
MOV RDI,RAX
CALL 0x00102984
NOP
LEA RAX,[RBP + -0xa5]
MOV qword ptr [RBP + -0x98],RAX
NOP
NOP
MOV RAX,qword ptr [RBP + -0xc0]
MOV RDI,RAX
CALL 0x001023f0
MOV R12,RAX
MOV EAX,dword ptr [RBP + -0xa4]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0xc0]
MOV RDI,RAX
CALL 0x001022e0
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[RBP + -0x50]
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00102590
MOV RSI,RAX
LEA RDX,[RBP + -0xa5]
LEA RAX,[RBP + -0x30]
MOV RCX,RDX
MOV RDX,R12
MOV RDI,RAX
LAB_001016b9:
CALL 0x001025f6
LEA RAX,[RBP + -0x70]
LEA RDX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
LAB_001016cc:
CALL 0x00101525
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00102100
LEA RAX,[RBP + -0xa5]
MOV RDI,RAX
CALL 0x00102984
NOP
LEA RDX,[RBP + -0x70]
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
LAB_001016fb:
CALL 0x0010269c
LEA RDX,[RBP + -0x90]
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
LAB_00101711:
CALL 0x0010269c
MOV RAX,qword ptr [RBP + -0xb8]
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x50]
MOV RSI,RCX
MOV RDI,RAX
LAB_0010172b:
CALL 0x001012c9
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00102100
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00102100
LEA RAX,[RBP + -0x70]
MOV RDI,RAX
CALL 0x00102100
LEA RAX,[RBP + -0x90]
MOV RDI,RAX
CALL 0x00102100
JMP 0x00101849
LAB_00101849:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010185d
CALL 0x00101190
LAB_0010185d:
MOV RAX,qword ptr [RBP + -0xb8]
ADD RSP,0xb0
POP RBX
POP R12
POP RBP
RET | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
bool bVar1;
long lVar2;
ulong uVar3;
int8 uVar4;
int8 uVar5;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
long in_FS_OFFSET;
__new_allocator<int> local_ad;
int local_ac;
__new_allocator<int> *local_a8;
__new_allocator<int> *local_a0;
vector<int,std::allocator<int>> local_98 [32];
__new_allocator<int> local_78 [32];
int8 local_58 [4];
vector<int,std::allocator<int>> local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
lVar2 = std::vector<int,std::allocator<int>>::size(in_RSI);
if (lVar2 != 0) {
lVar2 = std::vector<int,std::allocator<int>>::size(in_RSI);
if (lVar2 != 1) {
bVar1 = false;
goto LAB_00101589;
}
}
bVar1 = true;
LAB_00101589:
if (bVar1) {
std::vector<int,std::allocator<int>>::vector
((vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1),
(vector *)in_RSI);
}
else {
uVar3 = std::vector<int,std::allocator<int>>::size(in_RSI);
local_ac = (int)(uVar3 >> 1);
local_a8 = local_78;
lVar2 = (long)local_ac;
local_58[0] = std::vector<int,std::allocator<int>>::begin(in_RSI);
uVar4 = __normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator+
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)local_58,
lVar2);
uVar5 = std::vector<int,std::allocator<int>>::begin(in_RSI);
/* try { // try from 00101621 to 00101625 has its CatchHandler @ 0010177d */
std::vector<int,std::allocator<int>>::
vector<__normal_iterator<int*,std::vector<int,std::allocator<int>>>,void>
(local_38,uVar5,uVar4,local_78);
/* try { // try from 00101637 to 0010163b has its CatchHandler @ 00101768 */
func0((vector)local_98);
std::vector<int,std::allocator<int>>::~vector(local_38);
std::__new_allocator<int>::~__new_allocator(local_78);
local_a0 = &local_ad;
uVar4 = std::vector<int,std::allocator<int>>::end(in_RSI);
lVar2 = (long)local_ac;
local_58[0] = std::vector<int,std::allocator<int>>::begin(in_RSI);
uVar5 = __normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator+
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)local_58,
lVar2);
/* try { // try from 001016b9 to 001016bd has its CatchHandler @ 001017c5 */
std::vector<int,std::allocator<int>>::
vector<__normal_iterator<int*,std::vector<int,std::allocator<int>>>,void>
(local_38,uVar5,uVar4,&local_ad);
/* try { // try from 001016cc to 001016d0 has its CatchHandler @ 001017b0 */
func0((vector)local_78);
std::vector<int,std::allocator<int>>::~vector(local_38);
std::__new_allocator<int>::~__new_allocator(&local_ad);
/* try { // try from 001016fb to 001016ff has its CatchHandler @ 00101808 */
std::vector<int,std::allocator<int>>::vector(local_38,(vector *)local_78);
/* try { // try from 00101711 to 00101715 has its CatchHandler @ 001017f3 */
std::vector<int,std::allocator<int>>::vector
((vector<int,std::allocator<int>> *)local_58,(vector *)local_98);
/* try { // try from 0010172b to 0010172f has its CatchHandler @ 001017de */
merge(param_1,(vector)local_58);
std::vector<int,std::allocator<int>>::~vector((vector<int,std::allocator<int>> *)local_58);
std::vector<int,std::allocator<int>>::~vector(local_38);
std::vector<int,std::allocator<int>>::~vector((vector<int,std::allocator<int>> *)local_78);
std::vector<int,std::allocator<int>>::~vector(local_98);
}
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);
} |
605 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
std::vector<int> merge(std::vector<int> a, std::vector<int> b) {
std::vector<int> c;
while (!a.empty() && !b.empty()) {
if (a.front() < b.front()) {
c.push_back(a.front());
a.erase(a.begin());
} else {
c.push_back(b.front());
b.erase(b.begin());
}
}
if (a.empty()) {
c.insert(c.end(), b.begin(), b.end());
} else {
c.insert(c.end(), a.begin(), a.end());
}
return c;
}
| std::vector<int> func0(std::vector<int> x) {
if (x.size() == 0 || x.size() == 1) {
return x;
} else {
int middle = x.size() / 2;
std::vector<int> a = func0(std::vector<int>(x.begin(), x.begin() + middle));
std::vector<int> b = func0(std::vector<int>(x.begin() + middle, x.end()));
return merge(a, b);
}
}
| int main() {
std::vector<int> v1 = {3, 4, 2, 6, 5, 7, 1, 9};
std::vector<int> r1 = {1, 2, 3, 4, 5, 6, 7, 9};
assert(func0(v1) == r1);
std::vector<int> v2 = {7, 25, 45, 78, 11, 33, 19};
std::vector<int> r2 = {7, 11, 19, 25, 33, 45, 78};
assert(func0(v2) == r2);
std::vector<int> v3 = {3, 1, 4, 9, 8};
std::vector<int> r3 = {1, 3, 4, 8, 9};
assert(func0(v3) == r3);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
add $0xffffffffffffff80,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
mov 0x8(%rsi),%rdx
mov (%rsi),%r12
mov %rdx,%rax
sub %r12,%rax
cmp $0x4,%rax
je 1432 <_Z5func0St6vectorIiSaIiEE+0x8b>
cmp %r12,%rdx
je 1432 <_Z5func0St6vectorIiSaIiEE+0x8b>
shl $0x1d,%rax
sar $0x20,%rax
lea 0x0(,%rax,4),%r13
movq $0x0,0x60(%rsp)
movq $0x0,0x68(%rsp)
movq $0x0,0x70(%rsp)
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 147d <_Z5func0St6vectorIiSaIiEE+0xd6>
test %rax,%rax
je 14dc <_Z5func0St6vectorIiSaIiEE+0x135>
mov %r13,%rdi
callq 1170 <_Znwm@plt>
jmp 14a7 <_Z5func0St6vectorIiSaIiEE+0x100>
mov %r12,0x0(%rbp)
mov %rdx,0x8(%rbp)
mov 0x10(%rbx),%rax
mov %rax,0x10(%rbp)
movq $0x0,0x10(%rbx)
movq $0x0,0x8(%rbx)
movq $0x0,(%rbx)
mov 0x78(%rsp),%rax
xor %fs:0x28,%rax
jne 17cd <_Z5func0St6vectorIiSaIiEE+0x426>
mov %rbp,%rax
sub $0xffffffffffffff80,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
lea 0x1b84(%rip),%rdi
callq 1120 <_ZSt20__throw_length_errorPKc@plt>
endbr64
mov %rax,%rbx
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 149f <_Z5func0St6vectorIiSaIiEE+0xf8>
callq 1160 <_ZdlPv@plt>
mov %rbx,%rdi
callq 11b0 <_Unwind_Resume@plt>
mov %rax,%rdi
mov %rdi,0x60(%rsp)
lea (%rdi,%r13,1),%r14
mov %r14,0x70(%rsp)
test %r13,%r13
je 14c8 <_Z5func0St6vectorIiSaIiEE+0x121>
mov %r13,%rdx
mov %r12,%rsi
callq 1140 <memcpy@plt>
mov %r14,0x68(%rsp)
mov %rsp,%rdi
lea 0x60(%rsp),%rsi
callq 13a7 <_Z5func0St6vectorIiSaIiEE>
jmp 14e3 <_Z5func0St6vectorIiSaIiEE+0x13c>
mov $0x0,%edi
jmp 14aa <_Z5func0St6vectorIiSaIiEE+0x103>
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 14f2 <_Z5func0St6vectorIiSaIiEE+0x14b>
callq 1160 <_ZdlPv@plt>
mov 0x8(%rbx),%r12
add (%rbx),%r13
movq $0x0,0x60(%rsp)
movq $0x0,0x68(%rsp)
movq $0x0,0x70(%rsp)
mov %r12,%rbx
sub %r13,%rbx
mov %rbx,%rax
sar $0x2,%rax
test %rbx,%rbx
js 1535 <_Z5func0St6vectorIiSaIiEE+0x18e>
test %rax,%rax
je 15a4 <_Z5func0St6vectorIiSaIiEE+0x1fd>
mov %rbx,%rdi
callq 1170 <_Znwm@plt>
jmp 156d <_Z5func0St6vectorIiSaIiEE+0x1c6>
lea 0x1acc(%rip),%rdi
callq 1120 <_ZSt20__throw_length_errorPKc@plt>
endbr64
mov %rax,%rbx
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 1557 <_Z5func0St6vectorIiSaIiEE+0x1b0>
callq 1160 <_ZdlPv@plt>
mov (%rsp),%rdi
test %rdi,%rdi
je 1565 <_Z5func0St6vectorIiSaIiEE+0x1be>
callq 1160 <_ZdlPv@plt>
mov %rbx,%rdi
callq 11b0 <_Unwind_Resume@plt>
mov %rax,%rdi
mov %rdi,0x60(%rsp)
lea (%rdi,%rbx,1),%r14
mov %r14,0x70(%rsp)
cmp %r12,%r13
je 158e <_Z5func0St6vectorIiSaIiEE+0x1e7>
mov %rbx,%rdx
mov %r13,%rsi
callq 1140 <memcpy@plt>
mov %r14,0x68(%rsp)
lea 0x20(%rsp),%rdi
lea 0x60(%rsp),%rsi
callq 13a7 <_Z5func0St6vectorIiSaIiEE>
jmp 15ab <_Z5func0St6vectorIiSaIiEE+0x204>
mov $0x0,%edi
jmp 1570 <_Z5func0St6vectorIiSaIiEE+0x1c9>
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 15ba <_Z5func0St6vectorIiSaIiEE+0x213>
callq 1160 <_ZdlPv@plt>
mov 0x28(%rsp),%r12
sub 0x20(%rsp),%r12
movq $0x0,0x60(%rsp)
movq $0x0,0x68(%rsp)
movq $0x0,0x70(%rsp)
mov %r12,%rax
sar $0x2,%rax
je 169d <_Z5func0St6vectorIiSaIiEE+0x2f6>
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 1605 <_Z5func0St6vectorIiSaIiEE+0x25e>
mov %r12,%rdi
callq 1170 <_Znwm@plt>
jmp 1616 <_Z5func0St6vectorIiSaIiEE+0x26f>
callq 1100 <_ZSt17__throw_bad_allocv@plt>
endbr64
mov %rax,%rbx
jmpq 17b5 <_Z5func0St6vectorIiSaIiEE+0x40e>
mov %rax,%rbx
mov %rbx,0x60(%rsp)
mov %rbx,0x68(%rsp)
add %rbx,%r12
mov %r12,0x70(%rsp)
mov 0x28(%rsp),%rax
mov 0x20(%rsp),%rsi
mov %rax,%r12
sub %rsi,%r12
cmp %rsi,%rax
je 164b <_Z5func0St6vectorIiSaIiEE+0x2a4>
mov %r12,%rdx
mov %rbx,%rdi
callq 11a0 <memmove@plt>
add %r12,%rbx
mov %rbx,0x68(%rsp)
mov 0x8(%rsp),%r12
sub (%rsp),%r12
movq $0x0,0x40(%rsp)
movq $0x0,0x48(%rsp)
movq $0x0,0x50(%rsp)
mov %r12,%rax
sar $0x2,%rax
je 1708 <_Z5func0St6vectorIiSaIiEE+0x361>
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 16a7 <_Z5func0St6vectorIiSaIiEE+0x300>
mov %r12,%rdi
callq 1170 <_Znwm@plt>
jmp 16b8 <_Z5func0St6vectorIiSaIiEE+0x311>
mov $0x0,%ebx
jmpq 1619 <_Z5func0St6vectorIiSaIiEE+0x272>
callq 1100 <_ZSt17__throw_bad_allocv@plt>
endbr64
mov %rax,%rbx
jmpq 17a6 <_Z5func0St6vectorIiSaIiEE+0x3ff>
mov %rax,%rbx
mov %rbx,0x40(%rsp)
mov %rbx,0x48(%rsp)
add %rbx,%r12
mov %r12,0x50(%rsp)
mov 0x8(%rsp),%rax
mov (%rsp),%rsi
mov %rax,%r12
sub %rsi,%r12
cmp %rsi,%rax
je 16ec <_Z5func0St6vectorIiSaIiEE+0x345>
mov %r12,%rdx
mov %rbx,%rdi
callq 11a0 <memmove@plt>
add %r12,%rbx
mov %rbx,0x48(%rsp)
lea 0x60(%rsp),%rdx
lea 0x40(%rsp),%rsi
mov %rbp,%rdi
callq 12a9 <_Z5mergeSt6vectorIiSaIiEES1_>
jmp 170f <_Z5func0St6vectorIiSaIiEE+0x368>
mov $0x0,%ebx
jmp 16bb <_Z5func0St6vectorIiSaIiEE+0x314>
mov 0x40(%rsp),%rdi
test %rdi,%rdi
je 171e <_Z5func0St6vectorIiSaIiEE+0x377>
callq 1160 <_ZdlPv@plt>
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 172d <_Z5func0St6vectorIiSaIiEE+0x386>
callq 1160 <_ZdlPv@plt>
mov 0x20(%rsp),%rdi
test %rdi,%rdi
je 173c <_Z5func0St6vectorIiSaIiEE+0x395>
callq 1160 <_ZdlPv@plt>
mov (%rsp),%rdi
test %rdi,%rdi
je 1459 <_Z5func0St6vectorIiSaIiEE+0xb2>
callq 1160 <_ZdlPv@plt>
jmpq 1459 <_Z5func0St6vectorIiSaIiEE+0xb2>
endbr64
mov %rax,%rbx
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 1769 <_Z5func0St6vectorIiSaIiEE+0x3c2>
callq 1160 <_ZdlPv@plt>
mov %rbx,%rdi
callq 11b0 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbx
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 1557 <_Z5func0St6vectorIiSaIiEE+0x1b0>
callq 1160 <_ZdlPv@plt>
jmpq 1557 <_Z5func0St6vectorIiSaIiEE+0x1b0>
endbr64
mov %rax,%rbx
mov 0x40(%rsp),%rdi
test %rdi,%rdi
je 17a6 <_Z5func0St6vectorIiSaIiEE+0x3ff>
callq 1160 <_ZdlPv@plt>
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 17b5 <_Z5func0St6vectorIiSaIiEE+0x40e>
callq 1160 <_ZdlPv@plt>
mov 0x20(%rsp),%rdi
test %rdi,%rdi
je 1557 <_Z5func0St6vectorIiSaIiEE+0x1b0>
callq 1160 <_ZdlPv@plt>
jmpq 1557 <_Z5func0St6vectorIiSaIiEE+0x1b0>
callq 1180 <__stack_chk_fail@plt>
| _Z5func0St6vectorIiSaIiEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
add rsp, 0FFFFFFFFFFFFFF80h
mov r12, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+0A8h+var_30], rax
xor eax, eax
mov rdx, [rsi+8]
mov r13, [rsi]
mov rax, rdx
sub rax, r13
cmp rax, 4
jz short loc_13F1
cmp r13, rdx
jz short loc_13F1
shl rax, 1Dh
sar rax, 20h
lea rbp, ds:0[rax*4]
mov [rsp+0A8h+var_48], 0
mov [rsp+0A8h+var_40], 0
mov [rsp+0A8h+var_38], 0
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbp
jb short loc_143E
test rbp, rbp
jz loc_184F
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
jmp loc_1485
loc_13F1:
mov [r12], r13
mov [r12+8], rdx
mov rax, [rbx+10h]
mov [r12+10h], rax
mov qword ptr [rbx+10h], 0
mov qword ptr [rbx+8], 0
mov qword ptr [rbx], 0
loc_141A:
mov rax, [rsp+0A8h+var_30]
sub rax, fs:28h
jnz loc_186C
mov rax, r12
sub rsp, 0FFFFFFFFFFFFFF80h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_143E:
mov rax, [rsp+0A8h+var_30]
sub rax, fs:28h
jnz short loc_1480
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
endbr64
mov rbx, rax
lea rdi, [rsp+0A8h+var_48]
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
mov rax, [rsp+0A8h+var_30]
sub rax, fs:28h
jz short loc_14C3
call ___stack_chk_fail
loc_1480:
call ___stack_chk_fail
loc_1485:
mov rdi, rax; dest
mov [rsp+0A8h+var_48], rax
lea r14, [rax+rbp]
mov [rsp+0A8h+var_38], r14
cmp rbp, 4
jle short loc_14BB
mov rdx, rbp; n
mov rsi, r13; src
call _memmove
loc_14A7:
mov [rsp+0A8h+var_40], r14
mov rdi, rsp
lea rsi, [rsp+0A8h+var_48]
call _Z5func0St6vectorIiSaIiEE; func0(std::vector<int>)
jmp short loc_14CB
loc_14BB:
mov eax, [r13+0]
mov [rdi], eax
jmp short loc_14A7
loc_14C3:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_14CB:
mov rdi, [rsp+0A8h+var_48]; void *
test rdi, rdi
jz short loc_14E2
mov rsi, [rsp+0A8h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_14E2:
mov rax, [rbx+8]
add rbp, [rbx]
mov [rsp+0A8h+var_48], 0
mov [rsp+0A8h+var_40], 0
mov [rsp+0A8h+var_38], 0
sub rax, rbp
mov rbx, rax
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbx
jb short loc_152C
test rbx, rbx
jz loc_1832
mov rdi, rbx; unsigned __int64
call __Znwm; operator new(ulong)
jmp short loc_157F
loc_152C:
mov rax, [rsp+0A8h+var_30]
sub rax, fs:28h
jnz short loc_157A
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
endbr64
mov rbx, rax
lea rdi, [rsp+0A8h+var_48]
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
loc_1559:
mov rdi, rsp
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+0A8h+var_30]
sub rax, fs:28h
jz loc_182A
call ___stack_chk_fail
loc_157A:
call ___stack_chk_fail
loc_157F:
mov rdi, rax; dest
mov [rsp+0A8h+var_48], rax
lea r13, [rax+rbx]
mov [rsp+0A8h+var_38], r13
cmp rbx, 4
jle short loc_15B7
mov rdx, rbx; n
mov rsi, rbp; src
call _memmove
loc_15A1:
mov [rsp+0A8h+var_40], r13
lea rdi, [rsp+0A8h+src]
lea rsi, [rsp+0A8h+var_48]
call _Z5func0St6vectorIiSaIiEE; func0(std::vector<int>)
jmp short loc_15C0
loc_15B7:
jnz short loc_15A1
mov eax, [rbp+0]
mov [rdi], eax
jmp short loc_15A1
loc_15C0:
mov rdi, [rsp+0A8h+var_48]; void *
test rdi, rdi
jz short loc_15D7
mov rsi, [rsp+0A8h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_15D7:
mov rax, [rsp+0A8h+var_80]
mov [rsp+0A8h+var_48], 0
mov [rsp+0A8h+var_40], 0
mov [rsp+0A8h+var_38], 0
sub rax, [rsp+0A8h+src]
mov rbx, rax
jz loc_16C2
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbx
jb short loc_161E
mov rdi, rbx; unsigned __int64
call __Znwm; operator new(ulong)
jmp short loc_1644
loc_161E:
mov rax, [rsp+0A8h+var_30]
sub rax, fs:28h
jnz short loc_163F
call __ZSt28__throw_bad_array_new_lengthv; std::__throw_bad_array_new_length(void)
endbr64
mov rbx, rax
jmp loc_181B
loc_163F:
call ___stack_chk_fail
loc_1644:
mov rbp, rax
loc_1647:
mov [rsp+0A8h+var_48], rbp
lea rax, [rbp+rbx+0]
mov [rsp+0A8h+var_38], rax
mov rsi, [rsp+0A8h+src]; src
mov rbx, [rsp+0A8h+var_80]
sub rbx, rsi
cmp rbx, 4
jle short loc_16CC
mov rdx, rbx; n
mov rdi, rbp; dest
call _memmove
loc_1674:
add rbp, rbx
mov [rsp+0A8h+var_40], rbp
mov rax, [rsp+0A8h+var_A0]
mov [rsp+0A8h+var_68], 0
mov [rsp+0A8h+var_60], 0
mov [rsp+0A8h+var_58], 0
sub rax, [rsp+0A8h+var_A8]
mov rbx, rax
jz loc_1748
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbx
jb short loc_16D5
mov rdi, rbx; unsigned __int64
call __Znwm; operator new(ulong)
jmp short loc_16FB
loc_16C2:
mov ebp, 0
jmp loc_1647
loc_16CC:
jnz short loc_1674
mov eax, [rsi]
mov [rbp+0], eax
jmp short loc_1674
loc_16D5:
mov rax, [rsp+0A8h+var_30]
sub rax, fs:28h
jnz short loc_16F6
call __ZSt28__throw_bad_array_new_lengthv; std::__throw_bad_array_new_length(void)
endbr64
mov rbx, rax
jmp loc_1811
loc_16F6:
call ___stack_chk_fail
loc_16FB:
mov rbp, rax
loc_16FE:
mov [rsp+0A8h+var_68], rbp
lea rax, [rbp+rbx+0]
mov [rsp+0A8h+var_58], rax
mov rsi, [rsp+0A8h+var_A8]; src
mov rbx, [rsp+0A8h+var_A0]
sub rbx, rsi
cmp rbx, 4
jle short loc_174F
mov rdx, rbx; n
mov rdi, rbp; dest
call _memmove
loc_172A:
lea rax, [rbp+rbx+0]
mov [rsp+0A8h+var_60], rax
lea rdx, [rsp+0A8h+var_48]
lea rsi, [rsp+0A8h+var_68]
mov rdi, r12
call _Z5mergeSt6vectorIiSaIiEES1_; merge(std::vector<int>,std::vector<int>)
jmp short loc_1758
loc_1748:
mov ebp, 0
jmp short loc_16FE
loc_174F:
jnz short loc_172A
mov eax, [rsi]
mov [rbp+0], eax
jmp short loc_172A
loc_1758:
mov rdi, [rsp+0A8h+var_68]; void *
test rdi, rdi
jz short loc_176F
mov rsi, [rsp+0A8h+var_58]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_176F:
mov rdi, [rsp+0A8h+var_48]; void *
test rdi, rdi
jz short loc_1786
mov rsi, [rsp+0A8h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1786:
mov rdi, [rsp+0A8h+src]; void *
test rdi, rdi
jz short loc_179D
mov rsi, [rsp+0A8h+var_78]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_179D:
mov rdi, [rsp+0A8h+var_A8]; void *
test rdi, rdi
jz loc_141A
mov rsi, [rsp+0A8h+var_98]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_141A
endbr64
mov rbx, rax
lea rdi, [rsp+0A8h+var_48]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+0A8h+var_30]
sub rax, fs:28h
jz short loc_17E2
call ___stack_chk_fail
loc_17E2:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
endbr64
mov rbx, rax
lea rdi, [rsp+0A8h+var_48]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp loc_1559
endbr64
mov rbx, rax
lea rdi, [rsp+0A8h+var_68]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
loc_1811:
lea rdi, [rsp+0A8h+var_48]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
loc_181B:
lea rdi, [rsp+0A8h+src]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp loc_1559
loc_182A:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1832:
mov [rsp+0A8h+var_48], 0
mov [rsp+0A8h+var_38], 0
mov r13d, 0
jmp loc_15A1
loc_184F:
mov [rsp+0A8h+var_48], 0
mov [rsp+0A8h+var_38], 0
mov r14d, 0
jmp loc_14A7
loc_186C:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, long long a2)
{
_DWORD *v2; // rdx
_DWORD *v3; // r13
long long v4; // rax
signed long long v5; // rbp
_DWORD *v6; // rax
char *v8; // r14
long long v9; // rax
_DWORD *v10; // rbp
signed long long v11; // rbx
_DWORD *v12; // rax
char *v13; // r13
unsigned long long v14; // rbx
struct _Unwind_Exception *v15; // rbx
_DWORD *v16; // rbp
signed long long v17; // rbx
unsigned long long v18; // rbx
_DWORD *v19; // rbp
signed long long v20; // rbx
void *v21; // [rsp+0h] [rbp-A8h] BYREF
_BYTE *v22; // [rsp+8h] [rbp-A0h]
long long v23; // [rsp+10h] [rbp-98h]
void *src; // [rsp+20h] [rbp-88h] BYREF
_BYTE *v25; // [rsp+28h] [rbp-80h]
long long v26; // [rsp+30h] [rbp-78h]
void *v27; // [rsp+40h] [rbp-68h] BYREF
char *v28; // [rsp+48h] [rbp-60h]
char *v29; // [rsp+50h] [rbp-58h]
void *v30; // [rsp+60h] [rbp-48h] BYREF
char *v31; // [rsp+68h] [rbp-40h]
char *v32; // [rsp+70h] [rbp-38h]
unsigned long long v33; // [rsp+78h] [rbp-30h]
v33 = __readfsqword(0x28u);
v2 = *(_DWORD **)(a2 + 8);
v3 = *(_DWORD **)a2;
v4 = (long long)v2 - *(_QWORD *)a2;
if ( v4 == 4 || v3 == v2 )
{
*a1 = v3;
a1[1] = v2;
a1[2] = *(_QWORD *)(a2 + 16);
*(_QWORD *)(a2 + 16) = 0LL;
*(_QWORD *)(a2 + 8) = 0LL;
*(_QWORD *)a2 = 0LL;
return a1;
}
v5 = (int)(v4 >> 3);
v30 = 0LL;
v31 = 0LL;
v32 = 0LL;
if ( (unsigned long long)v5 > 0x1FFFFFFFFFFFFFFFLL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( v5 * 4 )
{
v6 = (_DWORD *)operator new(v5 * 4);
v30 = v6;
v8 = (char *)&v6[v5];
v32 = (char *)&v6[v5];
if ( v5 <= 1 )
*v6 = *v3;
else
memmove(v6, v3, v5 * 4);
}
else
{
v30 = 0LL;
v32 = 0LL;
v8 = 0LL;
}
v31 = v8;
func0(&v21, &v30);
if ( v30 )
operator delete(v30, v32 - (_BYTE *)v30);
v9 = *(_QWORD *)(a2 + 8);
v10 = (_DWORD *)(*(_QWORD *)a2 + v5 * 4);
v30 = 0LL;
v31 = 0LL;
v32 = 0LL;
v11 = v9 - (_QWORD)v10;
if ( (unsigned long long)(v9 - (_QWORD)v10) > 0x7FFFFFFFFFFFFFFCLL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( v11 )
{
v12 = (_DWORD *)operator new(v11);
v30 = v12;
v13 = (char *)v12 + v11;
v32 = (char *)v12 + v11;
if ( v11 <= 4 )
{
if ( v11 == 4 )
*v12 = *v10;
}
else
{
memmove(v12, v10, v11);
}
}
else
{
v30 = 0LL;
v32 = 0LL;
v13 = 0LL;
}
v31 = v13;
func0(&src, &v30);
if ( v30 )
operator delete(v30, v32 - (_BYTE *)v30);
v30 = 0LL;
v31 = 0LL;
v32 = 0LL;
v14 = v25 - (_BYTE *)src;
if ( v25 == src )
{
v16 = 0LL;
}
else
{
if ( v14 > 0x7FFFFFFFFFFFFFFCLL )
{
v15 = (struct _Unwind_Exception *)std::__throw_bad_array_new_length();
goto LABEL_53;
}
v16 = (_DWORD *)operator new(v25 - (_BYTE *)src);
}
v30 = v16;
v32 = (char *)v16 + v14;
v17 = v25 - (_BYTE *)src;
if ( v25 - (_BYTE *)src <= 4 )
{
if ( v25 - (_BYTE *)src == 4 )
*v16 = *(_DWORD *)src;
}
else
{
memmove(v16, src, v25 - (_BYTE *)src);
}
v31 = (char *)v16 + v17;
v27 = 0LL;
v28 = 0LL;
v29 = 0LL;
v18 = v22 - (_BYTE *)v21;
if ( v22 == v21 )
{
v19 = 0LL;
goto LABEL_39;
}
if ( v18 > 0x7FFFFFFFFFFFFFFCLL )
{
v15 = (struct _Unwind_Exception *)std::__throw_bad_array_new_length();
std::vector<int>::~vector(&v30);
LABEL_53:
std::vector<int>::~vector(&src);
std::vector<int>::~vector(&v21);
_Unwind_Resume(v15);
}
v19 = (_DWORD *)operator new(v22 - (_BYTE *)v21);
LABEL_39:
v27 = v19;
v29 = (char *)v19 + v18;
v20 = v22 - (_BYTE *)v21;
if ( v22 - (_BYTE *)v21 <= 4 )
{
if ( v22 - (_BYTE *)v21 == 4 )
*v19 = *(_DWORD *)v21;
}
else
{
memmove(v19, v21, v22 - (_BYTE *)v21);
}
v28 = (char *)v19 + v20;
merge(a1, &v27, &v30);
if ( v27 )
operator delete(v27, v29 - (_BYTE *)v27);
if ( v30 )
operator delete(v30, v32 - (_BYTE *)v30);
if ( src )
operator delete(src, v26 - (_QWORD)src);
if ( v21 )
operator delete(v21, v23 - (_QWORD)v21);
return a1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
ADD RSP,-0x80
MOV R12,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RSI + 0x8]
MOV R13,qword ptr [RSI]
MOV RAX,RDX
SUB RAX,R13
CMP RAX,0x4
JZ 0x001013f1
CMP R13,RDX
JZ 0x001013f1
SHL RAX,0x1d
SAR RAX,0x20
LEA RBP,[RAX*0x4]
MOV qword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x0
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBP
JC 0x0010143e
TEST RBP,RBP
JZ 0x0010184f
MOV RDI,RBP
LAB_001013e7:
CALL 0x00101130
JMP 0x00101485
LAB_001013f1:
MOV qword ptr [R12],R13
MOV qword ptr [R12 + 0x8],RDX
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [R12 + 0x10],RAX
MOV qword ptr [RBX + 0x10],0x0
MOV qword ptr [RBX + 0x8],0x0
MOV qword ptr [RBX],0x0
LAB_0010141a:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010186c
MOV RAX,R12
SUB RSP,-0x80
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010143e:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101480
LEA RDI,[0x103008]
CALL 0x001010f0
LAB_0010145a:
ENDBR64
MOV RBX,RAX
LEA RDI,[RSP + 0x60]
CALL 0x00101d94
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001014c3
CALL 0x00101150
LAB_00101480:
CALL 0x00101150
LAB_00101485:
MOV RDI,RAX
MOV qword ptr [RSP + 0x60],RAX
LEA R14,[RAX + RBP*0x1]
MOV qword ptr [RSP + 0x70],R14
CMP RBP,0x4
JLE 0x001014bb
MOV RDX,RBP
MOV RSI,R13
CALL 0x00101160
LAB_001014a7:
MOV qword ptr [RSP + 0x68],R14
MOV RDI,RSP
LEA RSI,[RSP + 0x60]
LAB_001014b4:
CALL 0x00101363
JMP 0x001014cb
LAB_001014bb:
MOV EAX,dword ptr [R13]
MOV dword ptr [RDI],EAX
JMP 0x001014a7
LAB_001014c3:
MOV RDI,RBX
LAB_001014c6:
CALL 0x00101170
LAB_001014cb:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x001014e2
MOV RSI,qword ptr [RSP + 0x70]
SUB RSI,RDI
CALL 0x00101140
LAB_001014e2:
MOV RAX,qword ptr [RBX + 0x8]
ADD RBP,qword ptr [RBX]
MOV qword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x0
SUB RAX,RBP
MOV RBX,RAX
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBX
JC 0x0010152c
TEST RBX,RBX
JZ 0x00101832
MOV RDI,RBX
LAB_00101525:
CALL 0x00101130
JMP 0x0010157f
LAB_0010152c:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010157a
LEA RDI,[0x103008]
CALL 0x001010f0
LAB_00101548:
ENDBR64
MOV RBX,RAX
LEA RDI,[RSP + 0x60]
CALL 0x00101d94
LAB_00101559:
MOV RDI,RSP
CALL 0x00101dba
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010182a
CALL 0x00101150
LAB_0010157a:
CALL 0x00101150
LAB_0010157f:
MOV RDI,RAX
MOV qword ptr [RSP + 0x60],RAX
LEA R13,[RAX + RBX*0x1]
MOV qword ptr [RSP + 0x70],R13
CMP RBX,0x4
JLE 0x001015b7
MOV RDX,RBX
MOV RSI,RBP
CALL 0x00101160
LAB_001015a1:
MOV qword ptr [RSP + 0x68],R13
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0x60]
LAB_001015b0:
CALL 0x00101363
JMP 0x001015c0
LAB_001015b7:
JNZ 0x001015a1
MOV EAX,dword ptr [RBP]
MOV dword ptr [RDI],EAX
JMP 0x001015a1
LAB_001015c0:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x001015d7
MOV RSI,qword ptr [RSP + 0x70]
SUB RSI,RDI
CALL 0x00101140
LAB_001015d7:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x0
SUB RAX,qword ptr [RSP + 0x20]
MOV RBX,RAX
JZ 0x001016c2
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBX
JC 0x0010161e
MOV RDI,RBX
LAB_00101617:
CALL 0x00101130
JMP 0x00101644
LAB_0010161e:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010163f
CALL 0x00101110
LAB_00101633:
ENDBR64
MOV RBX,RAX
JMP 0x0010181b
LAB_0010163f:
CALL 0x00101150
LAB_00101644:
MOV RBP,RAX
LAB_00101647:
MOV qword ptr [RSP + 0x60],RBP
LEA RAX,[RBP + RBX*0x1]
MOV qword ptr [RSP + 0x70],RAX
MOV RSI,qword ptr [RSP + 0x20]
MOV RBX,qword ptr [RSP + 0x28]
SUB RBX,RSI
CMP RBX,0x4
JLE 0x001016cc
MOV RDX,RBX
MOV RDI,RBP
CALL 0x00101160
LAB_00101674:
ADD RBP,RBX
MOV qword ptr [RSP + 0x68],RBP
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x0
SUB RAX,qword ptr [RSP]
MOV RBX,RAX
JZ 0x00101748
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBX
JC 0x001016d5
MOV RDI,RBX
LAB_001016bb:
CALL 0x00101130
JMP 0x001016fb
LAB_001016c2:
MOV EBP,0x0
JMP 0x00101647
LAB_001016cc:
JNZ 0x00101674
MOV EAX,dword ptr [RSI]
MOV dword ptr [RBP],EAX
JMP 0x00101674
LAB_001016d5:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001016f6
CALL 0x00101110
LAB_001016ea:
ENDBR64
MOV RBX,RAX
JMP 0x00101811
LAB_001016f6:
CALL 0x00101150
LAB_001016fb:
MOV RBP,RAX
LAB_001016fe:
MOV qword ptr [RSP + 0x40],RBP
LEA RAX,[RBP + RBX*0x1]
MOV qword ptr [RSP + 0x50],RAX
MOV RSI,qword ptr [RSP]
MOV RBX,qword ptr [RSP + 0x8]
SUB RBX,RSI
CMP RBX,0x4
JLE 0x0010174f
MOV RDX,RBX
MOV RDI,RBP
CALL 0x00101160
LAB_0010172a:
LEA RAX,[RBP + RBX*0x1]
MOV qword ptr [RSP + 0x48],RAX
LEA RDX,[RSP + 0x60]
LEA RSI,[RSP + 0x40]
MOV RDI,R12
LAB_00101741:
CALL 0x00101269
JMP 0x00101758
LAB_00101748:
MOV EBP,0x0
JMP 0x001016fe
LAB_0010174f:
JNZ 0x0010172a
MOV EAX,dword ptr [RSI]
MOV dword ptr [RBP],EAX
JMP 0x0010172a
LAB_00101758:
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x0010176f
MOV RSI,qword ptr [RSP + 0x50]
SUB RSI,RDI
CALL 0x00101140
LAB_0010176f:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x00101786
MOV RSI,qword ptr [RSP + 0x70]
SUB RSI,RDI
CALL 0x00101140
LAB_00101786:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x0010179d
MOV RSI,qword ptr [RSP + 0x30]
SUB RSI,RDI
CALL 0x00101140
LAB_0010179d:
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x0010141a
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RDI
CALL 0x00101140
JMP 0x0010141a
LAB_00101811:
LEA RDI,[RSP + 0x60]
CALL 0x00101dba
LAB_0010181b:
LEA RDI,[RSP + 0x20]
CALL 0x00101dba
JMP 0x00101559
LAB_0010182a:
MOV RDI,RBX
CALL 0x00101170
LAB_00101832:
MOV qword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x70],0x0
MOV R13D,0x0
JMP 0x001015a1
LAB_0010184f:
MOV qword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x70],0x0
MOV R14D,0x0
JMP 0x001014a7
LAB_0010186c:
CALL 0x00101150 | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1)
{
int4 *__src;
long lVar1;
ulong uVar2;
int8 uVar3;
size_t sVar4;
int4 *puVar5;
long *in_RSI;
int4 in_register_0000003c;
int8 *puVar6;
long in_FS_OFFSET;
int4 *local_a8;
long local_a0;
long local_98;
int4 *local_88;
long local_80;
long local_78;
int4 *local_68;
long local_60;
long local_58;
int4 *local_48;
int4 *local_40;
int4 *local_38;
long local_30;
puVar6 = (int8 *)CONCAT44(in_register_0000003c,param_1);
local_30 = *(long *)(in_FS_OFFSET + 0x28);
puVar5 = (int4 *)in_RSI[1];
__src = (int4 *)*in_RSI;
if (((long)puVar5 - (long)__src == 4) || (__src == puVar5)) {
*puVar6 = __src;
puVar6[1] = puVar5;
puVar6[2] = in_RSI[2];
in_RSI[2] = 0;
in_RSI[1] = 0;
*in_RSI = 0;
goto LAB_0010141a;
}
lVar1 = ((long)puVar5 - (long)__src) * 0x20000000 >> 0x20;
uVar2 = lVar1 * 4;
local_48 = (int4 *)0x0;
local_40 = (int4 *)0x0;
local_38 = (int4 *)0x0;
if (0x7ffffffffffffffc < uVar2) {
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
uVar3 = std::__throw_length_error("cannot create std::vector larger than max_size()");
/* catch() { ... } // from try @ 001013e7 with catch @ 0010145a */
std::_Vector_base<int,std::allocator<int>>::~_Vector_base
((_Vector_base<int,std::allocator<int>> *)&local_48);
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar3);
}
if (uVar2 == 0) {
local_48 = (int4 *)0x0;
local_38 = (int4 *)0x0;
puVar5 = (int4 *)0x0;
}
else {
/* try { // try from 001013e7 to 00101459 has its CatchHandler @ 0010145a */
local_48 = (int4 *)operator_new(uVar2);
puVar5 = local_48 + lVar1;
local_38 = puVar5;
if ((long)uVar2 < 5) {
*local_48 = *__src;
}
else {
memmove(local_48,__src,uVar2);
}
}
local_40 = puVar5;
/* try { // try from 001014b4 to 001014b8 has its CatchHandler @ 001017bc */
func0((vector)&local_a8);
if (local_48 != (int4 *)0x0) {
operator_delete(local_48,(long)local_38 - (long)local_48);
}
puVar5 = (int4 *)(uVar2 + *in_RSI);
local_48 = (int4 *)0x0;
local_40 = (int4 *)0x0;
local_38 = (int4 *)0x0;
uVar2 = in_RSI[1] - (long)puVar5;
if (0x7ffffffffffffffc < uVar2) {
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
uVar3 = std::__throw_length_error("cannot create std::vector larger than max_size()");
/* catch() { ... } // from try @ 00101525 with catch @ 00101548 */
std::_Vector_base<int,std::allocator<int>>::~_Vector_base
((_Vector_base<int,std::allocator<int>> *)&local_48);
goto LAB_00101559;
}
if (uVar2 == 0) {
local_48 = (int4 *)0x0;
local_38 = (int4 *)0x0;
lVar1 = 0;
}
else {
/* try { // try from 00101525 to 00101547 has its CatchHandler @ 00101548 */
local_48 = (int4 *)operator_new(uVar2);
lVar1 = (long)local_48 + uVar2;
local_38 = (int4 *)lVar1;
if ((long)uVar2 < 5) {
if (uVar2 == 4) {
*local_48 = *puVar5;
}
}
else {
memmove(local_48,puVar5,uVar2);
}
}
local_40 = (int4 *)lVar1;
/* try { // try from 001015b0 to 001015b4 has its CatchHandler @ 001017ea */
func0((vector)&local_88);
if (local_48 != (int4 *)0x0) {
operator_delete(local_48,(long)local_38 - (long)local_48);
}
local_48 = (int4 *)0x0;
local_40 = (int4 *)0x0;
local_38 = (int4 *)0x0;
uVar2 = local_80 - (long)local_88;
if (uVar2 != 0) {
if (uVar2 < 0x7ffffffffffffffd) {
/* try { // try from 00101617 to 00101632 has its CatchHandler @ 00101633 */
puVar5 = (int4 *)operator_new(uVar2);
goto LAB_00101647;
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
uVar3 = std::__throw_bad_array_new_length();
/* catch() { ... } // from try @ 00101617 with catch @ 00101633 */
LAB_0010181b:
std::vector<int,std::allocator<int>>::~vector((vector<int,std::allocator<int>> *)&local_88);
LAB_00101559:
std::vector<int,std::allocator<int>>::~vector((vector<int,std::allocator<int>> *)&local_a8);
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar3);
}
puVar5 = (int4 *)0x0;
LAB_00101647:
local_38 = (int4 *)((long)puVar5 + uVar2);
sVar4 = local_80 - (long)local_88;
local_48 = puVar5;
if ((long)sVar4 < 5) {
if (sVar4 == 4) {
*puVar5 = *local_88;
}
}
else {
memmove(puVar5,local_88,sVar4);
}
local_40 = (int4 *)((long)puVar5 + sVar4);
local_68 = (int4 *)0x0;
local_60 = 0;
local_58 = 0;
uVar2 = local_a0 - (long)local_a8;
if (uVar2 == 0) {
puVar5 = (int4 *)0x0;
}
else {
if (0x7ffffffffffffffc < uVar2) {
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
uVar3 = std::__throw_bad_array_new_length();
std::vector<int,std::allocator<int>>::~vector((vector<int,std::allocator<int>> *)&local_48);
/* catch() { ... } // from try @ 001016bb with catch @ 001016ea */
goto LAB_0010181b;
}
/* try { // try from 001016bb to 001016e9 has its CatchHandler @ 001016ea */
puVar5 = (int4 *)operator_new(uVar2);
}
local_58 = (long)puVar5 + uVar2;
sVar4 = local_a0 - (long)local_a8;
local_68 = puVar5;
if ((long)sVar4 < 5) {
if (sVar4 == 4) {
*puVar5 = *local_a8;
}
}
else {
memmove(puVar5,local_a8,sVar4);
}
local_60 = (long)puVar5 + sVar4;
/* try { // try from 00101741 to 00101745 has its CatchHandler @ 00101800 */
merge(param_1,(vector)&local_68);
if (local_68 != (int4 *)0x0) {
operator_delete(local_68,local_58 - (long)local_68);
}
if (local_48 != (int4 *)0x0) {
operator_delete(local_48,(long)local_38 - (long)local_48);
}
if (local_88 != (int4 *)0x0) {
operator_delete(local_88,local_78 - (long)local_88);
}
if (local_a8 != (int4 *)0x0) {
operator_delete(local_a8,local_98 - (long)local_a8);
}
LAB_0010141a:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar6;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
606 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
std::vector<int> merge(std::vector<int> a, std::vector<int> b) {
std::vector<int> c;
while (!a.empty() && !b.empty()) {
if (a.front() < b.front()) {
c.push_back(a.front());
a.erase(a.begin());
} else {
c.push_back(b.front());
b.erase(b.begin());
}
}
if (a.empty()) {
c.insert(c.end(), b.begin(), b.end());
} else {
c.insert(c.end(), a.begin(), a.end());
}
return c;
}
| std::vector<int> func0(std::vector<int> x) {
if (x.size() == 0 || x.size() == 1) {
return x;
} else {
int middle = x.size() / 2;
std::vector<int> a = func0(std::vector<int>(x.begin(), x.begin() + middle));
std::vector<int> b = func0(std::vector<int>(x.begin() + middle, x.end()));
return merge(a, b);
}
}
| int main() {
std::vector<int> v1 = {3, 4, 2, 6, 5, 7, 1, 9};
std::vector<int> r1 = {1, 2, 3, 4, 5, 6, 7, 9};
assert(func0(v1) == r1);
std::vector<int> v2 = {7, 25, 45, 78, 11, 33, 19};
std::vector<int> r2 = {7, 11, 19, 25, 33, 45, 78};
assert(func0(v2) == r2);
std::vector<int> v3 = {3, 1, 4, 9, 8};
std::vector<int> r3 = {1, 3, 4, 8, 9};
assert(func0(v3) == r3);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x88,%rsp
mov 0x8(%rsi),%rdx
mov (%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
mov %rdx,%rax
sub %rbp,%rax
cmp $0x4,%rax
je 1ca0 <_Z5func0St6vectorIiSaIiEE+0x2e0>
cmp %rdx,%rbp
je 1ca0 <_Z5func0St6vectorIiSaIiEE+0x2e0>
movabs $0x1fffffffffffffff,%rdx
shl $0x1d,%rax
movq $0x0,0x60(%rsp)
movq $0x0,0x68(%rsp)
sar $0x20,%rax
movq $0x0,0x70(%rsp)
lea 0x0(,%rax,4),%r13
cmp %rdx,%rax
ja 1d34 <_Z5func0St6vectorIiSaIiEE+0x374>
test %rax,%rax
je 1cf0 <_Z5func0St6vectorIiSaIiEE+0x330>
mov %r13,%rdi
callq 1170 <_Znwm@plt>
mov %rax,%rdi
lea (%rdi,%r13,1),%r14
mov %rdi,0x60(%rsp)
mov %r14,0x70(%rsp)
test %r13,%r13
je 1a7b <_Z5func0St6vectorIiSaIiEE+0xbb>
mov %r13,%rdx
mov %rbp,%rsi
callq 1140 <memcpy@plt>
mov %r14,0x68(%rsp)
lea 0x60(%rsp),%r14
mov %rsp,%rdi
mov %r14,%rsi
callq 19c0 <_Z5func0St6vectorIiSaIiEE>
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 1a9f <_Z5func0St6vectorIiSaIiEE+0xdf>
callq 1160 <_ZdlPv@plt>
mov 0x8(%rbx),%rbp
add (%rbx),%r13
movq $0x0,0x60(%rsp)
movq $0x0,0x68(%rsp)
movq $0x0,0x70(%rsp)
mov %rbp,%r15
sub %r13,%r15
mov %r15,%rax
sar $0x2,%rax
test %r15,%r15
js 1d45 <_Z5func0St6vectorIiSaIiEE+0x385>
test %rax,%rax
je 1d10 <_Z5func0St6vectorIiSaIiEE+0x350>
mov %r15,%rdi
callq 1170 <_Znwm@plt>
mov %rax,%rdi
lea (%rdi,%r15,1),%rbx
mov %rdi,0x60(%rsp)
mov %rbx,0x70(%rsp)
cmp %rbp,%r13
je 1b09 <_Z5func0St6vectorIiSaIiEE+0x149>
mov %r15,%rdx
mov %r13,%rsi
callq 1140 <memcpy@plt>
lea 0x20(%rsp),%rdi
mov %r14,%rsi
mov %rbx,0x68(%rsp)
callq 19c0 <_Z5func0St6vectorIiSaIiEE>
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 1b2a <_Z5func0St6vectorIiSaIiEE+0x16a>
callq 1160 <_ZdlPv@plt>
mov 0x28(%rsp),%rax
mov 0x20(%rsp),%rsi
movq $0x0,0x60(%rsp)
movq $0x0,0x68(%rsp)
movq $0x0,0x70(%rsp)
mov %rax,%rbx
sub %rsi,%rbx
mov %rbx,%rdx
sar $0x2,%rdx
je 1d20 <_Z5func0St6vectorIiSaIiEE+0x360>
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rdx
ja 1d40 <_Z5func0St6vectorIiSaIiEE+0x380>
mov %rbx,%rdi
callq 1170 <_Znwm@plt>
mov %rax,%rcx
mov 0x28(%rsp),%rax
mov 0x20(%rsp),%rsi
mov %rax,%rbp
sub %rsi,%rbp
add %rcx,%rbx
mov %rcx,0x60(%rsp)
mov %rcx,0x68(%rsp)
mov %rbx,0x70(%rsp)
cmp %rax,%rsi
je 1bb5 <_Z5func0St6vectorIiSaIiEE+0x1f5>
mov %rcx,%rdi
mov %rbp,%rdx
callq 11a0 <memmove@plt>
mov %rax,%rcx
mov 0x8(%rsp),%rax
mov (%rsp),%rsi
add %rbp,%rcx
movq $0x0,0x40(%rsp)
mov %rcx,0x68(%rsp)
movq $0x0,0x48(%rsp)
mov %rax,%rbx
movq $0x0,0x50(%rsp)
sub %rsi,%rbx
mov %rbx,%rdx
sar $0x2,%rdx
je 1d00 <_Z5func0St6vectorIiSaIiEE+0x340>
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rdx
ja 1d2f <_Z5func0St6vectorIiSaIiEE+0x36f>
mov %rbx,%rdi
callq 1170 <_Znwm@plt>
mov %rax,%rcx
mov 0x8(%rsp),%rax
mov (%rsp),%rsi
mov %rax,%rbp
sub %rsi,%rbp
add %rcx,%rbx
mov %rcx,0x40(%rsp)
mov %rcx,0x48(%rsp)
mov %rbx,0x50(%rsp)
cmp %rsi,%rax
je 1c46 <_Z5func0St6vectorIiSaIiEE+0x286>
mov %rcx,%rdi
mov %rbp,%rdx
callq 11a0 <memmove@plt>
mov %rax,%rcx
add %rbp,%rcx
lea 0x40(%rsp),%rsi
mov %r14,%rdx
mov %r12,%rdi
mov %rcx,0x48(%rsp)
callq 18b0 <_Z5mergeSt6vectorIiSaIiEES1_>
mov 0x40(%rsp),%rdi
test %rdi,%rdi
je 1c6d <_Z5func0St6vectorIiSaIiEE+0x2ad>
callq 1160 <_ZdlPv@plt>
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 1c7c <_Z5func0St6vectorIiSaIiEE+0x2bc>
callq 1160 <_ZdlPv@plt>
mov 0x20(%rsp),%rdi
test %rdi,%rdi
je 1c8b <_Z5func0St6vectorIiSaIiEE+0x2cb>
callq 1160 <_ZdlPv@plt>
mov (%rsp),%rdi
test %rdi,%rdi
je 1cc9 <_Z5func0St6vectorIiSaIiEE+0x309>
callq 1160 <_ZdlPv@plt>
jmp 1cc9 <_Z5func0St6vectorIiSaIiEE+0x309>
nopl 0x0(%rax,%rax,1)
mov 0x10(%rbx),%rax
mov %rbp,(%r12)
mov %rdx,0x8(%r12)
mov %rax,0x10(%r12)
movq $0x0,0x10(%rbx)
movq $0x0,0x8(%rbx)
movq $0x0,(%rbx)
mov 0x78(%rsp),%rax
xor %fs:0x28,%rax
jne 1d2a <_Z5func0St6vectorIiSaIiEE+0x36a>
add $0x88,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xchg %ax,%ax
xor %edi,%edi
jmpq 1a5d <_Z5func0St6vectorIiSaIiEE+0x9d>
nopw 0x0(%rax,%rax,1)
mov %rbx,%rbp
xor %ecx,%ecx
jmpq 1c21 <_Z5func0St6vectorIiSaIiEE+0x261>
nopw 0x0(%rax,%rax,1)
xor %edi,%edi
jmpq 1aeb <_Z5func0St6vectorIiSaIiEE+0x12b>
nopw 0x0(%rax,%rax,1)
mov %rbx,%rbp
xor %ecx,%ecx
jmpq 1b90 <_Z5func0St6vectorIiSaIiEE+0x1d0>
callq 1180 <__stack_chk_fail@plt>
callq 1100 <_ZSt17__throw_bad_allocv@plt>
lea 0x12cd(%rip),%rdi
callq 1120 <_ZSt20__throw_length_errorPKc@plt>
callq 1100 <_ZSt17__throw_bad_allocv@plt>
lea 0x12bc(%rip),%rdi
callq 1120 <_ZSt20__throw_length_errorPKc@plt>
endbr64
mov %rax,%rbp
jmpq 11d6 <_Z5func0St6vectorIiSaIiEE.cold>
endbr64
mov %rax,%rbp
jmpq 1219 <_Z5func0St6vectorIiSaIiEE.cold+0x43>
endbr64
mov %rax,%rbp
jmpq 11fb <_Z5func0St6vectorIiSaIiEE.cold+0x25>
endbr64
mov %rax,%rbp
jmpq 11d6 <_Z5func0St6vectorIiSaIiEE.cold>
endbr64
mov %rax,%rbp
jmpq 1225 <_Z5func0St6vectorIiSaIiEE.cold+0x4f>
endbr64
mov %rax,%rbp
jmpq 123c <_Z5func0St6vectorIiSaIiEE.cold+0x66>
endbr64
mov %rax,%rbp
jmpq 120a <_Z5func0St6vectorIiSaIiEE.cold+0x34>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
mov rbx, rsi
sub rsp, 88h
mov rdx, [rsi+8]
mov r13, [rsi]
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
mov rax, rdx
sub rax, r13
cmp rax, 4
jz loc_1F40
cmp r13, rdx
jz loc_1F40
shl rax, 1Dh
pxor xmm0, xmm0
mov [rsp+0B8h+var_48], 0
sar rax, 20h
movaps xmmword ptr [rsp+0B8h+var_58], xmm0
lea rbp, ds:0[rax*4]
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbp
jb loc_2082
test rbp, rbp
jz loc_1F98
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
lea r14, [rax+rbp]
mov [rsp+0B8h+var_58], rax
mov rdi, rax; dest
mov [rsp+0B8h+var_48], r14
cmp rbp, 4
jz loc_2014
mov rdx, rbp; n
mov rsi, r13; src
call _memmove
loc_1D17:
mov [rsp+0B8h+var_58+8], r14
lea r13, [rsp+0B8h+var_58]
mov r14, rsp
mov rsi, r13
mov rdi, r14
call _Z5func0St6vectorIiSaIiEE; func0(std::vector<int>)
mov rdi, [rsp+0B8h+var_58]; void *
test rdi, rdi
jz short loc_1D46
mov rsi, [rsp+0B8h+var_48]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1D46:
mov rax, [rbx+8]
add rbp, [rbx]
pxor xmm0, xmm0
mov [rsp+0B8h+var_48], 0
movaps xmmword ptr [rsp+0B8h+var_58], xmm0
sub rax, rbp
mov rbx, rax
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbx
jb loc_209E
test rbx, rbx
jz loc_1FB8
mov rdi, rbx; unsigned __int64
call __Znwm; operator new(ulong)
lea r15, [rax+rbx]
mov [rsp+0B8h+var_58], rax
mov rdi, rax; dest
mov [rsp+0B8h+var_48], r15
cmp rbx, 4
jle loc_2020
mov rdx, rbx; n
mov rsi, rbp; src
call _memmove
loc_1DAF:
lea rbx, [rsp+0B8h+src]
mov rsi, r13
mov [rsp+0B8h+var_58+8], r15
mov rdi, rbx
call _Z5func0St6vectorIiSaIiEE; func0(std::vector<int>)
mov rdi, [rsp+0B8h+var_58]; void *
test rdi, rdi
jz short loc_1DDB
mov rsi, [rsp+0B8h+var_48]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1DDB:
pxor xmm0, xmm0
mov rbp, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_48], 0
movaps xmmword ptr [rsp+0B8h+var_58], xmm0
sub rbp, [rsp+0B8h+src]
jz loc_1FD8
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbp
jb loc_2050
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
mov rsi, [rsp+0B8h+src]; src
mov r15, [rsp+0B8h+var_90]
add rbp, rax
mov rcx, rax
mov [rsp+0B8h+var_58], rax
sub r15, rsi
mov [rsp+0B8h+var_48], rbp
cmp r15, 4
jle loc_202A
mov rdx, r15; n
mov rdi, rax; dest
call _memmove
mov rcx, rax
loc_1E4D:
add rcx, r15
pxor xmm0, xmm0
mov rbp, [rsp+0B8h+var_B0]
mov [rsp+0B8h+var_68], 0
mov [rsp+0B8h+var_58+8], rcx
movaps xmmword ptr [rsp+0B8h+var_78], xmm0
sub rbp, [rsp+0B8h+var_B8]
jz loc_1FF8
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbp
jb loc_2068
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
mov rsi, [rsp+0B8h+var_B8]; src
mov r15, [rsp+0B8h+var_B0]
add rbp, rax
mov rcx, rax
mov [rsp+0B8h+var_78], rax
sub r15, rsi
mov [rsp+0B8h+var_68], rbp
cmp r15, 4
jle loc_2039
mov rdx, r15; n
mov rdi, rax; dest
call _memmove
mov rcx, rax
loc_1EC5:
lea rbp, [rsp+0B8h+var_78]
add rcx, r15
mov rdx, r13
mov rdi, r12
mov rsi, rbp
mov [rsp+0B8h+var_78+8], rcx
call _Z5mergeSt6vectorIiSaIiEES1_; merge(std::vector<int>,std::vector<int>)
mov rdi, [rsp+0B8h+var_78]; void *
test rdi, rdi
jz short loc_1EF7
mov rsi, [rsp+0B8h+var_68]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1EF7:
mov rdi, [rsp+0B8h+var_58]; void *
test rdi, rdi
jz short loc_1F0E
mov rsi, [rsp+0B8h+var_48]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F0E:
mov rdi, [rsp+0B8h+src]; void *
test rdi, rdi
jz short loc_1F25
mov rsi, [rsp+0B8h+var_88]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F25:
mov rdi, [rsp+0B8h+var_B8]; void *
test rdi, rdi
jz short loc_1F6B
mov rsi, [rsp+0B8h+var_A8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1F6B
loc_1F40:
mov rax, [rbx+10h]
movq xmm0, r13
movq xmm1, rdx
mov qword ptr [rbx+10h], 0
punpcklqdq xmm0, xmm1
mov [r12+10h], rax
movups xmmword ptr [r12], xmm0
pxor xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_1F6B:
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz loc_207D
add rsp, 88h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1F98:
mov [rsp+0B8h+var_58], 0
xor r14d, r14d
mov [rsp+0B8h+var_48], 0
jmp loc_1D17
loc_1FB8:
mov [rsp+0B8h+var_58], 0
xor r15d, r15d
mov [rsp+0B8h+var_48], 0
jmp loc_1DAF
loc_1FD8:
mov [rsp+0B8h+var_58], 0
xor r15d, r15d
xor ecx, ecx
mov [rsp+0B8h+var_48], 0
jmp loc_1E4D
loc_1FF8:
mov [rsp+0B8h+var_78], 0
xor r15d, r15d
xor ecx, ecx
mov [rsp+0B8h+var_68], 0
jmp loc_1EC5
loc_2014:
mov eax, [r13+0]
mov [rdi], eax
jmp loc_1D17
loc_2020:
mov eax, [rbp+0]
mov [rdi], eax
jmp loc_1DAF
loc_202A:
jnz loc_1E4D
mov eax, [rsi]
mov [rcx], eax
jmp loc_1E4D
loc_2039:
jnz loc_1EC5
mov eax, [rsi]
mov [rcx], eax
jmp loc_1EC5
loc_2050:
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz short loc_207D
call __ZSt28__throw_bad_array_new_lengthv; std::__throw_bad_array_new_length(void)
nop dword ptr [rax]
loc_2068:
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz short loc_207D
call __ZSt28__throw_bad_array_new_lengthv; std::__throw_bad_array_new_length(void)
loc_207D:
call ___stack_chk_fail
loc_2082:
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz short loc_207D
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_209E:
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz short loc_207D
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
endbr64
mov rbx, rax
jmp _Z5func0St6vectorIiSaIiEE_cold; func0(std::vector<int>) [clone]
endbr64
mov rbx, rax
jmp loc_11B0
endbr64
mov rbx, rax
jmp loc_11CF
endbr64
mov rbx, rax
jmp loc_11F1
endbr64
mov rbp, rax
jmp loc_1206
endbr64
mov rbp, rax
jmp loc_120E
endbr64
mov r12, rax
jmp loc_11FB | __m128i * func0(__m128i *a1, long long a2, long long a3, int a4, int a5, int a6)
{
char *v6; // rdx
char *v7; // r13
size_t v8; // rbp
_DWORD *v9; // rax
int v10; // r14d
int v11; // edx
int v12; // ecx
int v13; // r8d
int v14; // r9d
long long v15; // rax
_DWORD *v16; // rbp
signed long long v17; // rbx
_DWORD *v18; // rax
int v19; // r15d
unsigned long long v20; // rbp
char *v21; // rax
char *v22; // rcx
signed long long v23; // r15
unsigned long long v24; // rbp
char *v25; // rax
char *v26; // rcx
signed long long v27; // r15
long long v28; // rax
void *v30; // [rsp+0h] [rbp-B8h] BYREF
_BYTE *v31; // [rsp+8h] [rbp-B0h]
long long v32; // [rsp+10h] [rbp-A8h]
int v33; // [rsp+18h] [rbp-A0h]
void *src; // [rsp+20h] [rbp-98h] BYREF
_BYTE *v35; // [rsp+28h] [rbp-90h]
long long v36; // [rsp+30h] [rbp-88h]
int v37; // [rsp+38h] [rbp-80h]
void *v38[2]; // [rsp+40h] [rbp-78h] BYREF
char *v39; // [rsp+50h] [rbp-68h]
int v40; // [rsp+58h] [rbp-60h]
void *v41[2]; // [rsp+60h] [rbp-58h] BYREF
char *v42; // [rsp+70h] [rbp-48h]
unsigned long long v43; // [rsp+78h] [rbp-40h]
v6 = *(char **)(a2 + 8);
v7 = *(char **)a2;
v43 = __readfsqword(0x28u);
if ( v6 - v7 == 4 || v7 == v6 )
{
v28 = *(_QWORD *)(a2 + 16);
*(_QWORD *)(a2 + 16) = 0LL;
a1[1].m128i_i64[0] = v28;
*a1 = _mm_unpacklo_epi64((__m128i)(unsigned long long)v7, (__m128i)(unsigned long long)v6);
*(_OWORD *)a2 = 0LL;
return a1;
}
v42 = 0LL;
*(_OWORD *)v41 = 0LL;
v8 = 4LL * (int)((v6 - v7) >> 3);
if ( v8 > 0x7FFFFFFFFFFFFFFCLL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( v8 )
{
v9 = (_DWORD *)operator new(4LL * (int)((v6 - v7) >> 3));
v10 = (_DWORD)v9 + v8;
v41[0] = v9;
v42 = (char *)&v9[v8 / 4];
if ( v8 == 4 )
*v9 = *(_DWORD *)v7;
else
memmove(v9, v7, v8);
}
else
{
v41[0] = 0LL;
v10 = 0;
v42 = 0LL;
}
func0(
(unsigned int)&v30,
(unsigned int)v41,
(_DWORD)v6,
a4,
a5,
a6,
(_DWORD)v30,
(_DWORD)v31,
v32,
v33,
(_DWORD)src,
(_DWORD)v35,
v36,
v37,
v38[0],
v38[1],
(_DWORD)v39,
v40,
v41[0],
v10,
(long long)v42);
if ( v41[0] )
operator delete(v41[0], v42 - (char *)v41[0]);
v15 = *(_QWORD *)(a2 + 8);
v16 = (_DWORD *)(*(_QWORD *)a2 + v8);
v42 = 0LL;
*(_OWORD *)v41 = 0LL;
v17 = v15 - (_QWORD)v16;
if ( (unsigned long long)(v15 - (_QWORD)v16) > 0x7FFFFFFFFFFFFFFCLL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( v17 )
{
v18 = (_DWORD *)operator new(v17);
v19 = (_DWORD)v18 + v17;
v41[0] = v18;
v42 = (char *)v18 + v17;
if ( v17 <= 4 )
*v18 = *v16;
else
memmove(v18, v16, v17);
}
else
{
v41[0] = 0LL;
v19 = 0;
v42 = 0LL;
}
func0(
(unsigned int)&src,
(unsigned int)v41,
v11,
v12,
v13,
v14,
(_DWORD)v30,
(_DWORD)v31,
v32,
v33,
(_DWORD)src,
(_DWORD)v35,
v36,
v37,
v38[0],
v38[1],
(_DWORD)v39,
v40,
v41[0],
v19,
(long long)v42);
if ( v41[0] )
operator delete(v41[0], v42 - (char *)v41[0]);
v42 = 0LL;
*(_OWORD *)v41 = 0LL;
v20 = v35 - (_BYTE *)src;
if ( v35 == src )
{
v41[0] = 0LL;
v23 = 0LL;
v22 = 0LL;
v42 = 0LL;
}
else
{
if ( v20 > 0x7FFFFFFFFFFFFFFCLL )
{
std::__throw_bad_array_new_length();
goto LABEL_44;
}
v21 = (char *)operator new(v35 - (_BYTE *)src);
v22 = v21;
v41[0] = v21;
v23 = v35 - (_BYTE *)src;
v42 = &v21[v20];
if ( v35 - (_BYTE *)src <= 4 )
{
if ( v35 - (_BYTE *)src == 4 )
*(_DWORD *)v21 = *(_DWORD *)src;
}
else
{
v22 = (char *)memmove(v21, src, v35 - (_BYTE *)src);
}
}
v39 = 0LL;
v41[1] = &v22[v23];
*(_OWORD *)v38 = 0LL;
v24 = v31 - (_BYTE *)v30;
if ( v31 != v30 )
{
if ( v24 <= 0x7FFFFFFFFFFFFFFCLL )
{
v25 = (char *)operator new(v31 - (_BYTE *)v30);
v26 = v25;
v38[0] = v25;
v27 = v31 - (_BYTE *)v30;
v39 = &v25[v24];
if ( v31 - (_BYTE *)v30 <= 4 )
{
if ( v31 - (_BYTE *)v30 == 4 )
*(_DWORD *)v25 = *(_DWORD *)v30;
}
else
{
v26 = (char *)memmove(v25, v30, v31 - (_BYTE *)v30);
}
goto LABEL_23;
}
LABEL_44:
std::__throw_bad_array_new_length();
}
v38[0] = 0LL;
v27 = 0LL;
v26 = 0LL;
v39 = 0LL;
LABEL_23:
v38[1] = &v26[v27];
merge(a1, v38, v41);
if ( v38[0] )
operator delete(v38[0], v39 - (char *)v38[0]);
if ( v41[0] )
operator delete(v41[0], v42 - (char *)v41[0]);
if ( src )
operator delete(src, v36 - (_QWORD)src);
if ( v30 )
operator delete(v30, v32 - (_QWORD)v30);
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x88
MOV RDX,qword ptr [RSI + 0x8]
MOV R13,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV RAX,RDX
SUB RAX,R13
CMP RAX,0x4
JZ 0x00101f40
CMP R13,RDX
JZ 0x00101f40
SHL RAX,0x1d
PXOR XMM0,XMM0
MOV qword ptr [RSP + 0x70],0x0
SAR RAX,0x20
MOVAPS xmmword ptr [RSP + 0x60],XMM0
LEA RBP,[RAX*0x4]
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBP
JC 0x00102082
TEST RBP,RBP
JZ 0x00101f98
MOV RDI,RBP
LAB_00101cec:
CALL 0x00101130
LEA R14,[RAX + RBP*0x1]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,RAX
MOV qword ptr [RSP + 0x70],R14
CMP RBP,0x4
JZ 0x00102014
MOV RDX,RBP
MOV RSI,R13
CALL 0x00101160
LAB_00101d17:
MOV qword ptr [RSP + 0x68],R14
LEA R13,[RSP + 0x60]
MOV R14,RSP
MOV RSI,R13
MOV RDI,R14
LAB_00101d2a:
CALL 0x00101c60
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x00101d46
MOV RSI,qword ptr [RSP + 0x70]
SUB RSI,RDI
CALL 0x00101140
LAB_00101d46:
MOV RAX,qword ptr [RBX + 0x8]
ADD RBP,qword ptr [RBX]
PXOR XMM0,XMM0
MOV qword ptr [RSP + 0x70],0x0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
SUB RAX,RBP
MOV RBX,RAX
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBX
JC 0x0010209e
TEST RBX,RBX
JZ 0x00101fb8
MOV RDI,RBX
LAB_00101d84:
CALL 0x00101130
LEA R15,[RAX + RBX*0x1]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,RAX
MOV qword ptr [RSP + 0x70],R15
CMP RBX,0x4
JLE 0x00102020
MOV RDX,RBX
MOV RSI,RBP
CALL 0x00101160
LAB_00101daf:
LEA RBX,[RSP + 0x20]
MOV RSI,R13
MOV qword ptr [RSP + 0x68],R15
MOV RDI,RBX
LAB_00101dbf:
CALL 0x00101c60
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x00101ddb
MOV RSI,qword ptr [RSP + 0x70]
SUB RSI,RDI
CALL 0x00101140
LAB_00101ddb:
PXOR XMM0,XMM0
MOV RBP,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x70],0x0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
SUB RBP,qword ptr [RSP + 0x20]
JZ 0x00101fd8
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBP
JC 0x00102050
MOV RDI,RBP
LAB_00101e13:
CALL 0x00101130
MOV RSI,qword ptr [RSP + 0x20]
MOV R15,qword ptr [RSP + 0x28]
ADD RBP,RAX
MOV RCX,RAX
MOV qword ptr [RSP + 0x60],RAX
SUB R15,RSI
MOV qword ptr [RSP + 0x70],RBP
CMP R15,0x4
JLE 0x0010202a
MOV RDX,R15
MOV RDI,RAX
CALL 0x00101160
MOV RCX,RAX
LAB_00101e4d:
ADD RCX,R15
PXOR XMM0,XMM0
MOV RBP,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x68],RCX
MOVAPS xmmword ptr [RSP + 0x40],XMM0
SUB RBP,qword ptr [RSP]
JZ 0x00101ff8
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBP
JC 0x00102068
MOV RDI,RBP
LAB_00101e8c:
CALL 0x00101130
MOV RSI,qword ptr [RSP]
MOV R15,qword ptr [RSP + 0x8]
ADD RBP,RAX
MOV RCX,RAX
MOV qword ptr [RSP + 0x40],RAX
SUB R15,RSI
MOV qword ptr [RSP + 0x50],RBP
CMP R15,0x4
JLE 0x00102039
MOV RDX,R15
MOV RDI,RAX
CALL 0x00101160
MOV RCX,RAX
LAB_00101ec5:
LEA RBP,[RSP + 0x40]
ADD RCX,R15
MOV RDX,R13
MOV RDI,R12
MOV RSI,RBP
MOV qword ptr [RSP + 0x48],RCX
LAB_00101edb:
CALL 0x00101ae0
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x00101ef7
MOV RSI,qword ptr [RSP + 0x50]
SUB RSI,RDI
CALL 0x00101140
LAB_00101ef7:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x00101f0e
MOV RSI,qword ptr [RSP + 0x70]
SUB RSI,RDI
CALL 0x00101140
LAB_00101f0e:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00101f25
MOV RSI,qword ptr [RSP + 0x30]
SUB RSI,RDI
CALL 0x00101140
LAB_00101f25:
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x00101f6b
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RDI
CALL 0x00101140
JMP 0x00101f6b
LAB_00101f40:
MOV RAX,qword ptr [RBX + 0x10]
MOVQ XMM0,R13
MOVQ XMM1,RDX
MOV qword ptr [RBX + 0x10],0x0
PUNPCKLQDQ XMM0,XMM1
MOV qword ptr [R12 + 0x10],RAX
MOVUPS xmmword ptr [R12],XMM0
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_00101f6b:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010207d
ADD RSP,0x88
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101f98:
MOV qword ptr [RSP + 0x60],0x0
XOR R14D,R14D
MOV qword ptr [RSP + 0x70],0x0
JMP 0x00101d17
LAB_00101fb8:
MOV qword ptr [RSP + 0x60],0x0
XOR R15D,R15D
MOV qword ptr [RSP + 0x70],0x0
JMP 0x00101daf
LAB_00101fd8:
MOV qword ptr [RSP + 0x60],0x0
XOR R15D,R15D
XOR ECX,ECX
MOV qword ptr [RSP + 0x70],0x0
JMP 0x00101e4d
LAB_00101ff8:
MOV qword ptr [RSP + 0x40],0x0
XOR R15D,R15D
XOR ECX,ECX
MOV qword ptr [RSP + 0x50],0x0
JMP 0x00101ec5
LAB_00102014:
MOV EAX,dword ptr [R13]
MOV dword ptr [RDI],EAX
JMP 0x00101d17
LAB_00102020:
MOV EAX,dword ptr [RBP]
MOV dword ptr [RDI],EAX
JMP 0x00101daf
LAB_0010202a:
JNZ 0x00101e4d
MOV EAX,dword ptr [RSI]
MOV dword ptr [RCX],EAX
JMP 0x00101e4d
LAB_00102039:
JNZ 0x00101ec5
MOV EAX,dword ptr [RSI]
MOV dword ptr [RCX],EAX
JMP 0x00101ec5
LAB_00102050:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010207d
LAB_00102060:
CALL 0x00101110
NOP dword ptr [RAX]
LAB_00102068:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010207d
LAB_00102078:
CALL 0x00101110
LAB_0010207d:
CALL 0x00101150
LAB_00102082:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010207d
LEA RDI,[0x103078]
LAB_00102099:
CALL 0x001010f0
LAB_0010209e:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010207d
LEA RDI,[0x103078]
LAB_001020b5:
CALL 0x001010f0
LAB_001020ba:
ENDBR64
MOV RBX,RAX
JMP 0x00101190 | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
void *pvVar4;
long lVar5;
int4 *__dest;
ulong uVar6;
int4 *puVar7;
int8 *puVar8;
int in_CL;
int extraout_DL;
int4 *puVar9;
int uVar10;
int (*in_RSI) [16];
ulong uVar11;
vector vVar12;
int4 in_register_0000003c;
int in_R8B;
int in_R9B;
size_t sVar13;
long in_FS_OFFSET;
int4 *local_b8;
int in_stack_ffffffffffffff50;
int7 uStack_af;
int in_stack_ffffffffffffff58;
int7 uStack_a7;
int in_stack_ffffffffffffff60;
int in_stack_ffffffffffffff68;
int7 uStack_97;
long local_90;
long local_88;
int local_78 [16];
long local_68;
int local_58 [16];
int4 *local_48;
long lVar14;
puVar8 = (int8 *)CONCAT44(in_register_0000003c,param_1);
puVar9 = *(int4 **)*in_RSI;
uVar2 = *(int8 *)*in_RSI;
uVar3 = *(int8 *)(*in_RSI + 8);
lVar14 = *(long *)(in_FS_OFFSET + 0x28);
lVar5 = (long)*(int4 **)(*in_RSI + 8) - (long)puVar9;
if ((lVar5 == 4) || (puVar9 == *(int4 **)(*in_RSI + 8))) {
uVar1 = *(int8 *)in_RSI[1];
*(int8 *)in_RSI[1] = 0;
puVar8[2] = uVar1;
*puVar8 = uVar2;
puVar8[1] = uVar3;
*in_RSI = (int [16])0x0;
LAB_00101f6b:
if (lVar14 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar8;
}
}
else {
local_48 = (int4 *)0x0;
lVar5 = lVar5 * 0x20000000 >> 0x20;
local_58 = (int [16])0x0;
uVar6 = lVar5 * 4;
if (uVar6 < 0x7ffffffffffffffd) {
if (uVar6 == 0) {
local_58._0_8_ = (int4 *)0x0;
puVar7 = (int4 *)0x0;
local_48 = (int4 *)0x0;
}
else {
/* try { // try from 00101cec to 00101cf0 has its CatchHandler @ 001020c6 */
__dest = (int4 *)operator_new(uVar6);
puVar7 = __dest + lVar5;
local_58._0_8_ = __dest;
local_48 = puVar7;
if (uVar6 == 4) {
*__dest = *puVar9;
}
else {
memmove(__dest,puVar9,uVar6);
}
}
local_58._8_8_ = puVar7;
uVar10 = SUB81(local_58,0);
/* try { // try from 00101d2a to 00101d2e has its CatchHandler @ 001020ba */
func0((vector)&local_b8);
if ((void *)local_58._0_8_ != (void *)0x0) {
uVar11 = (long)local_48 - local_58._0_8_;
operator_delete((void *)local_58._0_8_,uVar11);
uVar10 = (int)uVar11;
}
puVar9 = (int4 *)(uVar6 + *(long *)*in_RSI);
local_48 = (int4 *)0x0;
local_58 = (int [16])0x0;
uVar6 = *(long *)(*in_RSI + 8) - (long)puVar9;
if (uVar6 < 0x7ffffffffffffffd) {
if (uVar6 == 0) {
local_58._0_8_ = (int4 *)0x0;
lVar5 = 0;
local_48 = (int4 *)0x0;
}
else {
/* try { // try from 00101d84 to 00101d88 has its CatchHandler @ 001020d2 */
puVar7 = (int4 *)operator_new(uVar6);
lVar5 = (long)puVar7 + uVar6;
local_58._0_8_ = puVar7;
local_48 = (int4 *)lVar5;
if ((long)uVar6 < 5) {
*puVar7 = *puVar9;
}
else {
memmove(puVar7,puVar9,uVar6);
}
}
local_58._8_8_ = lVar5;
/* try { // try from 00101dbf to 00101dc3 has its CatchHandler @ 001020de */
func0((vector)&stack0xffffffffffffff68);
if ((void *)local_58._0_8_ != (void *)0x0) {
operator_delete((void *)local_58._0_8_,(long)local_48 - local_58._0_8_);
}
local_48 = (int4 *)0x0;
local_58 = (int [16])0x0;
uVar6 = local_90 - CONCAT71(uStack_97,in_stack_ffffffffffffff68);
if (uVar6 != 0) {
if (uVar6 < 0x7ffffffffffffffd) {
/* try { // try from 00101e13 to 00101e17 has its CatchHandler @ 001020f6 */
puVar9 = (int4 *)operator_new(uVar6);
puVar7 = (int4 *)CONCAT71(uStack_97,in_stack_ffffffffffffff68);
local_48 = (int4 *)(uVar6 + (long)puVar9);
local_58._0_8_ = puVar9;
sVar13 = local_90 - (long)puVar7;
if ((long)sVar13 < 5) {
if (sVar13 == 4) {
*puVar9 = *puVar7;
}
}
else {
puVar9 = (int4 *)memmove(puVar9,puVar7,sVar13);
}
goto LAB_00101e4d;
}
if (lVar14 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_0010207d;
/* try { // try from 00102060 to 00102064 has its CatchHandler @ 001020f6 */
std::__throw_bad_array_new_length();
LAB_00102068:
if (lVar14 == *(long *)(in_FS_OFFSET + 0x28)) {
/* try { // try from 00102078 to 0010207c has its CatchHandler @ 001020ea */
std::__throw_bad_array_new_length();
}
goto LAB_0010207d;
}
local_58._0_8_ = (int4 *)0x0;
sVar13 = 0;
puVar9 = (int4 *)0x0;
local_48 = (int4 *)0x0;
LAB_00101e4d:
local_68 = 0;
local_58._8_8_ = (long)puVar9 + sVar13;
local_78 = (int [16])0x0;
uVar6 = CONCAT71(uStack_af,in_stack_ffffffffffffff50) - (long)local_b8;
if (uVar6 == 0) {
local_78._0_8_ = (int4 *)0x0;
sVar13 = 0;
puVar9 = (int4 *)0x0;
local_68 = 0;
}
else {
if (0x7ffffffffffffffc < uVar6) goto LAB_00102068;
/* try { // try from 00101e8c to 00101e90 has its CatchHandler @ 001020ea */
puVar9 = (int4 *)operator_new(uVar6);
local_68 = uVar6 + (long)puVar9;
local_78._0_8_ = puVar9;
sVar13 = CONCAT71(uStack_af,in_stack_ffffffffffffff50) - (long)local_b8;
if ((long)sVar13 < 5) {
if (sVar13 == 4) {
*puVar9 = *local_b8;
}
}
else {
puVar9 = (int4 *)memmove(puVar9,local_b8,sVar13);
}
}
local_78._8_8_ = (long)puVar9 + sVar13;
/* try { // try from 00101edb to 00101edf has its CatchHandler @ 00102102 */
merge(param_1,(vector)local_78);
if ((void *)local_78._0_8_ != (void *)0x0) {
operator_delete((void *)local_78._0_8_,local_68 - local_78._0_8_);
}
if ((void *)local_58._0_8_ != (void *)0x0) {
operator_delete((void *)local_58._0_8_,(long)local_48 - local_58._0_8_);
}
pvVar4 = (void *)CONCAT71(uStack_97,in_stack_ffffffffffffff68);
if (pvVar4 != (void *)0x0) {
operator_delete(pvVar4,local_88 - (long)pvVar4);
}
if (local_b8 != (int4 *)0x0) {
operator_delete(local_b8,CONCAT71(uStack_a7,in_stack_ffffffffffffff58) - (long)local_b8);
}
goto LAB_00101f6b;
}
}
else {
if (lVar14 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_0010207d;
/* try { // try from 00102099 to 0010209d has its CatchHandler @ 001020c6 */
std::__throw_length_error("cannot create std::vector larger than max_size()");
uVar10 = SUB81(in_RSI,0);
}
if (lVar14 == *(long *)(in_FS_OFFSET + 0x28)) {
vVar12 = 0x103078;
/* try { // try from 001020b5 to 001020b9 has its CatchHandler @ 001020d2 */
std::__throw_length_error("cannot create std::vector larger than max_size()");
/* catch() { ... } // from try @ 00101d2a with catch @ 001020ba */
puVar8 = (int8 *)
func0(vVar12,uVar10,extraout_DL,in_CL,in_R8B,in_R9B,in_stack_ffffffffffffff50,
in_stack_ffffffffffffff58,in_stack_ffffffffffffff60,in_stack_ffffffffffffff68,
lVar14);
return puVar8;
}
}
LAB_0010207d:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
607 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
std::vector<int> merge(std::vector<int> a, std::vector<int> b) {
std::vector<int> c;
while (!a.empty() && !b.empty()) {
if (a.front() < b.front()) {
c.push_back(a.front());
a.erase(a.begin());
} else {
c.push_back(b.front());
b.erase(b.begin());
}
}
if (a.empty()) {
c.insert(c.end(), b.begin(), b.end());
} else {
c.insert(c.end(), a.begin(), a.end());
}
return c;
}
| std::vector<int> func0(std::vector<int> x) {
if (x.size() == 0 || x.size() == 1) {
return x;
} else {
int middle = x.size() / 2;
std::vector<int> a = func0(std::vector<int>(x.begin(), x.begin() + middle));
std::vector<int> b = func0(std::vector<int>(x.begin() + middle, x.end()));
return merge(a, b);
}
}
| int main() {
std::vector<int> v1 = {3, 4, 2, 6, 5, 7, 1, 9};
std::vector<int> r1 = {1, 2, 3, 4, 5, 6, 7, 9};
assert(func0(v1) == r1);
std::vector<int> v2 = {7, 25, 45, 78, 11, 33, 19};
std::vector<int> r2 = {7, 11, 19, 25, 33, 45, 78};
assert(func0(v2) == r2);
std::vector<int> v3 = {3, 1, 4, 9, 8};
std::vector<int> r3 = {1, 3, 4, 8, 9};
assert(func0(v3) == r3);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x88,%rsp
mov 0x8(%rsi),%rdx
mov (%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
mov %rdx,%rax
sub %rbp,%rax
cmp $0x4,%rax
je 1c40 <_Z5func0St6vectorIiSaIiEE+0x2c0>
cmp %rdx,%rbp
je 1c40 <_Z5func0St6vectorIiSaIiEE+0x2c0>
shl $0x1d,%rax
pxor %xmm0,%xmm0
movabs $0x1fffffffffffffff,%rdx
movq $0x0,0x70(%rsp)
sar $0x20,%rax
movaps %xmm0,0x60(%rsp)
lea 0x0(,%rax,4),%r13
cmp %rdx,%rax
ja 1cd4 <_Z5func0St6vectorIiSaIiEE+0x354>
test %rax,%rax
je 1c90 <_Z5func0St6vectorIiSaIiEE+0x310>
mov %r13,%rdi
callq 1170 <_Znwm@plt>
mov %rax,%rdi
lea (%rdi,%r13,1),%r14
mov %rdi,0x60(%rsp)
mov %r14,0x70(%rsp)
test %r13,%r13
je 1a32 <_Z5func0St6vectorIiSaIiEE+0xb2>
mov %r13,%rdx
mov %rbp,%rsi
callq 1140 <memcpy@plt>
mov %r14,0x68(%rsp)
lea 0x60(%rsp),%r14
mov %rsp,%rdi
mov %r14,%rsi
callq 1980 <_Z5func0St6vectorIiSaIiEE>
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 1a56 <_Z5func0St6vectorIiSaIiEE+0xd6>
callq 1160 <_ZdlPv@plt>
mov 0x8(%rbx),%rbp
add (%rbx),%r13
pxor %xmm0,%xmm0
movq $0x0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
mov %rbp,%r15
sub %r13,%r15
mov %r15,%rax
sar $0x2,%rax
test %r15,%r15
js 1ce5 <_Z5func0St6vectorIiSaIiEE+0x365>
test %rax,%rax
je 1cb0 <_Z5func0St6vectorIiSaIiEE+0x330>
mov %r15,%rdi
callq 1170 <_Znwm@plt>
mov %rax,%rdi
lea (%rdi,%r15,1),%rbx
mov %rdi,0x60(%rsp)
mov %rbx,0x70(%rsp)
cmp %rbp,%r13
je 1ab7 <_Z5func0St6vectorIiSaIiEE+0x137>
mov %r15,%rdx
mov %r13,%rsi
callq 1140 <memcpy@plt>
lea 0x20(%rsp),%rdi
mov %r14,%rsi
mov %rbx,0x68(%rsp)
callq 1980 <_Z5func0St6vectorIiSaIiEE>
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 1ad8 <_Z5func0St6vectorIiSaIiEE+0x158>
callq 1160 <_ZdlPv@plt>
mov 0x28(%rsp),%rax
mov 0x20(%rsp),%rsi
pxor %xmm0,%xmm0
movq $0x0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
mov %rax,%rbx
sub %rsi,%rbx
mov %rbx,%rdx
sar $0x2,%rdx
je 1cc0 <_Z5func0St6vectorIiSaIiEE+0x340>
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rdx
ja 1ce0 <_Z5func0St6vectorIiSaIiEE+0x360>
mov %rbx,%rdi
callq 1170 <_Znwm@plt>
mov %rax,%rcx
mov 0x28(%rsp),%rax
mov 0x20(%rsp),%rsi
mov %rax,%rbp
sub %rsi,%rbp
movq %rcx,%xmm0
add %rcx,%rbx
punpcklqdq %xmm0,%xmm0
mov %rbx,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
cmp %rsi,%rax
je 1b5e <_Z5func0St6vectorIiSaIiEE+0x1de>
mov %rcx,%rdi
mov %rbp,%rdx
callq 11a0 <memmove@plt>
mov %rax,%rcx
mov 0x8(%rsp),%rax
mov (%rsp),%rsi
add %rbp,%rcx
pxor %xmm0,%xmm0
mov %rcx,0x68(%rsp)
mov %rax,%rbx
movaps %xmm0,0x40(%rsp)
movq $0x0,0x50(%rsp)
sub %rsi,%rbx
mov %rbx,%rdx
sar $0x2,%rdx
je 1ca0 <_Z5func0St6vectorIiSaIiEE+0x320>
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rdx
ja 1ccf <_Z5func0St6vectorIiSaIiEE+0x34f>
mov %rbx,%rdi
callq 1170 <_Znwm@plt>
mov %rax,%rcx
mov 0x8(%rsp),%rax
mov (%rsp),%rsi
mov %rax,%rbp
sub %rsi,%rbp
movq %rcx,%xmm0
add %rcx,%rbx
punpcklqdq %xmm0,%xmm0
mov %rbx,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
cmp %rsi,%rax
je 1bea <_Z5func0St6vectorIiSaIiEE+0x26a>
mov %rcx,%rdi
mov %rbp,%rdx
callq 11a0 <memmove@plt>
mov %rax,%rcx
add %rbp,%rcx
lea 0x40(%rsp),%rsi
mov %r14,%rdx
mov %r12,%rdi
mov %rcx,0x48(%rsp)
callq 1820 <_Z5mergeSt6vectorIiSaIiEES1_>
mov 0x40(%rsp),%rdi
test %rdi,%rdi
je 1c11 <_Z5func0St6vectorIiSaIiEE+0x291>
callq 1160 <_ZdlPv@plt>
mov 0x60(%rsp),%rdi
test %rdi,%rdi
je 1c20 <_Z5func0St6vectorIiSaIiEE+0x2a0>
callq 1160 <_ZdlPv@plt>
mov 0x20(%rsp),%rdi
test %rdi,%rdi
je 1c2f <_Z5func0St6vectorIiSaIiEE+0x2af>
callq 1160 <_ZdlPv@plt>
mov (%rsp),%rdi
test %rdi,%rdi
je 1c6b <_Z5func0St6vectorIiSaIiEE+0x2eb>
callq 1160 <_ZdlPv@plt>
jmp 1c6b <_Z5func0St6vectorIiSaIiEE+0x2eb>
mov 0x10(%rbx),%rax
movq %rbp,%xmm0
movq %rdx,%xmm1
movq $0x0,0x10(%rbx)
punpcklqdq %xmm1,%xmm0
mov %rax,0x10(%r12)
movups %xmm0,(%r12)
pxor %xmm0,%xmm0
movups %xmm0,(%rbx)
mov 0x78(%rsp),%rax
xor %fs:0x28,%rax
jne 1cca <_Z5func0St6vectorIiSaIiEE+0x34a>
add $0x88,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xor %edi,%edi
jmpq 1a14 <_Z5func0St6vectorIiSaIiEE+0x94>
nopw 0x0(%rax,%rax,1)
mov %rbx,%rbp
xor %ecx,%ecx
jmpq 1bc1 <_Z5func0St6vectorIiSaIiEE+0x241>
nopw 0x0(%rax,%rax,1)
xor %edi,%edi
jmpq 1a99 <_Z5func0St6vectorIiSaIiEE+0x119>
nopw 0x0(%rax,%rax,1)
mov %rbx,%rbp
xor %ecx,%ecx
jmpq 1b35 <_Z5func0St6vectorIiSaIiEE+0x1b5>
callq 1180 <__stack_chk_fail@plt>
callq 1100 <_ZSt17__throw_bad_allocv@plt>
lea 0x132d(%rip),%rdi
callq 1120 <_ZSt20__throw_length_errorPKc@plt>
callq 1100 <_ZSt17__throw_bad_allocv@plt>
lea 0x131c(%rip),%rdi
callq 1120 <_ZSt20__throw_length_errorPKc@plt>
endbr64
mov %rax,%rbp
jmpq 11d6 <_Z5func0St6vectorIiSaIiEE.cold>
endbr64
mov %rax,%rbp
jmpq 1219 <_Z5func0St6vectorIiSaIiEE.cold+0x43>
endbr64
mov %rax,%rbp
jmpq 11fb <_Z5func0St6vectorIiSaIiEE.cold+0x25>
endbr64
mov %rax,%rbp
jmpq 11d6 <_Z5func0St6vectorIiSaIiEE.cold>
endbr64
mov %rax,%rbp
jmpq 1225 <_Z5func0St6vectorIiSaIiEE.cold+0x4f>
endbr64
mov %rax,%rbp
jmpq 123c <_Z5func0St6vectorIiSaIiEE.cold+0x66>
endbr64
mov %rax,%rbp
jmpq 120a <_Z5func0St6vectorIiSaIiEE.cold+0x34>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
mov rbx, rsi
sub rsp, 88h
mov rdx, [rsi+8]
mov rbp, [rsi]
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
mov rax, rdx
sub rax, rbp
cmp rax, 4
jz loc_1F20
cmp rbp, rdx
jz loc_1F20
shl rax, 1Dh
pxor xmm0, xmm0
mov [rsp+0B8h+var_48], 0
sar rax, 20h
movaps xmmword ptr [rsp+0B8h+var_58], xmm0
lea r12, ds:0[rax*4]
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, r12
jb loc_2062
test r12, r12
jz loc_1F78
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
lea r14, [rax+r12]
mov [rsp+0B8h+var_58], rax
mov rdi, rax; dest
mov [rsp+0B8h+var_48], r14
cmp r12, 4
jz loc_1FF4
mov rdx, r12; n
mov rsi, rbp; src
call _memmove
loc_1CF7:
mov [rsp+0B8h+var_58+8], r14
lea rbp, [rsp+0B8h+var_58]
mov r14, rsp
mov rsi, rbp
mov rdi, r14
call _Z5func0St6vectorIiSaIiEE; func0(std::vector<int>)
mov rdi, [rsp+0B8h+var_58]; void *
test rdi, rdi
jz short loc_1D26
mov rsi, [rsp+0B8h+var_48]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1D26:
mov rax, [rbx+8]
add r12, [rbx]
pxor xmm0, xmm0
mov [rsp+0B8h+var_48], 0
movaps xmmword ptr [rsp+0B8h+var_58], xmm0
sub rax, r12
mov rbx, rax
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbx
jb loc_207E
test rbx, rbx
jz loc_1F98
mov rdi, rbx; unsigned __int64
call __Znwm; operator new(ulong)
lea r15, [rax+rbx]
mov [rsp+0B8h+var_58], rax
mov rdi, rax; dest
mov [rsp+0B8h+var_48], r15
cmp rbx, 4
jle loc_2000
mov rdx, rbx; n
mov rsi, r12; src
call _memmove
loc_1D8F:
lea rbx, [rsp+0B8h+src]
mov rsi, rbp
mov [rsp+0B8h+var_58+8], r15
mov rdi, rbx
call _Z5func0St6vectorIiSaIiEE; func0(std::vector<int>)
mov rdi, [rsp+0B8h+var_58]; void *
test rdi, rdi
jz short loc_1DBB
mov rsi, [rsp+0B8h+var_48]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1DBB:
pxor xmm0, xmm0
mov r12, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_48], 0
movaps xmmword ptr [rsp+0B8h+var_58], xmm0
sub r12, [rsp+0B8h+src]
jz loc_1FB8
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, r12
jb loc_2030
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
mov rsi, [rsp+0B8h+src]; src
mov r15, [rsp+0B8h+var_90]
add r12, rax
mov rcx, rax
mov [rsp+0B8h+var_58], rax
sub r15, rsi
mov [rsp+0B8h+var_48], r12
cmp r15, 4
jle loc_200B
mov rdx, r15; n
mov rdi, rax; dest
call _memmove
mov rcx, rax
loc_1E2D:
add rcx, r15
pxor xmm0, xmm0
mov r12, [rsp+0B8h+var_B0]
mov [rsp+0B8h+var_68], 0
mov [rsp+0B8h+var_58+8], rcx
movaps xmmword ptr [rsp+0B8h+var_78], xmm0
sub r12, [rsp+0B8h+var_B8]
jz loc_1FD8
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, r12
jb loc_2048
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
mov rsi, [rsp+0B8h+var_B8]; src
mov r15, [rsp+0B8h+var_B0]
add r12, rax
mov rcx, rax
mov [rsp+0B8h+var_78], rax
sub r15, rsi
mov [rsp+0B8h+var_68], r12
cmp r15, 4
jle loc_201A
mov rdx, r15; n
mov rdi, rax; dest
call _memmove
mov rcx, rax
loc_1EA5:
lea r12, [rsp+0B8h+var_78]
add rcx, r15
mov rdx, rbp
mov rdi, r13
mov rsi, r12
mov [rsp+0B8h+var_78+8], rcx
call _Z5mergeSt6vectorIiSaIiEES1_; merge(std::vector<int>,std::vector<int>)
mov rdi, [rsp+0B8h+var_78]; void *
test rdi, rdi
jz short loc_1ED7
mov rsi, [rsp+0B8h+var_68]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1ED7:
mov rdi, [rsp+0B8h+var_58]; void *
test rdi, rdi
jz short loc_1EEE
mov rsi, [rsp+0B8h+var_48]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1EEE:
mov rdi, [rsp+0B8h+src]; void *
test rdi, rdi
jz short loc_1F05
mov rsi, [rsp+0B8h+var_88]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F05:
mov rdi, [rsp+0B8h+var_B8]; void *
test rdi, rdi
jz short loc_1F4A
mov rsi, [rsp+0B8h+var_A8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1F4A
loc_1F20:
mov rax, [rbx+10h]
movq xmm0, rbp
movq xmm1, rdx
mov qword ptr [rbx+10h], 0
punpcklqdq xmm0, xmm1
mov [r13+10h], rax
movups xmmword ptr [r13+0], xmm0
pxor xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_1F4A:
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz loc_205D
add rsp, 88h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1F78:
mov [rsp+0B8h+var_58], 0
xor r14d, r14d
mov [rsp+0B8h+var_48], 0
jmp loc_1CF7
loc_1F98:
mov [rsp+0B8h+var_58], 0
xor r15d, r15d
mov [rsp+0B8h+var_48], 0
jmp loc_1D8F
loc_1FB8:
mov [rsp+0B8h+var_58], 0
xor r15d, r15d
xor ecx, ecx
mov [rsp+0B8h+var_48], 0
jmp loc_1E2D
loc_1FD8:
mov [rsp+0B8h+var_78], 0
xor r15d, r15d
xor ecx, ecx
mov [rsp+0B8h+var_68], 0
jmp loc_1EA5
loc_1FF4:
mov eax, [rbp+0]
mov [rdi], eax
jmp loc_1CF7
loc_2000:
mov eax, [r12]
mov [rdi], eax
jmp loc_1D8F
loc_200B:
jnz loc_1E2D
mov eax, [rsi]
mov [rcx], eax
jmp loc_1E2D
loc_201A:
jnz loc_1EA5
mov eax, [rsi]
mov [rcx], eax
jmp loc_1EA5
loc_2030:
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz short loc_205D
call __ZSt28__throw_bad_array_new_lengthv; std::__throw_bad_array_new_length(void)
nop dword ptr [rax]
loc_2048:
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz short loc_205D
call __ZSt28__throw_bad_array_new_lengthv; std::__throw_bad_array_new_length(void)
loc_205D:
call ___stack_chk_fail
loc_2062:
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz short loc_205D
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_207E:
mov rax, [rsp+0B8h+var_40]
sub rax, fs:28h
jnz short loc_205D
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
endbr64
mov r12, rax
jmp loc_119B
endbr64
mov rbx, rax
jmp loc_11CE
endbr64
mov r13, rax
jmp _Z5func0St6vectorIiSaIiEE_cold; func0(std::vector<int>) [clone]
endbr64
mov rbx, rax
jmp loc_11EB
endbr64
mov rbx, rax
jmp loc_11AE
endbr64
mov r12, rax
jmp loc_11A3 | __m128i * func0(__m128i *a1, long long a2)
{
char *v2; // rdx
char *v3; // rbp
size_t v4; // r12
_DWORD *v5; // rax
_DWORD *v6; // r14
long long v7; // rax
_DWORD *v8; // r12
signed long long v9; // rbx
_DWORD *v10; // rax
char *v11; // r15
unsigned long long v12; // r12
char *v13; // rax
char *v14; // rcx
signed long long v15; // r15
unsigned long long v16; // r12
char *v17; // rax
char *v18; // rcx
signed long long v19; // r15
long long v20; // rax
void *v22; // [rsp+0h] [rbp-B8h] BYREF
_BYTE *v23; // [rsp+8h] [rbp-B0h]
long long v24; // [rsp+10h] [rbp-A8h]
void *src; // [rsp+20h] [rbp-98h] BYREF
_BYTE *v26; // [rsp+28h] [rbp-90h]
long long v27; // [rsp+30h] [rbp-88h]
void *v28[2]; // [rsp+40h] [rbp-78h] BYREF
char *v29; // [rsp+50h] [rbp-68h]
void *v30[2]; // [rsp+60h] [rbp-58h] BYREF
char *v31; // [rsp+70h] [rbp-48h]
unsigned long long v32; // [rsp+78h] [rbp-40h]
v2 = *(char **)(a2 + 8);
v3 = *(char **)a2;
v32 = __readfsqword(0x28u);
if ( v2 - v3 == 4 || v3 == v2 )
{
v20 = *(_QWORD *)(a2 + 16);
*(_QWORD *)(a2 + 16) = 0LL;
a1[1].m128i_i64[0] = v20;
*a1 = _mm_unpacklo_epi64((__m128i)(unsigned long long)v3, (__m128i)(unsigned long long)v2);
*(_OWORD *)a2 = 0LL;
return a1;
}
v31 = 0LL;
*(_OWORD *)v30 = 0LL;
v4 = (int)((v2 - v3) >> 3);
if ( v4 > 0x1FFFFFFFFFFFFFFFLL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( v4 * 4 )
{
v5 = (_DWORD *)operator new(4LL * (int)((v2 - v3) >> 3));
v6 = &v5[v4];
v30[0] = v5;
v31 = (char *)&v5[v4];
if ( v4 == 1 )
*v5 = *(_DWORD *)v3;
else
memmove(v5, v3, v4 * 4);
}
else
{
v30[0] = 0LL;
v6 = 0LL;
v31 = 0LL;
}
v30[1] = v6;
func0(&v22, v30);
if ( v30[0] )
operator delete(v30[0], v31 - (char *)v30[0]);
v7 = *(_QWORD *)(a2 + 8);
v8 = (_DWORD *)(*(_QWORD *)a2 + v4 * 4);
v31 = 0LL;
*(_OWORD *)v30 = 0LL;
v9 = v7 - (_QWORD)v8;
if ( (unsigned long long)(v7 - (_QWORD)v8) > 0x7FFFFFFFFFFFFFFCLL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( v9 )
{
v10 = (_DWORD *)operator new(v9);
v11 = (char *)v10 + v9;
v30[0] = v10;
v31 = (char *)v10 + v9;
if ( v9 <= 4 )
*v10 = *v8;
else
memmove(v10, v8, v9);
}
else
{
v30[0] = 0LL;
v11 = 0LL;
v31 = 0LL;
}
v30[1] = v11;
func0(&src, v30);
if ( v30[0] )
operator delete(v30[0], v31 - (char *)v30[0]);
v31 = 0LL;
*(_OWORD *)v30 = 0LL;
v12 = v26 - (_BYTE *)src;
if ( v26 == src )
{
v30[0] = 0LL;
v15 = 0LL;
v14 = 0LL;
v31 = 0LL;
}
else
{
if ( v12 > 0x7FFFFFFFFFFFFFFCLL )
{
std::__throw_bad_array_new_length();
goto LABEL_44;
}
v13 = (char *)operator new(v26 - (_BYTE *)src);
v14 = v13;
v30[0] = v13;
v15 = v26 - (_BYTE *)src;
v31 = &v13[v12];
if ( v26 - (_BYTE *)src <= 4 )
{
if ( v26 - (_BYTE *)src == 4 )
*(_DWORD *)v13 = *(_DWORD *)src;
}
else
{
v14 = (char *)memmove(v13, src, v26 - (_BYTE *)src);
}
}
v29 = 0LL;
v30[1] = &v14[v15];
*(_OWORD *)v28 = 0LL;
v16 = v23 - (_BYTE *)v22;
if ( v23 != v22 )
{
if ( v16 <= 0x7FFFFFFFFFFFFFFCLL )
{
v17 = (char *)operator new(v23 - (_BYTE *)v22);
v18 = v17;
v28[0] = v17;
v19 = v23 - (_BYTE *)v22;
v29 = &v17[v16];
if ( v23 - (_BYTE *)v22 <= 4 )
{
if ( v23 - (_BYTE *)v22 == 4 )
*(_DWORD *)v17 = *(_DWORD *)v22;
}
else
{
v18 = (char *)memmove(v17, v22, v23 - (_BYTE *)v22);
}
goto LABEL_23;
}
LABEL_44:
std::__throw_bad_array_new_length();
}
v28[0] = 0LL;
v19 = 0LL;
v18 = 0LL;
v29 = 0LL;
LABEL_23:
v28[1] = &v18[v19];
merge(a1, v28, v30);
if ( v28[0] )
operator delete(v28[0], v29 - (char *)v28[0]);
if ( v30[0] )
operator delete(v30[0], v31 - (char *)v30[0]);
if ( src )
operator delete(src, v27 - (_QWORD)src);
if ( v22 )
operator delete(v22, v24 - (_QWORD)v22);
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x88
MOV RDX,qword ptr [RSI + 0x8]
MOV RBP,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV RAX,RDX
SUB RAX,RBP
CMP RAX,0x4
JZ 0x00101f20
CMP RBP,RDX
JZ 0x00101f20
SHL RAX,0x1d
PXOR XMM0,XMM0
MOV qword ptr [RSP + 0x70],0x0
SAR RAX,0x20
MOVAPS xmmword ptr [RSP + 0x60],XMM0
LEA R12,[RAX*0x4]
MOV RAX,0x7ffffffffffffffc
CMP RAX,R12
JC 0x00102062
TEST R12,R12
JZ 0x00101f78
MOV RDI,R12
LAB_00101ccc:
CALL 0x00101130
LEA R14,[RAX + R12*0x1]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,RAX
MOV qword ptr [RSP + 0x70],R14
CMP R12,0x4
JZ 0x00101ff4
MOV RDX,R12
MOV RSI,RBP
CALL 0x00101160
LAB_00101cf7:
MOV qword ptr [RSP + 0x68],R14
LEA RBP,[RSP + 0x60]
MOV R14,RSP
MOV RSI,RBP
MOV RDI,R14
LAB_00101d0a:
CALL 0x00101c40
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x00101d26
MOV RSI,qword ptr [RSP + 0x70]
SUB RSI,RDI
CALL 0x00101140
LAB_00101d26:
MOV RAX,qword ptr [RBX + 0x8]
ADD R12,qword ptr [RBX]
PXOR XMM0,XMM0
MOV qword ptr [RSP + 0x70],0x0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
SUB RAX,R12
MOV RBX,RAX
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBX
JC 0x0010207e
TEST RBX,RBX
JZ 0x00101f98
MOV RDI,RBX
LAB_00101d64:
CALL 0x00101130
LEA R15,[RAX + RBX*0x1]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,RAX
MOV qword ptr [RSP + 0x70],R15
CMP RBX,0x4
JLE 0x00102000
MOV RDX,RBX
MOV RSI,R12
CALL 0x00101160
LAB_00101d8f:
LEA RBX,[RSP + 0x20]
MOV RSI,RBP
MOV qword ptr [RSP + 0x68],R15
MOV RDI,RBX
LAB_00101d9f:
CALL 0x00101c40
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x00101dbb
MOV RSI,qword ptr [RSP + 0x70]
SUB RSI,RDI
CALL 0x00101140
LAB_00101dbb:
PXOR XMM0,XMM0
MOV R12,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x70],0x0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
SUB R12,qword ptr [RSP + 0x20]
JZ 0x00101fb8
MOV RAX,0x7ffffffffffffffc
CMP RAX,R12
JC 0x00102030
MOV RDI,R12
LAB_00101df3:
CALL 0x00101130
MOV RSI,qword ptr [RSP + 0x20]
MOV R15,qword ptr [RSP + 0x28]
ADD R12,RAX
MOV RCX,RAX
MOV qword ptr [RSP + 0x60],RAX
SUB R15,RSI
MOV qword ptr [RSP + 0x70],R12
CMP R15,0x4
JLE 0x0010200b
MOV RDX,R15
MOV RDI,RAX
CALL 0x00101160
MOV RCX,RAX
LAB_00101e2d:
ADD RCX,R15
PXOR XMM0,XMM0
MOV R12,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x68],RCX
MOVAPS xmmword ptr [RSP + 0x40],XMM0
SUB R12,qword ptr [RSP]
JZ 0x00101fd8
MOV RAX,0x7ffffffffffffffc
CMP RAX,R12
JC 0x00102048
MOV RDI,R12
LAB_00101e6c:
CALL 0x00101130
MOV RSI,qword ptr [RSP]
MOV R15,qword ptr [RSP + 0x8]
ADD R12,RAX
MOV RCX,RAX
MOV qword ptr [RSP + 0x40],RAX
SUB R15,RSI
MOV qword ptr [RSP + 0x50],R12
CMP R15,0x4
JLE 0x0010201a
MOV RDX,R15
MOV RDI,RAX
CALL 0x00101160
MOV RCX,RAX
LAB_00101ea5:
LEA R12,[RSP + 0x40]
ADD RCX,R15
MOV RDX,RBP
MOV RDI,R13
MOV RSI,R12
MOV qword ptr [RSP + 0x48],RCX
LAB_00101ebb:
CALL 0x00101ac0
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x00101ed7
MOV RSI,qword ptr [RSP + 0x50]
SUB RSI,RDI
CALL 0x00101140
LAB_00101ed7:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x00101eee
MOV RSI,qword ptr [RSP + 0x70]
SUB RSI,RDI
CALL 0x00101140
LAB_00101eee:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00101f05
MOV RSI,qword ptr [RSP + 0x30]
SUB RSI,RDI
CALL 0x00101140
LAB_00101f05:
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x00101f4a
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RDI
CALL 0x00101140
JMP 0x00101f4a
LAB_00101f20:
MOV RAX,qword ptr [RBX + 0x10]
MOVQ XMM0,RBP
MOVQ XMM1,RDX
MOV qword ptr [RBX + 0x10],0x0
PUNPCKLQDQ XMM0,XMM1
MOV qword ptr [R13 + 0x10],RAX
MOVUPS xmmword ptr [R13],XMM0
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_00101f4a:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010205d
ADD RSP,0x88
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101f78:
MOV qword ptr [RSP + 0x60],0x0
XOR R14D,R14D
MOV qword ptr [RSP + 0x70],0x0
JMP 0x00101cf7
LAB_00101f98:
MOV qword ptr [RSP + 0x60],0x0
XOR R15D,R15D
MOV qword ptr [RSP + 0x70],0x0
JMP 0x00101d8f
LAB_00101fb8:
MOV qword ptr [RSP + 0x60],0x0
XOR R15D,R15D
XOR ECX,ECX
MOV qword ptr [RSP + 0x70],0x0
JMP 0x00101e2d
LAB_00101fd8:
MOV qword ptr [RSP + 0x40],0x0
XOR R15D,R15D
XOR ECX,ECX
MOV qword ptr [RSP + 0x50],0x0
JMP 0x00101ea5
LAB_00101ff4:
MOV EAX,dword ptr [RBP]
MOV dword ptr [RDI],EAX
JMP 0x00101cf7
LAB_00102000:
MOV EAX,dword ptr [R12]
MOV dword ptr [RDI],EAX
JMP 0x00101d8f
LAB_0010200b:
JNZ 0x00101e2d
MOV EAX,dword ptr [RSI]
MOV dword ptr [RCX],EAX
JMP 0x00101e2d
LAB_0010201a:
JNZ 0x00101ea5
MOV EAX,dword ptr [RSI]
MOV dword ptr [RCX],EAX
JMP 0x00101ea5
LAB_00102030:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010205d
LAB_00102040:
CALL 0x00101110
NOP dword ptr [RAX]
LAB_00102048:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010205d
LAB_00102058:
CALL 0x00101110
LAB_0010205d:
CALL 0x00101150
LAB_00102062:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010205d
LEA RDI,[0x103078]
LAB_00102079:
CALL 0x001010f0
LAB_0010207e:
MOV RAX,qword ptr [RSP + 0x78]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010205d
LEA RDI,[0x103078]
LAB_00102095:
CALL 0x001010f0
LAB_0010209a:
ENDBR64
MOV R12,RAX
JMP 0x0010119b | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1)
{
int8 uVar1;
int8 uVar2;
long lVar3;
int4 *puVar4;
int8 uVar5;
vector<int,std::allocator<int>> *pvVar6;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
int8 *puVar7;
int4 *puVar8;
ulong uVar9;
vector<int,std::allocator<int>> *unaff_R14;
size_t sVar10;
long in_FS_OFFSET;
int4 *local_b8;
long local_b0;
long local_a8;
int4 *local_98;
long local_90;
long local_88;
int local_78 [16];
long local_68;
int local_58 [16];
vector<int,std::allocator<int>> *local_48;
long local_40;
puVar7 = (int8 *)CONCAT44(in_register_0000003c,param_1);
pvVar6 = *(vector<int,std::allocator<int>> **)in_RSI;
uVar5 = *(int8 *)in_RSI;
uVar2 = *(int8 *)(in_RSI + 8);
local_40 = *(long *)(in_FS_OFFSET + 0x28);
lVar3 = (long)*(vector<int,std::allocator<int>> **)(in_RSI + 8) - (long)pvVar6;
if ((lVar3 == 4) || (pvVar6 == *(vector<int,std::allocator<int>> **)(in_RSI + 8))) {
uVar1 = *(int8 *)(in_RSI + 0x10);
*(int8 *)(in_RSI + 0x10) = 0;
puVar7[2] = uVar1;
*puVar7 = uVar5;
puVar7[1] = uVar2;
*(int (*) [16])in_RSI = (int [16])0x0;
LAB_00101f4a:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar7;
}
}
else {
local_48 = (vector<int,std::allocator<int>> *)0x0;
lVar3 = lVar3 * 0x20000000 >> 0x20;
local_58 = (int [16])0x0;
uVar9 = lVar3 * 4;
if (uVar9 < 0x7ffffffffffffffd) {
if (uVar9 == 0) {
local_58._0_8_ = (int4 *)0x0;
puVar8 = (int4 *)0x0;
local_48 = (vector<int,std::allocator<int>> *)0x0;
}
else {
puVar4 = (int4 *)operator_new(uVar9);
puVar8 = puVar4 + lVar3;
local_58._0_8_ = puVar4;
local_48 = (vector<int,std::allocator<int>> *)puVar8;
if (uVar9 == 4) {
*puVar4 = *(int4 *)pvVar6;
}
else {
memmove(puVar4,pvVar6,uVar9);
}
}
local_58._8_8_ = puVar8;
pvVar6 = (vector<int,std::allocator<int>> *)local_58;
/* try { // try from 00101d0a to 00101d0e has its CatchHandler @ 001020a6 */
func0((vector)&local_b8);
if ((void *)local_58._0_8_ != (void *)0x0) {
operator_delete((void *)local_58._0_8_,(long)local_48 - local_58._0_8_);
}
puVar8 = (int4 *)(uVar9 + *(long *)in_RSI);
local_48 = (vector<int,std::allocator<int>> *)0x0;
local_58 = (int [16])0x0;
in_RSI = (vector<int,std::allocator<int>> *)(*(long *)(in_RSI + 8) - (long)puVar8);
unaff_R14 = (vector<int,std::allocator<int>> *)&local_b8;
if (in_RSI < (vector<int,std::allocator<int>> *)0x7ffffffffffffffd) {
if (in_RSI == (vector<int,std::allocator<int>> *)0x0) {
local_58._0_8_ = (int4 *)0x0;
pvVar6 = (vector<int,std::allocator<int>> *)0x0;
local_48 = (vector<int,std::allocator<int>> *)0x0;
}
else {
/* try { // try from 00101d64 to 00101d68 has its CatchHandler @ 001020ca */
puVar4 = (int4 *)operator_new((ulong)in_RSI);
pvVar6 = (vector<int,std::allocator<int>> *)((long)puVar4 + (long)in_RSI);
local_58._0_8_ = puVar4;
local_48 = pvVar6;
if ((long)in_RSI < 5) {
*puVar4 = *puVar8;
}
else {
memmove(puVar4,puVar8,(size_t)in_RSI);
}
}
local_58._8_8_ = pvVar6;
/* try { // try from 00101d9f to 00101da3 has its CatchHandler @ 001020be */
func0((vector)&local_98);
if ((void *)local_58._0_8_ != (void *)0x0) {
operator_delete((void *)local_58._0_8_,(long)local_48 - local_58._0_8_);
}
local_48 = (vector<int,std::allocator<int>> *)0x0;
local_58 = (int [16])0x0;
uVar9 = local_90 - (long)local_98;
if (uVar9 != 0) {
if (uVar9 < 0x7ffffffffffffffd) {
/* try { // try from 00101df3 to 00101df7 has its CatchHandler @ 001020d6 */
puVar8 = (int4 *)operator_new(uVar9);
local_48 = (vector<int,std::allocator<int>> *)(uVar9 + (long)puVar8);
local_58._0_8_ = puVar8;
sVar10 = local_90 - (long)local_98;
if ((long)sVar10 < 5) {
if (sVar10 == 4) {
*puVar8 = *local_98;
}
}
else {
puVar8 = (int4 *)memmove(puVar8,local_98,sVar10);
}
goto LAB_00101e2d;
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_0010205d;
/* try { // try from 00102040 to 00102044 has its CatchHandler @ 001020d6 */
std::__throw_bad_array_new_length();
LAB_00102048:
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* try { // try from 00102058 to 0010205c has its CatchHandler @ 0010209a */
std::__throw_bad_array_new_length();
}
goto LAB_0010205d;
}
local_58._0_8_ = (int4 *)0x0;
sVar10 = 0;
puVar8 = (int4 *)0x0;
local_48 = (vector<int,std::allocator<int>> *)0x0;
LAB_00101e2d:
local_68 = 0;
local_58._8_8_ = (long)puVar8 + sVar10;
local_78 = (int [16])0x0;
uVar9 = local_b0 - (long)local_b8;
if (uVar9 == 0) {
local_78._0_8_ = (int4 *)0x0;
sVar10 = 0;
puVar8 = (int4 *)0x0;
local_68 = 0;
}
else {
if (0x7ffffffffffffffc < uVar9) goto LAB_00102048;
/* try { // try from 00101e6c to 00101e70 has its CatchHandler @ 0010209a */
puVar8 = (int4 *)operator_new(uVar9);
local_68 = uVar9 + (long)puVar8;
local_78._0_8_ = puVar8;
sVar10 = local_b0 - (long)local_b8;
if ((long)sVar10 < 5) {
if (sVar10 == 4) {
*puVar8 = *local_b8;
}
}
else {
puVar8 = (int4 *)memmove(puVar8,local_b8,sVar10);
}
}
local_78._8_8_ = (long)puVar8 + sVar10;
/* try { // try from 00101ebb to 00101ebf has its CatchHandler @ 001020b2 */
merge(param_1,(vector)local_78);
if ((void *)local_78._0_8_ != (void *)0x0) {
operator_delete((void *)local_78._0_8_,local_68 - local_78._0_8_);
}
if ((void *)local_58._0_8_ != (void *)0x0) {
operator_delete((void *)local_58._0_8_,(long)local_48 - local_58._0_8_);
}
if (local_98 != (int4 *)0x0) {
operator_delete(local_98,local_88 - (long)local_98);
}
if (local_b8 != (int4 *)0x0) {
operator_delete(local_b8,local_a8 - (long)local_b8);
}
goto LAB_00101f4a;
}
}
else {
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_0010205d;
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* try { // try from 00102095 to 00102099 has its CatchHandler @ 001020ca */
uVar5 = std::__throw_length_error("cannot create std::vector larger than max_size()");
std::vector<int,std::allocator<int>>::~vector(pvVar6);
std::vector<int,std::allocator<int>>::~vector(in_RSI);
std::vector<int,std::allocator<int>>::~vector(unaff_R14);
/* catch() { ... } // from try @ 00101e6c with catch @ 0010209a
catch() { ... } // from try @ 00102058 with catch @ 0010209a */
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar5);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
}
LAB_0010205d:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
608 | func0 |
#include <assert.h>
#include <tuple>
| std::tuple<double, double> func0(double a, double b, double c) {
double x = -b / (2 * a);
double y = ((4 * a * c) - (b * b)) / (4 * a);
return std::make_tuple(x, y);
}
| int main() {
assert(func0(5,3,2) == std::make_tuple(-0.3, 1.55));
assert(func0(9,8,4) == std::make_tuple(-0.4444444444444444, 2.2222222222222223));
assert(func0(2,4,6) == std::make_tuple(-1.0, 4.0));
return 0;
}
| O0 | cpp | func0(double, double, double):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
movsd %xmm0,-0x30(%rbp)
movsd %xmm1,-0x38(%rbp)
movsd %xmm2,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movsd -0x38(%rbp),%xmm0
movq 0xf5c(%rip),%xmm1
xorpd %xmm0,%xmm1
movsd -0x30(%rbp),%xmm0
addsd %xmm0,%xmm0
divsd %xmm0,%xmm1
movapd %xmm1,%xmm0
movsd %xmm0,-0x18(%rbp)
movsd -0x30(%rbp),%xmm1
movsd 0xf45(%rip),%xmm0
mulsd %xmm1,%xmm0
movapd %xmm0,%xmm1
mulsd -0x40(%rbp),%xmm1
movsd -0x38(%rbp),%xmm0
mulsd %xmm0,%xmm0
subsd %xmm0,%xmm1
movapd %xmm1,%xmm0
movsd -0x30(%rbp),%xmm2
movsd 0xf1a(%rip),%xmm1
mulsd %xmm2,%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x10(%rbp)
mov -0x28(%rbp),%rax
lea -0x10(%rbp),%rdx
lea -0x18(%rbp),%rcx
mov %rcx,%rsi
mov %rax,%rdi
callq 1475 <_ZSt10make_tupleIJRdS0_EESt5tupleIJDpNSt17__decay_and_stripIT_E6__typeEEEDpOS3_>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
je 124e <_Z5func0ddd+0xc5>
callq 1080 <__stack_chk_fail@plt>
mov -0x28(%rbp),%rax
leaveq
retq
| _Z5func0ddd:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
movsd [rbp+var_30], xmm0
movsd [rbp+var_38], xmm1
movsd [rbp+var_40], xmm2
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
movsd xmm0, [rbp+var_38]
movq xmm1, cs:qword_2100
xorpd xmm1, xmm0
movsd xmm0, [rbp+var_30]
movapd xmm2, xmm0
addsd xmm2, xmm0
divsd xmm1, xmm2
movapd xmm0, xmm1
movsd [rbp+var_18], xmm0
movsd xmm1, [rbp+var_30]
movsd xmm0, cs:dbl_2110
mulsd xmm0, xmm1
movapd xmm1, xmm0
mulsd xmm1, [rbp+var_40]
movsd xmm0, [rbp+var_38]
movapd xmm2, xmm0
mulsd xmm2, xmm0
movapd xmm0, xmm1
subsd xmm0, xmm2
movsd xmm2, [rbp+var_30]
movsd xmm1, cs:dbl_2110
mulsd xmm1, xmm2
divsd xmm0, xmm1
movsd [rbp+var_10], xmm0
mov rax, [rbp+var_28]
lea rdx, [rbp+var_10]
lea rcx, [rbp+var_18]
mov rsi, rcx
mov rdi, rax
call _ZSt10make_tupleIJRdS0_EESt5tupleIJDpNSt25__strip_reference_wrapperINSt5decayIT_E4typeEE6__typeEEEDpOS4_; std::make_tuple<double &,double &>(double &,double &&&)
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short loc_1236
call ___stack_chk_fail
loc_1236:
mov rax, [rbp+var_28]
leave
retn | long long func0(
double a1,
double a2,
double a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9)
{
double v10; // [rsp+28h] [rbp-18h] BYREF
double v11[2]; // [rsp+30h] [rbp-10h] BYREF
*(_QWORD *)&v11[1] = __readfsqword(0x28u);
v10 = -a2 / (a1 + a1);
v11[0] = (4.0 * a1 * a3 - a2 * a2) / (4.0 * a1);
std::make_tuple<double &,double &>(a4, &v10, v11, &v10, a8, a9, *(_QWORD *)&a3, *(_QWORD *)&a2, *(_QWORD *)&a1);
return a4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOVSD qword ptr [RBP + -0x30],XMM0
MOVSD qword ptr [RBP + -0x38],XMM1
MOVSD qword ptr [RBP + -0x40],XMM2
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOVSD XMM0,qword ptr [RBP + -0x38]
MOVQ XMM1,qword ptr [0x00102100]
XORPD XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0x30]
MOVAPD XMM2,XMM0
ADDSD XMM2,XMM0
DIVSD XMM1,XMM2
MOVAPD XMM0,XMM1
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x30]
MOVSD XMM0,qword ptr [0x00102110]
MULSD XMM0,XMM1
MOVAPD XMM1,XMM0
MULSD XMM1,qword ptr [RBP + -0x40]
MOVSD XMM0,qword ptr [RBP + -0x38]
MOVAPD XMM2,XMM0
MULSD XMM2,XMM0
MOVAPD XMM0,XMM1
SUBSD XMM0,XMM2
MOVSD XMM2,qword ptr [RBP + -0x30]
MOVSD XMM1,qword ptr [0x00102110]
MULSD XMM1,XMM2
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x10],XMM0
MOV RAX,qword ptr [RBP + -0x28]
LEA RDX,[RBP + -0x10]
LEA RCX,[RBP + -0x18]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101452
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101236
CALL 0x00101070
LAB_00101236:
MOV RAX,qword ptr [RBP + -0x28]
LEAVE
RET | /* func0(double, double, double) */
double * func0(double param_1,double param_2,double param_3)
{
double *in_RDI;
long in_FS_OFFSET;
double local_20;
double local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (double)(DAT_00102100 ^ (ulong)param_2) / (param_1 + param_1);
local_18 = (DAT_00102110 * param_1 * param_3 - param_2 * param_2) / (DAT_00102110 * param_1);
std::make_tuple<double&,double&>(in_RDI,&local_20);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return in_RDI;
} |
609 | func0 |
#include <assert.h>
#include <tuple>
| std::tuple<double, double> func0(double a, double b, double c) {
double x = -b / (2 * a);
double y = ((4 * a * c) - (b * b)) / (4 * a);
return std::make_tuple(x, y);
}
| int main() {
assert(func0(5,3,2) == std::make_tuple(-0.3, 1.55));
assert(func0(9,8,4) == std::make_tuple(-0.4444444444444444, 2.2222222222222223));
assert(func0(2,4,6) == std::make_tuple(-1.0, 4.0));
return 0;
}
| O1 | cpp | func0(double, double, double):
endbr64
mov %rdi,%rax
movapd %xmm0,%xmm3
mulsd 0xecc(%rip),%xmm3
mulsd %xmm3,%xmm2
movapd %xmm1,%xmm4
mulsd %xmm1,%xmm4
subsd %xmm4,%xmm2
divsd %xmm3,%xmm2
movsd %xmm2,(%rdi)
xorpd 0xeb4(%rip),%xmm1
addsd %xmm0,%xmm0
divsd %xmm0,%xmm1
movsd %xmm1,0x8(%rdi)
retq
| _Z5func0ddd:
endbr64
mov rax, rdi
movapd xmm3, xmm0
mulsd xmm3, cs:qword_2008
mulsd xmm2, xmm3
movapd xmm4, xmm1
mulsd xmm4, xmm1
subsd xmm2, xmm4
divsd xmm2, xmm3
movsd qword ptr [rdi], xmm2
xorpd xmm1, cs:xmmword_2010
addsd xmm0, xmm0
divsd xmm1, xmm0
movsd qword ptr [rdi+8], xmm1
retn | double * func0(double a1, double a2, double a3, double *a4)
{
double *result; // rax
result = a4;
*a4 = (a3 * (a1 * 4.0) - a2 * a2) / (a1 * 4.0);
a4[1] = -a2 / (a1 + a1);
return result;
} | func0:
ENDBR64
MOV RAX,RDI
MOVAPD XMM3,XMM0
MULSD XMM3,qword ptr [0x00102008]
MULSD XMM2,XMM3
MOVAPD XMM4,XMM1
MULSD XMM4,XMM1
SUBSD XMM2,XMM4
DIVSD XMM2,XMM3
MOVSD qword ptr [RDI],XMM2
XORPD XMM1,xmmword ptr [0x00102010]
ADDSD XMM0,XMM0
DIVSD XMM1,XMM0
MOVSD qword ptr [RDI + 0x8],XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double, double) */
void func0(double param_1,double param_2,double param_3)
{
double *in_RDI;
*in_RDI = (param_3 * param_1 * _DAT_00102008 - param_2 * param_2) / (param_1 * _DAT_00102008);
in_RDI[1] = (double)((ulong)param_2 ^ _DAT_00102010) / (param_1 + param_1);
return;
} |
610 | func0 |
#include <assert.h>
#include <tuple>
| std::tuple<double, double> func0(double a, double b, double c) {
double x = -b / (2 * a);
double y = ((4 * a * c) - (b * b)) / (4 * a);
return std::make_tuple(x, y);
}
| int main() {
assert(func0(5,3,2) == std::make_tuple(-0.3, 1.55));
assert(func0(9,8,4) == std::make_tuple(-0.4444444444444444, 2.2222222222222223));
assert(func0(2,4,6) == std::make_tuple(-1.0, 4.0));
return 0;
}
| O2 | cpp | func0(double, double, double):
endbr64
movsd 0xebc(%rip),%xmm3
movapd %xmm1,%xmm4
mov %rdi,%rax
mulsd %xmm1,%xmm4
xorpd 0xeb1(%rip),%xmm1
mulsd %xmm0,%xmm3
addsd %xmm0,%xmm0
divsd %xmm0,%xmm1
mulsd %xmm3,%xmm2
subsd %xmm4,%xmm2
divsd %xmm3,%xmm2
movsd %xmm1,0x8(%rdi)
movsd %xmm2,(%rdi)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0ddd:
endbr64
unpcklpd xmm0, xmm0
mov rax, rdi
mulpd xmm0, cs:xmmword_2010
movapd xmm3, xmm0
mulsd xmm3, xmm2
movapd xmm2, xmm1
mulsd xmm2, xmm1
xorpd xmm1, cs:xmmword_2020
subsd xmm3, xmm2
unpcklpd xmm3, xmm1
divpd xmm3, xmm0
movups xmmword ptr [rdi], xmm3
retn | __m128d * func0(__m128d a1, __m128d a2, double a3, __m128d *a4)
{
__m128d *result; // rax
__m128d v5; // xmm0
__m128d v6; // xmm3
result = a4;
v5 = _mm_mul_pd(_mm_unpacklo_pd(a1, a1), (__m128d)xmmword_2010);
v6.m128d_f64[1] = v5.m128d_f64[1];
v6.m128d_f64[0] = v5.m128d_f64[0] * a3 - a2.m128d_f64[0] * a2.m128d_f64[0];
*a4 = _mm_div_pd(_mm_unpacklo_pd(v6, _mm_xor_pd(a2, (__m128d)xmmword_2020)), v5);
return result;
} | func0:
ENDBR64
UNPCKLPD XMM0,XMM0
MOV RAX,RDI
MULPD XMM0,xmmword ptr [0x00102010]
MOVAPD XMM3,XMM0
MULSD XMM3,XMM2
MOVAPD XMM2,XMM1
MULSD XMM2,XMM1
XORPD XMM1,xmmword ptr [0x00102020]
SUBSD XMM3,XMM2
UNPCKLPD XMM3,XMM1
DIVPD XMM3,XMM0
MOVUPS xmmword ptr [RDI],XMM3
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double, double) */
void func0(double param_1,double param_2,double param_3)
{
int (*in_RDI) [16];
int auVar1 [16];
int auVar2 [16];
auVar1._0_8_ = param_1 * _DAT_00102010 * param_3 - param_2 * param_2;
auVar1._8_8_ = (ulong)param_2 ^ _DAT_00102020;
auVar2._8_8_ = param_1 * _UNK_00102018;
auVar2._0_8_ = param_1 * _DAT_00102010;
auVar2 = divpd(auVar1,auVar2);
*in_RDI = auVar2;
return;
} |
611 | func0 |
#include <assert.h>
#include <tuple>
| std::tuple<double, double> func0(double a, double b, double c) {
double x = -b / (2 * a);
double y = ((4 * a * c) - (b * b)) / (4 * a);
return std::make_tuple(x, y);
}
| int main() {
assert(func0(5,3,2) == std::make_tuple(-0.3, 1.55));
assert(func0(9,8,4) == std::make_tuple(-0.4444444444444444, 2.2222222222222223));
assert(func0(2,4,6) == std::make_tuple(-1.0, 4.0));
return 0;
}
| O3 | cpp | func0(double, double, double):
endbr64
movsd 0xebc(%rip),%xmm3
movapd %xmm1,%xmm4
mov %rdi,%rax
mulsd %xmm1,%xmm4
xorpd 0xeb1(%rip),%xmm1
mulsd %xmm0,%xmm3
addsd %xmm0,%xmm0
divsd %xmm0,%xmm1
mulsd %xmm3,%xmm2
subsd %xmm4,%xmm2
divsd %xmm3,%xmm2
movsd %xmm1,0x8(%rdi)
movsd %xmm2,(%rdi)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0ddd:
endbr64
unpcklpd xmm0, xmm0
mov rax, rdi
mulpd xmm0, cs:xmmword_2010
movapd xmm3, xmm0
mulsd xmm3, xmm2
movapd xmm2, xmm1
mulsd xmm2, xmm1
xorpd xmm1, cs:xmmword_2020
subsd xmm3, xmm2
unpcklpd xmm3, xmm1
divpd xmm3, xmm0
movups xmmword ptr [rdi], xmm3
retn | __m128d * func0(__m128d a1, __m128d a2, double a3, __m128d *a4)
{
__m128d *result; // rax
__m128d v5; // xmm0
__m128d v6; // xmm3
result = a4;
v5 = _mm_mul_pd(_mm_unpacklo_pd(a1, a1), (__m128d)xmmword_2010);
v6.m128d_f64[1] = v5.m128d_f64[1];
v6.m128d_f64[0] = v5.m128d_f64[0] * a3 - a2.m128d_f64[0] * a2.m128d_f64[0];
*a4 = _mm_div_pd(_mm_unpacklo_pd(v6, _mm_xor_pd(a2, (__m128d)xmmword_2020)), v5);
return result;
} | func0:
ENDBR64
UNPCKLPD XMM0,XMM0
MOV RAX,RDI
MULPD XMM0,xmmword ptr [0x00102010]
MOVAPD XMM3,XMM0
MULSD XMM3,XMM2
MOVAPD XMM2,XMM1
MULSD XMM2,XMM1
XORPD XMM1,xmmword ptr [0x00102020]
SUBSD XMM3,XMM2
UNPCKLPD XMM3,XMM1
DIVPD XMM3,XMM0
MOVUPS xmmword ptr [RDI],XMM3
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double, double) */
void func0(double param_1,double param_2,double param_3)
{
int (*in_RDI) [16];
int auVar1 [16];
int auVar2 [16];
auVar1._0_8_ = param_1 * _DAT_00102010 * param_3 - param_2 * param_2;
auVar1._8_8_ = (ulong)param_2 ^ _DAT_00102020;
auVar2._8_8_ = param_1 * _UNK_00102018;
auVar2._0_8_ = param_1 * _DAT_00102010;
auVar2 = divpd(auVar1,auVar2);
*in_RDI = auVar2;
return;
} |
612 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<std::vector<int>>& nums, int N) {
std::vector<int> result;
for (const auto& i : nums) {
result.push_back(i[N]);
}
return result;
}
| int main() {
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 0) == std::vector<int>{1, 4, 7}));
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 2) == std::vector<int>{3, 6, 9}));
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 3) == std::vector<int>{2, 2, 5}));
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
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 -0x48(%rbp),%rax
mov %rax,%rdi
callq 20c8 <_ZNSt6vectorIiSaIiEEC1Ev>
mov -0x50(%rbp),%rax
mov %rax,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 21ce <_ZNKSt6vectorIS_IiSaIiEESaIS1_EE5beginEv>
mov %rax,-0x38(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 2226 <_ZNKSt6vectorIS_IiSaIiEESaIS1_EE3endEv>
mov %rax,-0x30(%rbp)
lea -0x30(%rbp),%rdx
lea -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 227e <_ZN9__gnu_cxxneIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESD_>
test %al,%al
je 137e <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xd5>
lea -0x38(%rbp),%rax
mov %rax,%rdi
callq 22e2 <_ZNK9__gnu_cxx17__normal_iteratorIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEdeEv>
mov %rax,-0x20(%rbp)
mov -0x54(%rbp),%eax
movslq %eax,%rdx
mov -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 22f8 <_ZNKSt6vectorIiSaIiEEixEm>
mov %rax,%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 231c <_ZNSt6vectorIiSaIiEE9push_backERKi>
lea -0x38(%rbp),%rax
mov %rax,%rdi
callq 22be <_ZN9__gnu_cxx17__normal_iteratorIPKSt6vectorIiSaIiEES1_IS3_SaIS3_EEEppEv>
jmp 1304 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x5b>
endbr64
mov %rax,%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 2186 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 11b0 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 1393 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xea>
callq 1170 <__stack_chk_fail@plt>
mov -0x48(%rbp),%rax
add $0x58,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
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 rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rax, [rbp+var_50]
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_1369
loc_1326:
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 eax, [rbp+var_54]
movsxd rdx, eax
mov rax, [rbp+var_20]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rdx, rax
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
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_1369:
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_1326
jmp short loc_13B4
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_13AC
call ___stack_chk_fail
loc_13AC:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_13B4:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_13C8
call ___stack_chk_fail
loc_13C8:
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; // rax
long long v6; // [rsp+28h] [rbp-38h] BYREF
_QWORD v7[2]; // [rsp+30h] [rbp-30h] BYREF
long long v8; // [rsp+40h] [rbp-20h]
unsigned long long v9; // [rsp+48h] [rbp-18h]
v9 = __readfsqword(0x28u);
std::vector<int>::vector(a1);
v7[1] = a2;
v6 = std::vector<std::vector<int>>::begin(a2);
v7[0] = std::vector<std::vector<int>>::end(a2);
while ( (unsigned __int8)__gnu_cxx::operator!=<std::vector<int> const*,std::vector<std::vector<int>>>(&v6, v7) )
{
v8 = __gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>>::operator*(&v6);
v3 = std::vector<int>::operator[](v8, a3);
std::vector<int>::push_back(a1, v3);
__gnu_cxx::__normal_iterator<std::vector<int> const*,std::vector<std::vector<int>>>::operator++(&v6);
}
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 RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00102154
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00102252
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x0010229e
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00101369
LAB_00101326:
LEA RAX,[RBP + -0x38]
MOV RDI,RAX
CALL 0x00102352
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x54]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102368
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
LAB_00101358:
CALL 0x0010238c
LEA RAX,[RBP + -0x38]
MOV RDI,RAX
CALL 0x0010232e
LAB_00101369:
LEA RDX,[RBP + -0x30]
LEA RAX,[RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001022ee
TEST AL,AL
JNZ 0x00101326
JMP 0x001013b4
LAB_001013b4:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001013c8
CALL 0x00101190
LAB_001013c8:
MOV RAX,qword ptr [RBP + -0x48]
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) */
vector * func0(vector *param_1,int param_2)
{
bool bVar1;
int *piVar2;
int in_EDX;
int4 in_register_00000034;
long in_FS_OFFSET;
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);
std::vector<int,std::allocator<int>>::vector((vector<int,std::allocator<int>> *)param_1);
local_30 = (vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
*)CONCAT44(in_register_00000034,param_2);
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>>>>
*)CONCAT44(in_register_00000034,param_2));
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);
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](local_28,(long)in_EDX);
/* try { // try from 00101358 to 0010135c has its CatchHandler @ 00101382 */
std::vector<int,std::allocator<int>>::push_back
((vector<int,std::allocator<int>> *)param_1,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_40);
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
613 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<std::vector<int>>& nums, int N) {
std::vector<int> result;
for (const auto& i : nums) {
result.push_back(i[N]);
}
return result;
}
| int main() {
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 0) == std::vector<int>{1, 4, 7}));
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 2) == std::vector<int>{3, 6, 9}));
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 3) == std::vector<int>{2, 2, 5}));
return 0;
}
| O1 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbp
mov 0x8(%rsi),%r13
cmp %r13,%rbp
je 1353 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x8a>
movslq %edx,%rdx
lea 0x0(,%rdx,4),%r12
jmp 131b <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x52>
mov %rbx,%rdi
callq 1d1c <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
add $0x18,%rbp
cmp %rbp,%r13
je 1353 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x8a>
mov %r12,%rdx
add 0x0(%rbp),%rdx
mov 0x8(%rbx),%rsi
cmp 0x10(%rbx),%rsi
je 130a <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x41>
mov (%rdx),%eax
mov %eax,(%rsi)
addq $0x4,0x8(%rbx)
jmp 1312 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x49>
endbr64
mov %rax,%rbp
mov (%rbx),%rdi
test %rdi,%rdi
je 134b <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x82>
callq 1170 <_ZdlPv@plt>
mov %rbp,%rdi
callq 11d0 <_Unwind_Resume@plt>
mov %rbx,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rbp, [rsi]
mov r13, [rsi+8]
cmp r13, rbp
jz short loc_134E
movsxd rdx, edx
lea r12, ds:0[rdx*4]
jmp short loc_131B
loc_130A:
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_1312:
add rbp, 18h
cmp r13, rbp
jz short loc_134E
loc_131B:
mov rdx, r12
add rdx, [rbp+0]
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jz short loc_130A
mov eax, [rdx]
mov [rsi], eax
add qword ptr [rbx+8], 4
jmp short loc_1312
endbr64
mov rbp, rax
mov rdi, rbx
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rdi, rbp; struct _Unwind_Exception *
call __Unwind_Resume
loc_134E:
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn | _QWORD * func0(_QWORD *a1, long long a2, int a3)
{
_QWORD *v3; // rbp
_QWORD *v4; // r13
long long v5; // r12
_DWORD *v6; // rdx
_DWORD *v7; // rsi
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v3 = *(_QWORD **)a2;
v4 = *(_QWORD **)(a2 + 8);
if ( v4 != *(_QWORD **)a2 )
{
v5 = 4LL * a3;
do
{
v6 = (_DWORD *)(*v3 + v5);
v7 = (_DWORD *)a1[1];
if ( v7 == (_DWORD *)a1[2] )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v7, v6);
}
else
{
*v7 = *v6;
a1[1] += 4LL;
}
v3 += 3;
}
while ( v4 != v3 );
}
return a1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBP,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
CMP R13,RBP
JZ 0x0010134e
MOVSXD RDX,EDX
LEA R12,[RDX*0x4]
JMP 0x0010131b
LAB_0010130a:
MOV RDI,RBX
LAB_0010130d:
CALL 0x00101d24
LAB_00101312:
ADD RBP,0x18
CMP R13,RBP
JZ 0x0010134e
LAB_0010131b:
MOV RDX,R12
ADD RDX,qword ptr [RBP]
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JZ 0x0010130a
MOV EAX,dword ptr [RDX]
MOV dword ptr [RSI],EAX
ADD qword ptr [RBX + 0x8],0x4
JMP 0x00101312
LAB_0010134e:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int) */
vector * func0(vector *param_1,int param_2)
{
long *plVar1;
int *piVar2;
int in_EDX;
int *piVar3;
long *plVar4;
int4 in_register_00000034;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
plVar4 = *(long **)CONCAT44(in_register_00000034,param_2);
plVar1 = (long *)((long *)CONCAT44(in_register_00000034,param_2))[1];
if (plVar1 != plVar4) {
do {
piVar3 = (int *)((long)in_EDX * 4 + *plVar4);
piVar2 = *(int **)(param_1 + 8);
if (piVar2 == *(int **)(param_1 + 0x10)) {
/* try { // try from 0010130d to 00101311 has its CatchHandler @ 00101337 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar2,piVar3);
}
else {
*piVar2 = *piVar3;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 4;
}
plVar4 = plVar4 + 3;
} while (plVar1 != plVar4);
}
return param_1;
} |
614 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<std::vector<int>>& nums, int N) {
std::vector<int> result;
for (const auto& i : nums) {
result.push_back(i[N]);
}
return result;
}
| int main() {
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 0) == std::vector<int>{1, 4, 7}));
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 2) == std::vector<int>{3, 6, 9}));
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 3) == std::vector<int>{2, 2, 5}));
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov (%rsi),%rbx
mov 0x8(%rsi),%r15
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
cmp %r15,%rbx
je 1a8e <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x10e>
movslq %edx,%rdx
xor %eax,%eax
xor %r12d,%r12d
lea 0x0(,%rdx,4),%r14
jmp 19f5 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x75>
xchg %ax,%ax
mov 0x0(%rbp),%eax
add $0x4,%r12
add $0x18,%rbx
mov %eax,-0x4(%r12)
mov %r12,0x8(%r13)
cmp %rbx,%r15
je 1a8e <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x10e>
mov 0x8(%r13),%r12
mov 0x10(%r13),%rax
mov (%rbx),%rbp
add %r14,%rbp
cmp %rax,%r12
jne 19d0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x50>
movabs $0x1fffffffffffffff,%rdi
mov 0x0(%r13),%rax
sub %rax,%r12
mov %rax,0x8(%rsp)
mov %r12,%rax
sar $0x2,%rax
cmp %rdi,%rax
je 1afe <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x17e>
test %rax,%rax
je 1af0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x170>
movabs $0x7ffffffffffffffc,%rsi
lea (%rax,%rax,1),%rdx
mov %rsi,0x10(%rsp)
cmp %rdx,%rax
jbe 1aa0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x120>
mov 0x10(%rsp),%rdi
callq 1180 <_Znwm@plt>
mov 0x10(%rsp),%r8
mov %rax,%rcx
add %rax,%r8
mov 0x0(%rbp),%eax
lea 0x4(%rcx,%r12,1),%rbp
mov %eax,(%rcx,%r12,1)
test %r12,%r12
jg 1ab0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x130>
cmpq $0x0,0x8(%rsp)
jne 1acd <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x14d>
add $0x18,%rbx
mov %rcx,0x0(%r13)
mov %rbp,0x8(%r13)
mov %r8,0x10(%r13)
cmp %rbx,%r15
jne 19ed <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x6d>
add $0x28,%rsp
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
test %rdx,%rdx
jne 1b0a <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x18a>
xor %r8d,%r8d
xor %ecx,%ecx
jmp 1a5c <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xdc>
nopl 0x0(%rax)
mov 0x8(%rsp),%rsi
mov %rcx,%rdi
mov %r12,%rdx
mov %r8,0x10(%rsp)
callq 11b0 <memmove@plt>
mov 0x10(%rsp),%r8
mov %rax,%rcx
mov 0x8(%rsp),%rdi
mov %rcx,0x18(%rsp)
mov %r8,0x10(%rsp)
callq 1170 <_ZdlPv@plt>
mov 0x18(%rsp),%rcx
mov 0x10(%rsp),%r8
jmp 1a75 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xf5>
nopl (%rax)
movq $0x4,0x10(%rsp)
jmpq 1a47 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xc7>
lea 0x4ff(%rip),%rdi
callq 1140 <_ZSt20__throw_length_errorPKc@plt>
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rdx
cmova %rax,%rdx
lea 0x0(,%rdx,4),%rax
mov %rax,0x10(%rsp)
jmpq 1a47 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xc7>
endbr64
mov %rax,%rbp
jmpq 11e0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi.cold>
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
mov rbx, [rsi]
mov r13, [rsi+8]
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
cmp r13, rbx
jz short loc_1A6A
movsxd rdx, edx
xor eax, eax
xor esi, esi
lea r12, ds:0[rdx*4]
jmp short loc_1A4E
loc_1A30:
mov eax, [rdx]
add rsi, 4
add rbx, 18h
mov [rsi-4], eax
mov [rbp+8], rsi
cmp r13, rbx
jz short loc_1A6A
loc_1A46:
mov rsi, [rbp+8]
mov rax, [rbp+10h]
loc_1A4E:
mov rdx, [rbx]
add rdx, r12
cmp rsi, rax
jnz short loc_1A30
mov rdi, rbp
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 rbx, 18h
cmp r13, rbx
jnz short loc_1A46
loc_1A6A:
add rsp, 8
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
retn
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi_cold; func0(std::vector<std::vector<int>> const&,int) [clone] | long long func0(long long a1, long long a2, int a3)
{
_QWORD *v3; // rbx
_QWORD *v4; // r13
long long v5; // rax
long long v6; // rsi
long long v7; // r12
long long v8; // rsi
_DWORD *v9; // rdx
v3 = *(_QWORD **)a2;
v4 = *(_QWORD **)(a2 + 8);
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
if ( v4 != v3 )
{
v5 = 0LL;
v6 = 0LL;
v7 = 4LL * a3;
while ( 1 )
{
v9 = (_DWORD *)(v7 + *v3);
if ( v6 == v5 )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v6, v9);
v3 += 3;
if ( v4 == v3 )
return a1;
}
else
{
v8 = v6 + 4;
v3 += 3;
*(_DWORD *)(v8 - 4) = *v9;
*(_QWORD *)(a1 + 8) = v8;
if ( v4 == v3 )
return a1;
}
v6 = *(_QWORD *)(a1 + 8);
v5 = *(_QWORD *)(a1 + 16);
}
}
return a1;
} | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
MOV RBX,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
CMP R13,RBX
JZ 0x00101a6a
MOVSXD RDX,EDX
XOR EAX,EAX
XOR ESI,ESI
LEA R12,[RDX*0x4]
JMP 0x00101a4e
LAB_00101a30:
MOV EAX,dword ptr [RDX]
ADD RSI,0x4
ADD RBX,0x18
MOV dword ptr [RSI + -0x4],EAX
MOV qword ptr [RBP + 0x8],RSI
CMP R13,RBX
JZ 0x00101a6a
LAB_00101a46:
MOV RSI,qword ptr [RBP + 0x8]
MOV RAX,qword ptr [RBP + 0x10]
LAB_00101a4e:
MOV RDX,qword ptr [RBX]
ADD RDX,R12
CMP RSI,RAX
JNZ 0x00101a30
MOV RDI,RBP
LAB_00101a5c:
CALL 0x00101c10
ADD RBX,0x18
CMP R13,RBX
JNZ 0x00101a46
LAB_00101a6a:
ADD RSP,0x8
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
RET | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int) */
vector * func0(vector *param_1,int param_2)
{
long *plVar1;
int *piVar2;
int in_EDX;
int *piVar3;
long *plVar4;
int4 in_register_00000034;
int *piVar5;
plVar4 = *(long **)CONCAT44(in_register_00000034,param_2);
plVar1 = (long *)((long *)CONCAT44(in_register_00000034,param_2))[1];
*(int (*) [16])param_1 = (int [16])0x0;
*(int8 *)(param_1 + 0x10) = 0;
if (plVar1 != plVar4) {
piVar2 = (int *)0x0;
piVar5 = (int *)0x0;
while( true ) {
piVar3 = (int *)(*plVar4 + (long)in_EDX * 4);
if (piVar5 == piVar2) {
/* try { // try from 00101a5c to 00101a60 has its CatchHandler @ 00101a78 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar5,piVar3);
}
else {
*piVar5 = *piVar3;
*(int **)(param_1 + 8) = piVar5 + 1;
}
if (plVar1 == plVar4 + 3) break;
plVar4 = plVar4 + 3;
piVar5 = *(int **)(param_1 + 8);
piVar2 = *(int **)(param_1 + 0x10);
}
}
return param_1;
} |
615 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<std::vector<int>>& nums, int N) {
std::vector<int> result;
for (const auto& i : nums) {
result.push_back(i[N]);
}
return result;
}
| int main() {
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 0) == std::vector<int>{1, 4, 7}));
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 2) == std::vector<int>{3, 6, 9}));
assert((func0({{1, 2, 3, 2}, {4, 5, 6, 2}, {7, 1, 9, 5}}, 3) == std::vector<int>{2, 2, 5}));
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&, int):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov (%rsi),%rbx
mov 0x8(%rsi),%r14
movups %xmm0,(%rdi)
movq $0x0,0x10(%rdi)
cmp %r14,%rbx
je 1a92 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x112>
movslq %edx,%rdx
xor %r8d,%r8d
xor %ecx,%ecx
lea 0x0(,%rdx,4),%r13
jmp 19ec <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x6c>
nopw %cs:0x0(%rax,%rax,1)
mov 0x0(%rbp),%eax
add $0x4,%rcx
add $0x18,%rbx
mov %eax,-0x4(%rcx)
mov %rcx,0x8(%r12)
cmp %rbx,%r14
je 1a92 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x112>
mov (%rbx),%rbp
add %r13,%rbp
cmp %r8,%rcx
jne 19d0 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x50>
movabs $0x1fffffffffffffff,%rdi
mov (%r12),%rax
sub %rax,%rcx
mov %rax,(%rsp)
mov %rcx,%rax
mov %rcx,%r15
sar $0x2,%rax
cmp %rdi,%rax
je 1b1e <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x19e>
test %rax,%rax
je 1b10 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x190>
movabs $0x7ffffffffffffffc,%rsi
lea (%rax,%rax,1),%rdx
mov %rsi,0x8(%rsp)
cmp %rdx,%rax
jbe 1aa8 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x128>
mov 0x8(%rsp),%rdi
callq 1180 <_Znwm@plt>
mov 0x8(%rsp),%r8
mov %rax,%r9
add %rax,%r8
mov 0x0(%rbp),%eax
lea 0x4(%r9,%r15,1),%rcx
mov %eax,(%r9,%r15,1)
test %r15,%r15
jg 1ab8 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x138>
cmpq $0x0,(%rsp)
jne 1ade <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x15e>
movq %r9,%xmm0
movq %rcx,%xmm1
add $0x18,%rbx
mov %r8,0x10(%r12)
punpcklqdq %xmm1,%xmm0
movups %xmm0,(%r12)
cmp %rbx,%r14
jne 19ec <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x6c>
add $0x28,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
test %rdx,%rdx
jne 1b2a <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0x1aa>
xor %r8d,%r8d
xor %r9d,%r9d
jmp 1a55 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xd5>
nopl (%rax)
mov (%rsp),%rsi
mov %r9,%rdi
mov %r15,%rdx
mov %rcx,0x10(%rsp)
mov %r8,0x8(%rsp)
callq 11b0 <memmove@plt>
mov 0x8(%rsp),%r8
mov 0x10(%rsp),%rcx
mov %rax,%r9
mov (%rsp),%rdi
mov %rcx,0x18(%rsp)
mov %r8,0x10(%rsp)
mov %r9,0x8(%rsp)
callq 1170 <_ZdlPv@plt>
mov 0x18(%rsp),%rcx
mov 0x10(%rsp),%r8
mov 0x8(%rsp),%r9
jmpq 1a6d <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xed>
nopw 0x0(%rax,%rax,1)
movq $0x4,0x8(%rsp)
jmpq 1a40 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xc0>
lea 0x667(%rip),%rdi
callq 1140 <_ZSt20__throw_length_errorPKc@plt>
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rdx
cmova %rax,%rdx
lea 0x0(,%rdx,4),%rax
mov %rax,0x8(%rsp)
jmpq 1a40 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi+0xc0>
endbr64
mov %rax,%rbp
jmpq 11f5 <_Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi.cold>
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
mov rbx, [rsi]
mov r14, [rsi+8]
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
cmp r14, rbx
jz loc_1B8B
movsxd rdx, edx
xor r8d, r8d
xor ecx, ecx
lea r13, ds:0[rdx*4]
jmp short loc_1AFC
loc_1AE0:
mov eax, [r12]
add rcx, 4
add rbx, 18h
mov [rcx-4], eax
mov [rbp+8], rcx
cmp r14, rbx
jz loc_1B8B
loc_1AFC:
mov r12, [rbx]
add r12, r13
cmp r8, rcx
jnz short loc_1AE0
mov rax, [rbp+0]
mov r15, r8
mov rdi, 1FFFFFFFFFFFFFFFh
sub r15, rax
mov [rsp+58h+src], rax
mov rax, r15
sar rax, 2
cmp rax, rdi
jz loc_1C8B
cmp [rsp+58h+src], r8
jz loc_1C00
lea rdx, [rax+rax]
cmp rdx, rax
jb loc_1C40
test rdx, rdx
jnz loc_1C68
xor r8d, r8d
xor r9d, r9d
loc_1B55:
mov eax, [r12]
lea rcx, [r9+r15+4]
mov [r9+r15], eax
test r15, r15
jg short loc_1BA0
cmp [rsp+58h+src], 0
jnz loc_1C58
loc_1B72:
add rbx, 18h
mov [rbp+0], r9
mov [rbp+8], rcx
mov [rbp+10h], r8
cmp r14, rbx
jnz loc_1AFC
loc_1B8B:
add rsp, 28h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1BA0:
mov rdx, r15; n
mov r15, [rsp+58h+src]
mov rdi, r9; dest
mov [rsp+58h+var_48], r8
mov [rsp+58h+var_50], rcx
mov rsi, r15; src
call _memmove
mov rcx, [rsp+58h+var_50]
mov r8, [rsp+58h+var_48]
mov r9, rax
mov rax, [rbp+10h]
sub rax, r15
mov rsi, rax; unsigned __int64
loc_1BD3:
mov rdi, [rsp+58h+src]; void *
mov [rsp+58h+var_40], r9
mov [rsp+58h+var_48], r8
mov [rsp+58h+var_50], rcx
call __ZdlPvm; operator delete(void *,ulong)
mov r9, [rsp+58h+var_40]
mov r8, [rsp+58h+var_48]
mov rcx, [rsp+58h+var_50]
jmp loc_1B72
loc_1C00:
add rax, 1
jb short loc_1C40
mov rdx, 1FFFFFFFFFFFFFFFh
cmp rax, rdx
cmova rax, rdx
shl rax, 2
mov [rsp+58h+var_50], rax
mov rdi, rax; unsigned __int64
loc_1C23:
call __Znwm; operator new(ulong)
mov r8, [rsp+58h+var_50]
mov r9, rax
add r8, rax
jmp loc_1B55
loc_1C40:
mov rax, 7FFFFFFFFFFFFFFCh
mov [rsp+58h+var_50], rax
mov rdi, rax
jmp short loc_1C23
loc_1C58:
mov rsi, [rbp+10h]
mov rax, [rsp+58h+src]
sub rsi, rax
jmp loc_1BD3
loc_1C68:
mov rax, 1FFFFFFFFFFFFFFFh
cmp rdx, rax
cmova rdx, rax
lea rax, ds:0[rdx*4]
mov [rsp+58h+var_50], rax
mov rdi, rax
jmp short loc_1C23
loc_1C8B:
lea rdi, aVectorMRealloc; "vector::_M_realloc_insert"
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIS_IiSaIiEESaIS1_EEi_cold; func0(std::vector<std::vector<int>> const&,int) [clone] | char ** func0(char **a1, long long a2, int a3)
{
_QWORD *v4; // rbx
_QWORD *v5; // r14
char *v6; // r8
long long v7; // rcx
long long v8; // r13
_DWORD *v9; // r12
signed long long v10; // r15
unsigned long long v11; // rax
unsigned long long v12; // rdx
char *v13; // r9
char *v15; // rax
unsigned long long v16; // rsi
bool v17; // cf
unsigned long long v18; // rax
unsigned long long v19; // rdi
char *src; // [rsp+0h] [rbp-58h]
long long v21; // [rsp+8h] [rbp-50h]
long long v22; // [rsp+8h] [rbp-50h]
long long v23; // [rsp+8h] [rbp-50h]
char *v24; // [rsp+10h] [rbp-48h]
char *v25; // [rsp+10h] [rbp-48h]
char *v26; // [rsp+18h] [rbp-40h]
v4 = *(_QWORD **)a2;
v5 = *(_QWORD **)(a2 + 8);
*(_OWORD *)a1 = 0LL;
a1[2] = 0LL;
if ( v5 != v4 )
{
v6 = 0LL;
v7 = 0LL;
v8 = 4LL * a3;
while ( 1 )
{
while ( 1 )
{
v9 = (_DWORD *)(v8 + *v4);
if ( v6 == (char *)v7 )
break;
v7 += 4LL;
v4 += 3;
*(_DWORD *)(v7 - 4) = *v9;
a1[1] = (char *)v7;
if ( v5 == v4 )
return a1;
}
v10 = v6 - *a1;
src = *a1;
v11 = v10 >> 2;
if ( v10 >> 2 == 0x1FFFFFFFFFFFFFFFLL )
std::__throw_length_error("vector::_M_realloc_insert");
if ( src == v6 )
break;
v12 = 2 * v11;
if ( 2 * v11 < v11 )
goto LABEL_21;
if ( !v12 )
{
v6 = 0LL;
v13 = 0LL;
goto LABEL_10;
}
if ( v12 > 0x1FFFFFFFFFFFFFFFLL )
v12 = 0x1FFFFFFFFFFFFFFFLL;
v23 = 4 * v12;
v19 = 4 * v12;
LABEL_20:
v13 = (char *)operator new(v19);
v6 = &v13[v23];
LABEL_10:
v7 = (long long)&v13[v10 + 4];
*(_DWORD *)&v13[v10] = *v9;
if ( v10 > 0 )
{
v24 = v6;
v21 = (long long)&v13[v10 + 4];
v15 = (char *)memmove(v13, src, v10);
v7 = v21;
v6 = v24;
v13 = v15;
v16 = a1[2] - src;
LABEL_15:
v26 = v13;
v25 = v6;
v22 = v7;
operator delete(src, v16);
v13 = v26;
v6 = v25;
v7 = v22;
goto LABEL_12;
}
if ( src )
{
v16 = a1[2] - src;
goto LABEL_15;
}
LABEL_12:
v4 += 3;
*a1 = v13;
a1[1] = (char *)v7;
a1[2] = v6;
if ( v5 == v4 )
return a1;
}
v17 = __CFADD__(v11, 1LL);
v18 = v11 + 1;
if ( !v17 )
{
if ( v18 > 0x1FFFFFFFFFFFFFFFLL )
v18 = 0x1FFFFFFFFFFFFFFFLL;
v23 = 4 * v18;
v19 = 4 * v18;
goto LABEL_20;
}
LABEL_21:
v23 = 0x7FFFFFFFFFFFFFFCLL;
v19 = 0x7FFFFFFFFFFFFFFCLL;
goto LABEL_20;
}
return a1;
} | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x28
MOV RBX,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
CMP R14,RBX
JZ 0x00101b8b
MOVSXD RDX,EDX
XOR R8D,R8D
XOR ECX,ECX
LEA R13,[RDX*0x4]
JMP 0x00101afc
LAB_00101ae0:
MOV EAX,dword ptr [R12]
ADD RCX,0x4
ADD RBX,0x18
MOV dword ptr [RCX + -0x4],EAX
MOV qword ptr [RBP + 0x8],RCX
CMP R14,RBX
JZ 0x00101b8b
LAB_00101afc:
MOV R12,qword ptr [RBX]
ADD R12,R13
CMP R8,RCX
JNZ 0x00101ae0
MOV RAX,qword ptr [RBP]
MOV R15,R8
MOV RDI,0x1fffffffffffffff
SUB R15,RAX
MOV qword ptr [RSP],RAX
MOV RAX,R15
SAR RAX,0x2
CMP RAX,RDI
JZ 0x00101c8b
CMP qword ptr [RSP],R8
JZ 0x00101c00
LEA RDX,[RAX + RAX*0x1]
CMP RDX,RAX
JC 0x00101c40
TEST RDX,RDX
JNZ 0x00101c68
XOR R8D,R8D
XOR R9D,R9D
LAB_00101b55:
MOV EAX,dword ptr [R12]
LEA RCX,[R9 + R15*0x1 + 0x4]
MOV dword ptr [R9 + R15*0x1],EAX
TEST R15,R15
JG 0x00101ba0
CMP qword ptr [RSP],0x0
JNZ 0x00101c58
LAB_00101b72:
ADD RBX,0x18
MOV qword ptr [RBP],R9
MOV qword ptr [RBP + 0x8],RCX
MOV qword ptr [RBP + 0x10],R8
CMP R14,RBX
JNZ 0x00101afc
LAB_00101b8b:
ADD RSP,0x28
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101ba0:
MOV RDX,R15
MOV R15,qword ptr [RSP]
MOV RDI,R9
MOV qword ptr [RSP + 0x10],R8
MOV qword ptr [RSP + 0x8],RCX
MOV RSI,R15
CALL 0x001011d0
MOV RCX,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RSP + 0x10]
MOV R9,RAX
MOV RAX,qword ptr [RBP + 0x10]
SUB RAX,R15
MOV RSI,RAX
LAB_00101bd3:
MOV RDI,qword ptr [RSP]
MOV qword ptr [RSP + 0x18],R9
MOV qword ptr [RSP + 0x10],R8
MOV qword ptr [RSP + 0x8],RCX
CALL 0x001011a0
MOV R9,qword ptr [RSP + 0x18]
MOV R8,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x8]
JMP 0x00101b72
LAB_00101c00:
ADD RAX,0x1
JC 0x00101c40
MOV RDX,0x1fffffffffffffff
CMP RAX,RDX
CMOVA RAX,RDX
SHL RAX,0x2
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,RAX
LAB_00101c23:
CALL 0x00101190
MOV R8,qword ptr [RSP + 0x8]
MOV R9,RAX
ADD R8,RAX
JMP 0x00101b55
LAB_00101c40:
MOV RAX,0x7ffffffffffffffc
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,RAX
JMP 0x00101c23
LAB_00101c58:
MOV RSI,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RSP]
SUB RSI,RAX
JMP 0x00101bd3
LAB_00101c68:
MOV RAX,0x1fffffffffffffff
CMP RDX,RAX
CMOVA RDX,RAX
LEA RAX,[RDX*0x4]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,RAX
JMP 0x00101c23
LAB_00101c8b:
LEA RDI,[0x10216c]
CALL 0x00101150
LAB_00101c97:
ENDBR64
MOV RBX,RAX
JMP 0x0010121c | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > const&, int) */
vector * func0(vector *param_1,int param_2)
{
long *plVar1;
int4 *__src;
ulong uVar2;
void *__dest;
vector *pvVar3;
int4 *puVar4;
int in_EDX;
long *plVar5;
int iVar6;
int4 in_register_00000034;
long *plVar7;
char *pcVar8;
int4 *puVar9;
int4 *puVar10;
size_t __n;
ulong local_50;
plVar7 = (long *)CONCAT44(in_register_00000034,param_2);
plVar5 = (long *)*plVar7;
plVar1 = (long *)plVar7[1];
*(int (*) [16])param_1 = (int [16])0x0;
*(int8 *)(param_1 + 0x10) = 0;
if (plVar1 != plVar5) {
puVar9 = (int4 *)0x0;
puVar4 = (int4 *)0x0;
do {
while( true ) {
iVar6 = (int)plVar7;
puVar10 = (int4 *)(*plVar5 + (long)in_EDX * 4);
if (puVar9 != puVar4) break;
__src = *(int4 **)param_1;
__n = (long)puVar9 - (long)__src;
uVar2 = (long)__n >> 2;
if (uVar2 == 0x1fffffffffffffff) {
pcVar8 = "vector::_M_realloc_insert";
std::__throw_length_error("vector::_M_realloc_insert");
/* catch() { ... } // from try @ 00101c23 with catch @ 00101c97 */
pvVar3 = (vector *)func0((vector *)pcVar8,iVar6);
return pvVar3;
}
if (__src == puVar9) {
local_50 = uVar2 + 1;
if (0xfffffffffffffffe < uVar2) goto LAB_00101c40;
if (0x1fffffffffffffff < local_50) {
local_50 = 0x1fffffffffffffff;
}
local_50 = local_50 << 2;
LAB_00101c23:
/* try { // try from 00101c23 to 00101c96 has its CatchHandler @ 00101c97 */
__dest = operator_new(local_50);
puVar9 = (int4 *)(local_50 + (long)__dest);
}
else {
local_50 = uVar2 * 2;
if (local_50 < uVar2) {
LAB_00101c40:
local_50 = 0x7ffffffffffffffc;
goto LAB_00101c23;
}
if (local_50 != 0) {
if (0x1fffffffffffffff < local_50) {
local_50 = 0x1fffffffffffffff;
}
local_50 = local_50 * 4;
goto LAB_00101c23;
}
puVar9 = (int4 *)0x0;
__dest = (void *)0x0;
}
puVar4 = (int4 *)((long)__dest + __n + 4);
*(int4 *)((long)__dest + __n) = *puVar10;
if ((long)__n < 1) {
if (__src != (int4 *)0x0) {
plVar7 = (long *)(*(long *)(param_1 + 0x10) - (long)__src);
goto LAB_00101bd3;
}
}
else {
__dest = memmove(__dest,__src,__n);
plVar7 = (long *)(*(long *)(param_1 + 0x10) - (long)__src);
LAB_00101bd3:
operator_delete(__src,(ulong)plVar7);
}
plVar5 = plVar5 + 3;
*(void **)param_1 = __dest;
*(int4 **)(param_1 + 8) = puVar4;
*(int4 **)(param_1 + 0x10) = puVar9;
if (plVar1 == plVar5) {
return param_1;
}
}
plVar5 = plVar5 + 3;
*puVar4 = *puVar10;
*(int4 **)(param_1 + 8) = puVar4 + 1;
puVar4 = puVar4 + 1;
} while (plVar1 != plVar5);
}
return param_1;
} |
616 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int res = 0, count = 0, temp = n;
while (temp > 0) {
if (count % 2 == 1) {
res = res | (1 << count);
}
count++;
temp >>= 1;
}
return n ^ res;
}
| int main() {
assert(func0(10) == 0);
assert(func0(20) == 30);
assert(func0(30) == 20);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jle 11db <_Z5func0i+0x52>
mov -0x8(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 11d2 <_Z5func0i+0x49>
mov -0x8(%rbp),%eax
mov $0x1,%edx
mov %eax,%ecx
shl %cl,%edx
mov %edx,%eax
or %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
sarl -0x4(%rbp)
jmp 11a8 <_Z5func0i+0x1f>
mov -0x14(%rbp),%eax
xor -0xc(%rbp),%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
jmp short loc_119B
loc_116A:
mov edx, [rbp+var_8]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
jnz short loc_1194
mov eax, [rbp+var_8]
mov edx, 1
mov ecx, eax
shl edx, cl
mov eax, edx
or [rbp+var_C], eax
loc_1194:
add [rbp+var_8], 1
sar [rbp+var_4], 1
loc_119B:
cmp [rbp+var_4], 0
jg short loc_116A
mov eax, [rbp+var_14]
xor eax, [rbp+var_C]
pop rbp
retn | long long func0(int a1)
{
int v2; // [rsp+8h] [rbp-Ch]
int v3; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
v3 = 0;
for ( i = a1; i > 0; i >>= 1 )
{
if ( v3 % 2 == 1 )
v2 |= 1 << v3;
++v3;
}
return v2 ^ (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0010119b
LAB_0010116a:
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
JNZ 0x00101194
MOV EAX,dword ptr [RBP + -0x8]
MOV EDX,0x1
MOV ECX,EAX
SHL EDX,CL
MOV EAX,EDX
OR dword ptr [RBP + -0xc],EAX
LAB_00101194:
ADD dword ptr [RBP + -0x8],0x1
SAR dword ptr [RBP + -0x4],0x1
LAB_0010119b:
CMP dword ptr [RBP + -0x4],0x0
JG 0x0010116a
MOV EAX,dword ptr [RBP + -0x14]
XOR EAX,dword ptr [RBP + -0xc]
POP RBP
RET | /* func0(int) */
uint func0(int param_1)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
local_10 = 0;
for (local_c = param_1; 0 < local_c; local_c = local_c >> 1) {
if (local_10 % 2 == 1) {
local_14 = local_14 | 1 << ((byte)local_10 & 0x1f);
}
local_10 = local_10 + 1;
}
return param_1 ^ local_14;
} |
617 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int res = 0, count = 0, temp = n;
while (temp > 0) {
if (count % 2 == 1) {
res = res | (1 << count);
}
count++;
temp >>= 1;
}
return n ^ res;
}
| int main() {
assert(func0(10) == 0);
assert(func0(20) == 30);
assert(func0(30) == 20);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov %edi,%r10d
test %edi,%edi
jle 11d3 <_Z5func0i+0x4a>
mov %edi,%esi
mov $0x0,%ecx
mov $0x0,%eax
mov $0x1,%r9d
add $0x1,%ecx
sar %esi
test %esi,%esi
jle 11d8 <_Z5func0i+0x4f>
mov %ecx,%r8d
shr $0x1f,%r8d
lea (%rcx,%r8,1),%edx
and $0x1,%edx
sub %r8d,%edx
mov %eax,%r8d
mov %r9d,%edi
shl %cl,%edi
or %edi,%eax
cmp $0x1,%edx
cmovne %r8d,%eax
jmp 11a6 <_Z5func0i+0x1d>
mov $0x0,%eax
xor %r10d,%eax
retq
| _Z5func0i:
endbr64
mov eax, edi
test edi, edi
jle short loc_1198
mov r8d, edi
mov ecx, 0
mov esi, 0
mov r11d, 1
loc_1166:
mov r9d, ecx
shr r9d, 1Fh
lea edx, [rcx+r9]
and edx, 1
sub edx, r9d
mov r9d, esi
mov r10d, r11d
shl r10d, cl
or esi, r10d
cmp edx, 1
cmovnz esi, r9d
add ecx, 1
sar r8d, 1
test r8d, r8d
jg short loc_1166
loc_1195:
xor eax, esi
retn
loc_1198:
mov esi, 0
jmp short loc_1195 | long long func0(int a1)
{
int v1; // r8d
int v2; // ecx
int v3; // esi
int v4; // r9d
if ( a1 <= 0 )
{
v3 = 0;
}
else
{
v1 = a1;
v2 = 0;
v3 = 0;
do
{
v4 = v3;
v3 |= 1 << v2;
if ( v2 % 2 != 1 )
v3 = v4;
++v2;
v1 >>= 1;
}
while ( v1 > 0 );
}
return v3 ^ (unsigned int)a1;
} | func0:
ENDBR64
MOV EAX,EDI
TEST EDI,EDI
JLE 0x00101198
MOV R8D,EDI
MOV ECX,0x0
MOV ESI,0x0
MOV R11D,0x1
LAB_00101166:
MOV R9D,ECX
SHR R9D,0x1f
LEA EDX,[RCX + R9*0x1]
AND EDX,0x1
SUB EDX,R9D
MOV R9D,ESI
MOV R10D,R11D
SHL R10D,CL
OR ESI,R10D
CMP EDX,0x1
CMOVNZ ESI,R9D
ADD ECX,0x1
SAR R8D,0x1
TEST R8D,R8D
JG 0x00101166
LAB_00101195:
XOR EAX,ESI
RET
LAB_00101198:
MOV ESI,0x0
JMP 0x00101195 | /* func0(int) */
uint func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
if (param_1 < 1) {
uVar3 = 0;
}
else {
iVar2 = 0;
uVar3 = 0;
iVar4 = param_1;
do {
uVar1 = uVar3 | 1 << ((byte)iVar2 & 0x1f);
if (iVar2 % 2 != 1) {
uVar1 = uVar3;
}
uVar3 = uVar1;
iVar2 = iVar2 + 1;
iVar4 = iVar4 >> 1;
} while (0 < iVar4);
}
return param_1 ^ uVar3;
} |
618 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int res = 0, count = 0, temp = n;
while (temp > 0) {
if (count % 2 == 1) {
res = res | (1 << count);
}
count++;
temp >>= 1;
}
return n ^ res;
}
| int main() {
assert(func0(10) == 0);
assert(func0(20) == 30);
assert(func0(30) == 20);
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11f8 <_Z5func0i+0x38>
mov %edi,%edx
xor %ecx,%ecx
xor %eax,%eax
mov $0x1,%r8d
add $0x1,%ecx
sar %edx
je 11ee <_Z5func0i+0x2e>
test $0x1,%cl
je 11d4 <_Z5func0i+0x14>
mov %r8d,%esi
shl %cl,%esi
add $0x1,%ecx
or %esi,%eax
sar %edx
jne 11db <_Z5func0i+0x1b>
xor %edi,%eax
retq
nopl 0x0(%rax)
mov %edi,%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
test edi, edi
jle short loc_1228
mov edx, edi
xor ecx, ecx
xor esi, esi
mov eax, 1
nop dword ptr [rax+rax+00h]
loc_1208:
test cl, 1
jz short loc_1216
mov r8d, eax
shl r8d, cl
or esi, r8d
loc_1216:
add ecx, 1
sar edx, 1
jnz short loc_1208
mov eax, edi
xor eax, esi
retn
loc_1228:
mov eax, edi
retn | long long func0(int a1)
{
int v1; // edx
char v2; // cl
int v3; // esi
if ( a1 <= 0 )
return (unsigned int)a1;
v1 = a1;
v2 = 0;
v3 = 0;
do
{
if ( (v2 & 1) != 0 )
v3 |= 1 << v2;
++v2;
v1 >>= 1;
}
while ( v1 );
return v3 ^ (unsigned int)a1;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101228
MOV EDX,EDI
XOR ECX,ECX
XOR ESI,ESI
MOV EAX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101208:
TEST CL,0x1
JZ 0x00101216
MOV R8D,EAX
SHL R8D,CL
OR ESI,R8D
LAB_00101216:
ADD ECX,0x1
SAR EDX,0x1
JNZ 0x00101208
MOV EAX,EDI
XOR EAX,ESI
RET
LAB_00101228:
MOV EAX,EDI
RET | /* func0(int) */
uint func0(int param_1)
{
byte bVar1;
int iVar2;
uint uVar3;
if (0 < param_1) {
bVar1 = 0;
uVar3 = 0;
iVar2 = param_1;
do {
if ((bool)(bVar1 & 1)) {
uVar3 = uVar3 | 1 << (bVar1 & 0x1f);
}
bVar1 = bVar1 + 1;
iVar2 = iVar2 >> 1;
} while (iVar2 != 0);
return param_1 ^ uVar3;
}
return param_1;
} |
619 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
int res = 0, count = 0, temp = n;
while (temp > 0) {
if (count % 2 == 1) {
res = res | (1 << count);
}
count++;
temp >>= 1;
}
return n ^ res;
}
| int main() {
assert(func0(10) == 0);
assert(func0(20) == 30);
assert(func0(30) == 20);
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
jle 1200 <_Z5func0i+0x40>
mov %edi,%edx
sar %edx
je 1208 <_Z5func0i+0x48>
mov $0x1,%ecx
xor %eax,%eax
mov $0x1,%r8d
nopl 0x0(%rax,%rax,1)
test $0x1,%cl
je 11ec <_Z5func0i+0x2c>
mov %r8d,%esi
shl %cl,%esi
or %esi,%eax
add $0x1,%ecx
sar %edx
jne 11e0 <_Z5func0i+0x20>
xor %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov %edi,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
jmp 11f3 <_Z5func0i+0x33>
nopl 0x0(%rax)
| _Z5func0i:
endbr64
test edi, edi
jle short loc_1178
mov edx, edi
xor ecx, ecx
xor esi, esi
mov eax, 1
nop dword ptr [rax+rax+00h]
loc_1158:
test cl, 1
jz short loc_1166
mov r8d, eax
shl r8d, cl
or esi, r8d
loc_1166:
add ecx, 1
sar edx, 1
jnz short loc_1158
mov eax, edi
xor eax, esi
retn
loc_1178:
mov eax, edi
retn | long long func0(int a1)
{
int v1; // edx
char v2; // cl
int v3; // esi
if ( a1 <= 0 )
return (unsigned int)a1;
v1 = a1;
v2 = 0;
v3 = 0;
do
{
if ( (v2 & 1) != 0 )
v3 |= 1 << v2;
++v2;
v1 >>= 1;
}
while ( v1 );
return v3 ^ (unsigned int)a1;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101178
MOV EDX,EDI
XOR ECX,ECX
XOR ESI,ESI
MOV EAX,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
TEST CL,0x1
JZ 0x00101166
MOV R8D,EAX
SHL R8D,CL
OR ESI,R8D
LAB_00101166:
ADD ECX,0x1
SAR EDX,0x1
JNZ 0x00101158
MOV EAX,EDI
XOR EAX,ESI
RET
LAB_00101178:
MOV EAX,EDI
RET | /* func0(int) */
uint func0(int param_1)
{
byte bVar1;
int iVar2;
uint uVar3;
if (0 < param_1) {
bVar1 = 0;
uVar3 = 0;
iVar2 = param_1;
do {
if ((bool)(bVar1 & 1)) {
uVar3 = uVar3 | 1 << (bVar1 & 0x1f);
}
bVar1 = bVar1 + 1;
iVar2 = iVar2 >> 1;
} while (iVar2 != 0);
return param_1 ^ uVar3;
}
return param_1;
} |
620 | func0 |
#include <tuple>
#include <string>
#include <cassert>
#include <utility>
| std::tuple<std::pair<int, int>, std::pair<int, int>> func0(
const std::tuple<std::pair<std::string, std::string>, std::pair<std::string, std::string>>& tuple_str)
{
return std::make_tuple(
std::make_pair(std::stoi(std::get<0>(tuple_str).first), std::stoi(std::get<0>(tuple_str).second)),
std::make_pair(std::stoi(std::get<1>(tuple_str).first), std::stoi(std::get<1>(tuple_str).second))
);
}
| int main() {
assert(func0(std::make_tuple(std::make_pair("333", "33"), std::make_pair("1416", "55")))
== std::make_tuple(std::make_pair(333, 33), std::make_pair(1416, 55)));
assert(func0(std::make_tuple(std::make_pair("999", "99"), std::make_pair("1000", "500")))
== std::make_tuple(std::make_pair(999, 99), std::make_pair(1000, 500)));
assert(func0(std::make_tuple(std::make_pair("666", "66"), std::make_pair("1500", "555")))
== std::make_tuple(std::make_pair(666, 66), std::make_pair(1500, 555)));
}
| O0 | cpp | func0(std::tuple<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 2e9e <_ZSt3getILm1EJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKSC_>
add $0x20,%rax
mov $0xa,%edx
mov $0x0,%esi
mov %rax,%rdi
callq 2a92 <_ZNSt7__cxx114stoiERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi>
mov %eax,-0x1c(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 2e9e <_ZSt3getILm1EJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKSC_>
mov $0xa,%edx
mov $0x0,%esi
mov %rax,%rdi
callq 2a92 <_ZNSt7__cxx114stoiERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi>
mov %eax,-0x20(%rbp)
lea -0x1c(%rbp),%rdx
lea -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2e2b <_ZSt9make_pairIiiESt4pairINSt17__decay_and_stripIT_E6__typeENS1_IT0_E6__typeEEOS2_OS5_>
mov %rax,-0x10(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 2e0d <_ZSt3getILm0EJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKSC_>
add $0x20,%rax
mov $0xa,%edx
mov $0x0,%esi
mov %rax,%rdi
callq 2a92 <_ZNSt7__cxx114stoiERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi>
mov %eax,-0x24(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 2e0d <_ZSt3getILm0EJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKSC_>
mov $0xa,%edx
mov $0x0,%esi
mov %rax,%rdi
callq 2a92 <_ZNSt7__cxx114stoiERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi>
mov %eax,-0x28(%rbp)
lea -0x24(%rbp),%rdx
lea -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2e2b <_ZSt9make_pairIiiESt4pairINSt17__decay_and_stripIT_E6__typeENS1_IT0_E6__typeEEOS2_OS5_>
mov %rax,-0x18(%rbp)
mov -0x38(%rbp),%rax
lea -0x10(%rbp),%rdx
lea -0x18(%rbp),%rcx
mov %rcx,%rsi
mov %rax,%rdi
callq 2ebc <_ZSt10make_tupleIJSt4pairIiiES1_EESt5tupleIJDpNSt17__decay_and_stripIT_E6__typeEEEDpOS4_>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
je 2531 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x108>
callq 22b0 <__stack_chk_fail@plt>
mov -0x38(%rbp),%rax
leaveq
retq
| _Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZSt3getILm1EJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKSC_; std::get<1ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>(std::tuple<std::pair<std::string,std::string>,std::pair<std::string,std::string>> const&)
add rax, 20h ; ' '
mov edx, 0Ah
mov esi, 0
mov rdi, rax
call _ZNSt7__cxx114stoiERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stoi(std::string const&,ulong *,int)
mov [rbp+var_1C], eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZSt3getILm1EJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKSC_; std::get<1ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>(std::tuple<std::pair<std::string,std::string>,std::pair<std::string,std::string>> const&)
mov edx, 0Ah
mov esi, 0
mov rdi, rax
call _ZNSt7__cxx114stoiERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stoi(std::string const&,ulong *,int)
mov [rbp+var_20], eax
lea rdx, [rbp+var_1C]
lea rax, [rbp+var_20]
mov rsi, rdx
mov rdi, rax
call _ZSt9make_pairIiiESt4pairINSt25__strip_reference_wrapperINSt5decayIT_E4typeEE6__typeENS1_INS2_IT0_E4typeEE6__typeEEOS3_OS8_; std::make_pair<int,int>(int&&,int&&)
mov [rbp+var_10], rax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZSt3getILm0EJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKSC_; std::get<0ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>(std::tuple<std::pair<std::string,std::string>,std::pair<std::string,std::string>> const&)
add rax, 20h ; ' '
mov edx, 0Ah
mov esi, 0
mov rdi, rax
call _ZNSt7__cxx114stoiERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stoi(std::string const&,ulong *,int)
mov [rbp+var_24], eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZSt3getILm0EJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKSC_; std::get<0ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>(std::tuple<std::pair<std::string,std::string>,std::pair<std::string,std::string>> const&)
mov edx, 0Ah
mov esi, 0
mov rdi, rax
call _ZNSt7__cxx114stoiERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stoi(std::string const&,ulong *,int)
mov [rbp+var_28], eax
lea rdx, [rbp+var_24]
lea rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZSt9make_pairIiiESt4pairINSt25__strip_reference_wrapperINSt5decayIT_E4typeEE6__typeENS1_INS2_IT0_E4typeEE6__typeEEOS3_OS8_; std::make_pair<int,int>(int&&,int&&)
mov [rbp+var_18], rax
mov rax, [rbp+var_38]
lea rdx, [rbp+var_10]
lea rcx, [rbp+var_18]
mov rsi, rcx
mov rdi, rax
call _ZSt10make_tupleIJSt4pairIiiES1_EESt5tupleIJDpNSt25__strip_reference_wrapperINSt5decayIT_E4typeEE6__typeEEEDpOS5_; std::make_tuple<std::pair<int,int>,std::pair<int,int>>(std::pair<int,int>,std::pair<int,int>&&)
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short loc_1491
call ___stack_chk_fail
loc_1491:
mov rax, [rbp+var_38]
leave
retn | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rax
long long v5; // rax
int v7; // [rsp+18h] [rbp-28h] BYREF
int v8; // [rsp+1Ch] [rbp-24h] BYREF
int v9; // [rsp+20h] [rbp-20h] BYREF
int v10; // [rsp+24h] [rbp-1Ch] BYREF
long long v11; // [rsp+28h] [rbp-18h] BYREF
_QWORD v12[2]; // [rsp+30h] [rbp-10h] BYREF
v12[1] = __readfsqword(0x28u);
v2 = std::get<1ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>(a2);
v10 = std::stoi(v2 + 32, 0LL, 10LL);
v3 = std::get<1ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>(a2);
v9 = std::stoi(v3, 0LL, 10LL);
v12[0] = std::make_pair<int,int>(&v9, &v10);
v4 = std::get<0ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>(a2);
v8 = std::stoi(v4 + 32, 0LL, 10LL);
v5 = std::get<0ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>(a2);
v7 = std::stoi(v5, 0LL, 10LL);
v11 = std::make_pair<int,int>(&v7, &v8);
std::make_tuple<std::pair<int,int>,std::pair<int,int>>(a1, &v11, v12);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101e64
ADD RAX,0x20
MOV EDX,0xa
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101a36
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101e64
MOV EDX,0xa
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101a36
MOV dword ptr [RBP + -0x20],EAX
LEA RDX,[RBP + -0x1c]
LEA RAX,[RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101df2
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101dd4
ADD RAX,0x20
MOV EDX,0xa
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101a36
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101dd4
MOV EDX,0xa
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101a36
MOV dword ptr [RBP + -0x28],EAX
LEA RDX,[RBP + -0x24]
LEA RAX,[RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101df2
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x38]
LEA RDX,[RBP + -0x10]
LEA RCX,[RBP + -0x18]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101e82
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101491
CALL 0x00101240
LAB_00101491:
MOV RAX,qword ptr [RBP + -0x38]
LEAVE
RET | /* func0(std::tuple<std::pair<std::string, std::string >, std::pair<std::string, std::string > >
const&) */
tuple * func0(tuple *param_1)
{
pair pVar1;
type *ptVar2;
int4 extraout_var;
type *ptVar3;
int4 extraout_var_00;
tuple *in_RSI;
long in_FS_OFFSET;
int local_30;
int local_2c;
int local_28;
int local_24;
int8 local_20;
int8 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
ptVar2 = std::get<1ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>
(in_RSI);
local_24 = std::stoi((string *)(ptVar2 + 0x20),(ulong *)0x0,10);
ptVar2 = std::get<1ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>
(in_RSI);
local_28 = std::stoi((string *)ptVar2,(ulong *)0x0,10);
pVar1 = std::make_pair<int,int>(&local_28,&local_24);
local_18 = CONCAT44(extraout_var,pVar1);
ptVar3 = std::get<0ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>
(in_RSI);
local_2c = std::stoi((string *)(ptVar3 + 0x20),(ulong *)0x0,10);
ptVar3 = std::get<0ul,std::pair<std::string,std::string>,std::pair<std::string,std::string>>
(in_RSI);
local_30 = std::stoi((string *)ptVar3,(ulong *)0x0,10);
pVar1 = std::make_pair<int,int>(&local_30,&local_2c);
local_20 = CONCAT44(extraout_var_00,pVar1);
std::make_tuple<std::pair<int,int>,std::pair<int,int>>(param_1,&local_20,&local_18);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
621 | func0 |
#include <tuple>
#include <string>
#include <cassert>
#include <utility>
| std::tuple<std::pair<int, int>, std::pair<int, int>> func0(
const std::tuple<std::pair<std::string, std::string>, std::pair<std::string, std::string>>& tuple_str)
{
return std::make_tuple(
std::make_pair(std::stoi(std::get<0>(tuple_str).first), std::stoi(std::get<0>(tuple_str).second)),
std::make_pair(std::stoi(std::get<1>(tuple_str).first), std::stoi(std::get<1>(tuple_str).second))
);
}
| int main() {
assert(func0(std::make_tuple(std::make_pair("333", "33"), std::make_pair("1416", "55")))
== std::make_tuple(std::make_pair(333, 33), std::make_pair(1416, 55)));
assert(func0(std::make_tuple(std::make_pair("999", "99"), std::make_pair("1000", "500")))
== std::make_tuple(std::make_pair(999, 99), std::make_pair(1000, 500)));
assert(func0(std::make_tuple(std::make_pair("666", "66"), std::make_pair("1500", "555")))
== std::make_tuple(std::make_pair(666, 66), std::make_pair(1500, 555)));
}
| O1 | cpp | func0(std::tuple<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov 0x20(%rsi),%rdx
mov $0xa,%r8d
mov $0x0,%ecx
lea 0xd6d(%rip),%rsi
mov 0x2d3a(%rip),%r12
mov %r12,%rdi
callq 15fb <_ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_>
mov %eax,%r14d
mov $0xa,%r8d
mov $0x0,%ecx
mov 0x0(%rbp),%rdx
lea 0xd45(%rip),%rsi
mov %r12,%rdi
callq 15fb <_ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_>
mov %eax,%r15d
mov 0x60(%rbp),%rdx
mov $0xa,%r8d
mov $0x0,%ecx
lea 0xd24(%rip),%rsi
mov %r12,%rdi
callq 15fb <_ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_>
mov %eax,%r13d
mov 0x40(%rbp),%rdx
mov $0xa,%r8d
mov $0x0,%ecx
lea 0xd03(%rip),%rsi
mov %r12,%rdi
callq 15fb <_ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_>
mov %r15d,(%rbx)
mov %r14d,0x4(%rbx)
mov %eax,0x8(%rbx)
mov %r13d,0xc(%rbx)
mov %rbx,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| _Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
mov rbp, rsi
mov rdx, [rsi+20h]
mov r8d, 0Ah
mov ecx, 0
lea r13, aStoi; "stoi"
mov rsi, r13
mov r12, cs:__isoc23_strtol_ptr
mov rdi, r12
call _ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_; __gnu_cxx::__stoa<long,int,char,int>(long (*)(char const*,char**,int),char const*,char const*,ulong *,int)
mov r14d, eax
mov rdx, [rbp+0]
mov r8d, 0Ah
mov ecx, 0
mov rsi, r13
mov rdi, r12
call _ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_; __gnu_cxx::__stoa<long,int,char,int>(long (*)(char const*,char**,int),char const*,char const*,ulong *,int)
mov r15d, eax
mov rdx, [rbp+60h]
mov r8d, 0Ah
mov ecx, 0
mov rsi, r13
mov rdi, r12
call _ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_; __gnu_cxx::__stoa<long,int,char,int>(long (*)(char const*,char**,int),char const*,char const*,ulong *,int)
mov [rsp+48h+var_3C], eax
mov rdx, [rbp+40h]
mov r8d, 0Ah
mov ecx, 0
mov rsi, r13
mov rdi, r12
call _ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_; __gnu_cxx::__stoa<long,int,char,int>(long (*)(char const*,char**,int),char const*,char const*,ulong *,int)
mov [rbx], r15d
mov [rbx+4], r14d
mov [rbx+8], eax
mov eax, [rsp+48h+var_3C]
mov [rbx+0Ch], eax
mov rax, rbx
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | _DWORD * func0(_DWORD *a1, _QWORD *a2)
{
int v2; // r14d
int v3; // r15d
int v4; // eax
int v6; // [rsp+Ch] [rbp-3Ch]
v2 = __gnu_cxx::__stoa<long,int,char,int>(&_isoc23_strtol, "stoi", a2[4], 0LL, 10LL);
v3 = __gnu_cxx::__stoa<long,int,char,int>(&_isoc23_strtol, "stoi", *a2, 0LL, 10LL);
v6 = __gnu_cxx::__stoa<long,int,char,int>(&_isoc23_strtol, "stoi", a2[12], 0LL, 10LL);
v4 = __gnu_cxx::__stoa<long,int,char,int>(&_isoc23_strtol, "stoi", a2[8], 0LL, 10LL);
*a1 = v3;
a1[1] = v2;
a1[2] = v4;
a1[3] = v6;
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RBP,RSI
MOV RDX,qword ptr [RSI + 0x20]
MOV R8D,0xa
MOV ECX,0x0
LEA R13,[0x102004]
MOV RSI,R13
MOV R12,qword ptr [0x00103ff8]
MOV RDI,R12
CALL 0x001016a7
MOV R14D,EAX
MOV RDX,qword ptr [RBP]
MOV R8D,0xa
MOV ECX,0x0
MOV RSI,R13
MOV RDI,R12
CALL 0x001016a7
MOV R15D,EAX
MOV RDX,qword ptr [RBP + 0x60]
MOV R8D,0xa
MOV ECX,0x0
MOV RSI,R13
MOV RDI,R12
CALL 0x001016a7
MOV dword ptr [RSP + 0xc],EAX
MOV RDX,qword ptr [RBP + 0x40]
MOV R8D,0xa
MOV ECX,0x0
MOV RSI,R13
MOV RDI,R12
CALL 0x001016a7
MOV dword ptr [RBX],R15D
MOV dword ptr [RBX + 0x4],R14D
MOV dword ptr [RBX + 0x8],EAX
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RBX + 0xc],EAX
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | /* func0(std::tuple<std::pair<std::string, std::string >, std::pair<std::string, std::string > >
const&) */
tuple * func0(tuple *param_1)
{
int *puVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int8 *in_RSI;
puVar1 = PTR___isoc23_strtol_00103ff8;
iVar2 = __stoa<long,int,char,int>
((_func_long_char_ptr_char_ptr_ptr_int *)PTR___isoc23_strtol_00103ff8,"stoi",
(char *)in_RSI[4],(ulong *)0x0,10);
iVar3 = __stoa<long,int,char,int>
((_func_long_char_ptr_char_ptr_ptr_int *)puVar1,"stoi",(char *)*in_RSI,
(ulong *)0x0,10);
iVar4 = __stoa<long,int,char,int>
((_func_long_char_ptr_char_ptr_ptr_int *)puVar1,"stoi",(char *)in_RSI[0xc],
(ulong *)0x0,10);
iVar5 = __stoa<long,int,char,int>
((_func_long_char_ptr_char_ptr_ptr_int *)puVar1,"stoi",(char *)in_RSI[8],
(ulong *)0x0,10);
*(int *)param_1 = iVar3;
*(int *)(param_1 + 4) = iVar2;
*(int *)(param_1 + 8) = iVar5;
*(int *)(param_1 + 0xc) = iVar4;
return param_1;
} |
622 | func0 |
#include <tuple>
#include <string>
#include <cassert>
#include <utility>
| std::tuple<std::pair<int, int>, std::pair<int, int>> func0(
const std::tuple<std::pair<std::string, std::string>, std::pair<std::string, std::string>>& tuple_str)
{
return std::make_tuple(
std::make_pair(std::stoi(std::get<0>(tuple_str).first), std::stoi(std::get<0>(tuple_str).second)),
std::make_pair(std::stoi(std::get<1>(tuple_str).first), std::stoi(std::get<1>(tuple_str).second))
);
}
| int main() {
assert(func0(std::make_tuple(std::make_pair("333", "33"), std::make_pair("1416", "55")))
== std::make_tuple(std::make_pair(333, 33), std::make_pair(1416, 55)));
assert(func0(std::make_tuple(std::make_pair("999", "99"), std::make_pair("1000", "500")))
== std::make_tuple(std::make_pair(999, 99), std::make_pair(1000, 500)));
assert(func0(std::make_tuple(std::make_pair("666", "66"), std::make_pair("1500", "555")))
== std::make_tuple(std::make_pair(666, 66), std::make_pair(1500, 555)));
}
| O2 | cpp | func0(std::tuple<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %r15
mov $0xa,%r8d
xor %ecx,%ecx
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
mov 0x2a31(%rip),%rbp
mov 0x20(%rsi),%rdx
lea 0xa52(%rip),%rsi
mov %rbp,%rdi
callq 1680 <_ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_>
mov (%rbx),%rdx
mov %rbp,%rdi
xor %ecx,%ecx
mov $0xa,%r8d
lea 0xa35(%rip),%rsi
mov %eax,%r14d
callq 1680 <_ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_>
mov 0x60(%rbx),%rdx
mov %rbp,%rdi
xor %ecx,%ecx
mov $0xa,%r8d
lea 0xa17(%rip),%rsi
mov %eax,%r15d
callq 1680 <_ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_>
mov 0x40(%rbx),%rdx
mov %rbp,%rdi
xor %ecx,%ecx
mov $0xa,%r8d
lea 0x9f9(%rip),%rsi
mov %eax,%r13d
callq 1680 <_ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_>
mov %r15d,(%r12)
mov %r14d,0x4(%r12)
mov %eax,0x8(%r12)
mov %r12,%rax
mov %r13d,0xc(%r12)
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE:
endbr64
push r15
mov r8d, 0Ah
xor ecx, ecx
push r14
push r13
lea r13, aStoi; "stoi"
push r12
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
sub rsp, 18h
mov r12, cs:__isoc23_strtol_ptr
mov rdx, [rsi+20h]
mov rsi, r13
mov rdi, r12
call _ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_; __gnu_cxx::__stoa<long,int,char,int>(long (*)(char const*,char**,int),char const*,char const*,ulong *,int)
mov rdx, [rbp+0]
mov rsi, r13
mov rdi, r12
mov r8d, 0Ah
xor ecx, ecx
mov r14d, eax
call _ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_; __gnu_cxx::__stoa<long,int,char,int>(long (*)(char const*,char**,int),char const*,char const*,ulong *,int)
mov rdx, [rbp+60h]
mov rsi, r13
mov rdi, r12
mov r8d, 0Ah
xor ecx, ecx
mov [rsp+48h+var_3C], eax
call _ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_; __gnu_cxx::__stoa<long,int,char,int>(long (*)(char const*,char**,int),char const*,char const*,ulong *,int)
mov rdx, [rbp+40h]
mov rsi, r13
mov rdi, r12
mov r8d, 0Ah
xor ecx, ecx
mov r15d, eax
call _ZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_; __gnu_cxx::__stoa<long,int,char,int>(long (*)(char const*,char**,int),char const*,char const*,ulong *,int)
movd xmm0, [rsp+48h+var_3C]
movd xmm2, r15d
movd xmm3, r14d
movd xmm1, eax
mov rax, rbx
punpckldq xmm1, xmm2
punpckldq xmm0, xmm3
punpcklqdq xmm0, xmm1
movups xmmword ptr [rbx], xmm0
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | __m128i * func0(__m128i *a1, _QWORD *a2)
{
unsigned int v2; // r14d
unsigned int v3; // r15d
__m128i v4; // xmm1
__m128i *result; // rax
unsigned int v6; // [rsp+Ch] [rbp-3Ch]
v2 = __gnu_cxx::__stoa<long,int,char,int>(&_isoc23_strtol, "stoi", a2[4], 0LL, 10LL);
v6 = __gnu_cxx::__stoa<long,int,char,int>(&_isoc23_strtol, "stoi", *a2, 0LL, 10LL);
v3 = __gnu_cxx::__stoa<long,int,char,int>(&_isoc23_strtol, "stoi", a2[12], 0LL, 10LL);
v4 = _mm_cvtsi32_si128(__gnu_cxx::__stoa<long,int,char,int>(&_isoc23_strtol, "stoi", a2[8], 0LL, 10LL));
result = a1;
*a1 = _mm_unpacklo_epi64(
_mm_unpacklo_epi32(_mm_cvtsi32_si128(v6), _mm_cvtsi32_si128(v2)),
_mm_unpacklo_epi32(v4, _mm_cvtsi32_si128(v3)));
return result;
} | func0:
ENDBR64
PUSH R15
MOV R8D,0xa
XOR ECX,ECX
PUSH R14
PUSH R13
LEA R13,[0x102004]
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV R12,qword ptr [0x00103ff8]
MOV RDX,qword ptr [RSI + 0x20]
MOV RSI,R13
MOV RDI,R12
CALL 0x00101740
MOV RDX,qword ptr [RBP]
MOV RSI,R13
MOV RDI,R12
MOV R8D,0xa
XOR ECX,ECX
MOV R14D,EAX
CALL 0x00101740
MOV RDX,qword ptr [RBP + 0x60]
MOV RSI,R13
MOV RDI,R12
MOV R8D,0xa
XOR ECX,ECX
MOV dword ptr [RSP + 0xc],EAX
CALL 0x00101740
MOV RDX,qword ptr [RBP + 0x40]
MOV RSI,R13
MOV RDI,R12
MOV R8D,0xa
XOR ECX,ECX
MOV R15D,EAX
CALL 0x00101740
MOVD XMM0,dword ptr [RSP + 0xc]
MOVD XMM2,R15D
MOVD XMM3,R14D
MOVD XMM1,EAX
MOV RAX,RBX
PUNPCKLDQ XMM1,XMM2
PUNPCKLDQ XMM0,XMM3
PUNPCKLQDQ XMM0,XMM1
MOVUPS xmmword ptr [RBX],XMM0
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | /* func0(std::tuple<std::pair<std::string, std::string >, std::pair<std::string, std::string > >
const&) */
tuple * func0(tuple *param_1)
{
int *puVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int8 *in_RSI;
puVar1 = PTR___isoc23_strtol_00103ff8;
iVar2 = __stoa<long,int,char,int>
((_func_long_char_ptr_char_ptr_ptr_int *)PTR___isoc23_strtol_00103ff8,"stoi",
(char *)in_RSI[4],(ulong *)0x0,10);
iVar3 = __stoa<long,int,char,int>
((_func_long_char_ptr_char_ptr_ptr_int *)puVar1,"stoi",(char *)*in_RSI,
(ulong *)0x0,10);
iVar4 = __stoa<long,int,char,int>
((_func_long_char_ptr_char_ptr_ptr_int *)puVar1,"stoi",(char *)in_RSI[0xc],
(ulong *)0x0,10);
iVar5 = __stoa<long,int,char,int>
((_func_long_char_ptr_char_ptr_ptr_int *)puVar1,"stoi",(char *)in_RSI[8],
(ulong *)0x0,10);
*(ulong *)param_1 = CONCAT44(iVar2,iVar3);
*(ulong *)(param_1 + 8) = CONCAT44(iVar4,iVar5);
return param_1;
} |
623 | func0 |
#include <tuple>
#include <string>
#include <cassert>
#include <utility>
| std::tuple<std::pair<int, int>, std::pair<int, int>> func0(
const std::tuple<std::pair<std::string, std::string>, std::pair<std::string, std::string>>& tuple_str)
{
return std::make_tuple(
std::make_pair(std::stoi(std::get<0>(tuple_str).first), std::stoi(std::get<0>(tuple_str).second)),
std::make_pair(std::stoi(std::get<1>(tuple_str).first), std::stoi(std::get<1>(tuple_str).second))
);
}
| int main() {
assert(func0(std::make_tuple(std::make_pair("333", "33"), std::make_pair("1416", "55")))
== std::make_tuple(std::make_pair(333, 33), std::make_pair(1416, 55)));
assert(func0(std::make_tuple(std::make_pair("999", "99"), std::make_pair("1000", "500")))
== std::make_tuple(std::make_pair(999, 99), std::make_pair(1000, 500)));
assert(func0(std::make_tuple(std::make_pair("666", "66"), std::make_pair("1500", "555")))
== std::make_tuple(std::make_pair(666, 66), std::make_pair(1500, 555)));
}
| O3 | cpp | func0(std::tuple<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
sub $0x38,%rsp
mov 0x20(%rsi),%r13
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r15
callq 1100 <__errno_location@plt>
mov $0xa,%edx
mov %r15,%rsi
mov %r13,%rdi
mov (%rax),%ebp
movl $0x0,(%rax)
mov %rax,%rbx
callq 1180 <strtol@plt>
mov %rax,(%rsp)
cmp 0x20(%rsp),%r13
je 17ec <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x21c>
mov (%rbx),%eax
cmp $0x22,%eax
je 17c8 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x1f8>
mov (%rsp),%rdi
mov $0x80000000,%r13d
mov $0xffffffff,%esi
lea (%rdi,%r13,1),%rdx
cmp %rsi,%rdx
ja 17c8 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x1f8>
mov (%r12),%rcx
movl $0x0,(%rbx)
test %eax,%eax
mov %r15,%rsi
mov $0xa,%edx
cmovne %eax,%ebp
mov %rcx,%rdi
mov %rcx,0x10(%rsp)
callq 1180 <strtol@plt>
mov 0x10(%rsp),%rcx
mov %rax,0x8(%rsp)
cmp 0x20(%rsp),%rcx
je 17e0 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x210>
mov (%rbx),%eax
cmp $0x22,%eax
je 17bc <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x1ec>
mov 0x8(%rsp),%rdi
mov $0xffffffff,%esi
lea (%rdi,%r13,1),%rdx
cmp %rsi,%rdx
ja 17bc <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x1ec>
mov 0x60(%r12),%rcx
movl $0x0,(%rbx)
test %eax,%eax
mov %r15,%rsi
mov $0xa,%edx
cmovne %eax,%ebp
mov %rcx,%rdi
mov %rcx,0x18(%rsp)
callq 1180 <strtol@plt>
mov 0x18(%rsp),%rcx
mov %rax,0x10(%rsp)
cmp 0x20(%rsp),%rcx
je 17fd <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x22d>
mov (%rbx),%eax
cmp $0x22,%eax
je 17b0 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x1e0>
add 0x10(%rsp),%r13
mov $0xffffffff,%edx
cmp %rdx,%r13
ja 17b0 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x1e0>
mov 0x40(%r12),%r12
movl $0x0,(%rbx)
test %eax,%eax
mov %r15,%rsi
mov $0xa,%edx
cmovne %eax,%ebp
mov %r12,%rdi
callq 1180 <strtol@plt>
cmp 0x20(%rsp),%r12
je 17d4 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x204>
mov (%rbx),%ecx
cmp $0x22,%ecx
je 17a4 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x1d4>
mov $0x80000000,%edx
mov $0xffffffff,%esi
add %rax,%rdx
cmp %rsi,%rdx
ja 17a4 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x1d4>
test %ecx,%ecx
je 17a0 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x1d0>
movd 0x10(%rsp),%xmm2
movd 0x8(%rsp),%xmm0
movd %eax,%xmm1
movd (%rsp),%xmm3
punpckldq %xmm2,%xmm1
punpckldq %xmm3,%xmm0
punpcklqdq %xmm1,%xmm0
movups %xmm0,(%r14)
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 17f8 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x228>
add $0x38,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
mov %ebp,(%rbx)
jmp 1752 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE+0x182>
lea 0x859(%rip),%rdi
callq 1190 <_ZSt20__throw_out_of_rangePKc@plt>
lea 0x84d(%rip),%rdi
callq 1190 <_ZSt20__throw_out_of_rangePKc@plt>
lea 0x841(%rip),%rdi
callq 1190 <_ZSt20__throw_out_of_rangePKc@plt>
lea 0x835(%rip),%rdi
callq 1190 <_ZSt20__throw_out_of_rangePKc@plt>
lea 0x829(%rip),%rdi
callq 1120 <_ZSt24__throw_invalid_argumentPKc@plt>
lea 0x81d(%rip),%rdi
callq 1120 <_ZSt24__throw_invalid_argumentPKc@plt>
lea 0x811(%rip),%rdi
callq 1120 <_ZSt24__throw_invalid_argumentPKc@plt>
callq 1170 <__stack_chk_fail@plt>
lea 0x800(%rip),%rdi
callq 1120 <_ZSt24__throw_invalid_argumentPKc@plt>
endbr64
mov %rax,%rdi
jmpq 11c0 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE.cold>
endbr64
mov %rax,%rdi
jmpq 11cc <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE.cold+0xc>
endbr64
mov %rax,%rdi
jmpq 11d8 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE.cold+0x18>
endbr64
mov %rax,%rdi
jmpq 11e4 <_Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE.cold+0x24>
nopl 0x0(%rax)
| _Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 38h
mov r14, [rsi+20h]
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
lea r15, [rsp+68h+var_48]
call ___errno_location
mov edx, 0Ah
mov rsi, r15
mov rdi, r14
mov r12d, [rax]
mov dword ptr [rax], 0
mov rbx, rax
call ___isoc23_strtol
mov [rsp+68h+var_60], rax
cmp r14, [rsp+68h+var_48]
jz loc_17F5
mov eax, [rbx]
cmp eax, 22h ; '"'
jz loc_17A1
mov rcx, [rsp+68h+var_60]
mov r14d, 80000000h
mov esi, 0FFFFFFFFh
lea rdx, [rcx+r14]
cmp rsi, rdx
jb loc_17A1
mov rcx, [r13+0]
mov dword ptr [rbx], 0
test eax, eax
mov rsi, r15
mov edx, 0Ah
cmovnz r12d, eax
mov rdi, rcx
mov [rsp+68h+var_50], rcx
call ___isoc23_strtol
mov rcx, [rsp+68h+var_50]
mov [rsp+68h+var_58], rax
cmp rcx, [rsp+68h+var_48]
jz loc_17D9
mov eax, [rbx]
cmp eax, 22h ; '"'
jz loc_1785
mov rcx, [rsp+68h+var_58]
mov esi, 0FFFFFFFFh
lea rdx, [rcx+r14]
cmp rsi, rdx
jb loc_1785
mov rdi, [r13+60h]
mov dword ptr [rbx], 0
test eax, eax
mov rsi, r15
mov edx, 0Ah
cmovnz r12d, eax
mov [rsp+68h+var_50], rdi
call ___isoc23_strtol
mov rdi, [rsp+68h+var_50]
mov rcx, rax
cmp rdi, [rsp+68h+var_48]
jz loc_1816
mov eax, [rbx]
cmp eax, 22h ; '"'
jz loc_1765
add r14, rcx
mov edi, 0FFFFFFFFh
cmp rdi, r14
jb loc_1765
mov r13, [r13+40h]
mov dword ptr [rbx], 0
test eax, eax
mov rsi, r15
mov edx, 0Ah
mov [rsp+68h+var_50], rcx
cmovnz r12d, eax
mov rdi, r13
call ___isoc23_strtol
cmp r13, [rsp+68h+var_48]
mov rcx, [rsp+68h+var_50]
jz loc_17BD
mov esi, [rbx]
cmp esi, 22h ; '"'
jz short loc_1745
mov edx, 80000000h
add rdx, rax
shr rdx, 20h
jnz short loc_1745
test esi, esi
jz short loc_1740
loc_1705:
mov ebx, dword ptr [rsp+68h+var_58]
mov [rbp+8], eax
mov [rbp+0Ch], ecx
mov [rbp+0], ebx
mov ebx, dword ptr [rsp+68h+var_60]
mov [rbp+4], ebx
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz loc_1811
add rsp, 38h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1740:
mov [rbx], r12d
jmp short loc_1705
loc_1745:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz loc_1811
lea rdi, aStoi; "stoi"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
loc_1765:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz loc_1811
lea rdi, aStoi; "stoi"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
loc_1785:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1811
lea rdi, aStoi; "stoi"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
loc_17A1:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1811
lea rdi, aStoi; "stoi"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
loc_17BD:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1811
lea rdi, aStoi; "stoi"
call __ZSt24__throw_invalid_argumentPKc; std::__throw_invalid_argument(char const*)
loc_17D9:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1811
lea rdi, aStoi; "stoi"
call __ZSt24__throw_invalid_argumentPKc; std::__throw_invalid_argument(char const*)
loc_17F5:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1811
lea rdi, aStoi; "stoi"
call __ZSt24__throw_invalid_argumentPKc; std::__throw_invalid_argument(char const*)
loc_1811:
call ___stack_chk_fail
loc_1816:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_1811
lea rdi, aStoi; "stoi"
call __ZSt24__throw_invalid_argumentPKc; std::__throw_invalid_argument(char const*)
endbr64
mov rdi, rax
jmp _Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE_cold; func0(std::tuple<std::pair<std::string,std::string>,std::pair<std::string,std::string>> const&) [clone]
endbr64
mov rdi, rax
jmp _Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE_cold; func0(std::tuple<std::pair<std::string,std::string>,std::pair<std::string,std::string>> const&) [clone]
endbr64
mov rdi, rax
jmp _Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE_cold; func0(std::tuple<std::pair<std::string,std::string>,std::pair<std::string,std::string>> const&) [clone]
endbr64
mov rdi, rax
jmp _Z5func0RKSt5tupleIJSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ES7_EE_cold; func0(std::tuple<std::pair<std::string,std::string>,std::pair<std::string,std::string>> const&) [clone] | _DWORD * func0(
_DWORD *a1,
long long *a2,
long long a3,
long long a4,
long long a5,
long long a6,
int a7,
int a8,
int a9,
int a10,
long long a11)
{
long long v12; // r14
int *v13; // rax
int v14; // r12d
int *v15; // rbx
int v16; // eax
long long v17; // rcx
int v18; // eax
long long v19; // rdi
long long v20; // rcx
int v21; // eax
long long v22; // r13
long long v23; // rax
int v25; // eax
int v26; // edx
int v27; // ecx
int v28; // r8d
int v29; // r9d
long long v30; // [rsp+8h] [rbp-60h]
long long v31; // [rsp+10h] [rbp-58h]
long long v32; // [rsp+18h] [rbp-50h]
int v33; // [rsp+18h] [rbp-50h]
_QWORD v34[9]; // [rsp+20h] [rbp-48h] BYREF
v12 = a2[4];
v34[1] = __readfsqword(0x28u);
v13 = __errno_location();
v14 = *v13;
*v13 = 0;
v15 = v13;
v30 = __isoc23_strtol(v12, v34, 10LL);
if ( v12 == v34[0] )
LABEL_28:
std::__throw_invalid_argument("stoi");
v16 = *v15;
if ( *v15 == 34 || (unsigned long long)(v30 + 0x80000000LL) > 0xFFFFFFFF )
std::__throw_out_of_range("stoi");
v17 = *a2;
*v15 = 0;
if ( v16 )
v14 = v16;
v32 = v17;
v31 = __isoc23_strtol(v17, v34, 10LL);
if ( v32 == v34[0] )
{
LABEL_27:
std::__throw_invalid_argument("stoi");
goto LABEL_28;
}
v18 = *v15;
if ( *v15 == 34 || (unsigned long long)(v31 + 0x80000000LL) > 0xFFFFFFFF )
std::__throw_out_of_range("stoi");
v19 = a2[12];
*v15 = 0;
if ( v18 )
v14 = v18;
v20 = __isoc23_strtol(v19, v34, 10LL);
if ( v19 == v34[0] )
{
v25 = std::__throw_invalid_argument("stoi");
func0(v25, (unsigned int)v34, v26, v27, v28, v29, a7, a8, a9, a10, a11);
}
v21 = *v15;
if ( *v15 == 34 || (unsigned long long)(v20 + 0x80000000LL) > 0xFFFFFFFF )
std::__throw_out_of_range("stoi");
v22 = a2[8];
*v15 = 0;
v33 = v20;
if ( v21 )
v14 = v21;
v23 = __isoc23_strtol(v22, v34, 10LL);
if ( v22 == v34[0] )
{
std::__throw_invalid_argument("stoi");
goto LABEL_27;
}
if ( *v15 == 34 || (unsigned long long)(v23 + 0x80000000LL) >> 32 )
std::__throw_out_of_range("stoi");
if ( !*v15 )
*v15 = v14;
a1[2] = v23;
a1[3] = v33;
*a1 = v31;
a1[1] = v30;
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x38
MOV R14,qword ptr [RSI + 0x20]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
LEA R15,[RSP + 0x20]
CALL 0x00101110
MOV EDX,0xa
MOV RSI,R15
MOV RDI,R14
MOV R12D,dword ptr [RAX]
MOV dword ptr [RAX],0x0
MOV RBX,RAX
CALL 0x001011d0
MOV qword ptr [RSP + 0x8],RAX
CMP R14,qword ptr [RSP + 0x20]
JZ 0x001017f5
MOV EAX,dword ptr [RBX]
CMP EAX,0x22
JZ 0x001017a1
MOV RCX,qword ptr [RSP + 0x8]
MOV R14D,0x80000000
MOV ESI,0xffffffff
LEA RDX,[RCX + R14*0x1]
CMP RSI,RDX
JC 0x001017a1
MOV RCX,qword ptr [R13]
MOV dword ptr [RBX],0x0
TEST EAX,EAX
MOV RSI,R15
MOV EDX,0xa
CMOVNZ R12D,EAX
MOV RDI,RCX
MOV qword ptr [RSP + 0x18],RCX
CALL 0x001011d0
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x10],RAX
CMP RCX,qword ptr [RSP + 0x20]
JZ 0x001017d9
MOV EAX,dword ptr [RBX]
CMP EAX,0x22
JZ 0x00101785
MOV RCX,qword ptr [RSP + 0x10]
MOV ESI,0xffffffff
LEA RDX,[RCX + R14*0x1]
CMP RSI,RDX
JC 0x00101785
MOV RDI,qword ptr [R13 + 0x60]
MOV dword ptr [RBX],0x0
TEST EAX,EAX
MOV RSI,R15
MOV EDX,0xa
CMOVNZ R12D,EAX
MOV qword ptr [RSP + 0x18],RDI
CALL 0x001011d0
MOV RDI,qword ptr [RSP + 0x18]
MOV RCX,RAX
CMP RDI,qword ptr [RSP + 0x20]
JZ 0x00101816
MOV EAX,dword ptr [RBX]
CMP EAX,0x22
JZ 0x00101765
ADD R14,RCX
MOV EDI,0xffffffff
CMP RDI,R14
JC 0x00101765
MOV R13,qword ptr [R13 + 0x40]
MOV dword ptr [RBX],0x0
TEST EAX,EAX
MOV RSI,R15
MOV EDX,0xa
MOV qword ptr [RSP + 0x18],RCX
CMOVNZ R12D,EAX
MOV RDI,R13
CALL 0x001011d0
CMP R13,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
JZ 0x001017bd
MOV ESI,dword ptr [RBX]
CMP ESI,0x22
JZ 0x00101745
MOV EDX,0x80000000
ADD RDX,RAX
SHR RDX,0x20
JNZ 0x00101745
TEST ESI,ESI
JZ 0x00101740
LAB_00101705:
MOV EBX,dword ptr [RSP + 0x10]
MOV dword ptr [RBP + 0x8],EAX
MOV dword ptr [RBP + 0xc],ECX
MOV dword ptr [RBP],EBX
MOV EBX,dword ptr [RSP + 0x8]
MOV dword ptr [RBP + 0x4],EBX
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101811
ADD RSP,0x38
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101740:
MOV dword ptr [RBX],R12D
JMP 0x00101705
LAB_00101745:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101811
LEA RDI,[0x102004]
LAB_00101760:
CALL 0x001011a0
LAB_00101765:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101811
LEA RDI,[0x102004]
LAB_00101780:
CALL 0x001011a0
LAB_00101785:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101811
LEA RDI,[0x102004]
LAB_0010179c:
CALL 0x001011a0
LAB_001017a1:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101811
LEA RDI,[0x102004]
LAB_001017b8:
CALL 0x001011a0
LAB_001017bd:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101811
LEA RDI,[0x102004]
LAB_001017d4:
CALL 0x00101130
LAB_001017d9:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101811
LEA RDI,[0x102004]
LAB_001017f0:
CALL 0x00101130
LAB_001017f5:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101811
LEA RDI,[0x102004]
LAB_0010180c:
CALL 0x00101130
LAB_00101811:
CALL 0x00101180
LAB_00101816:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101811
LEA RDI,[0x102004]
LAB_0010182d:
CALL 0x00101130
LAB_00101832:
ENDBR64
MOV RDI,RAX
JMP 0x001011e0 | /* func0(std::tuple<std::pair<std::string, std::string >, std::pair<std::string, std::string > >
const&) */
tuple * func0(tuple *param_1)
{
int iVar1;
int *piVar2;
long lVar3;
long lVar4;
long lVar5;
tuple *ptVar6;
int extraout_DL;
int uVar7;
long *in_RSI;
int in_R8B;
int in_R9B;
int iVar9;
long in_FS_OFFSET;
int4 uVar10;
int4 uVar11;
long lVar12;
int in_stack_ffffffffffffffb8;
int7 uStack_47;
long lVar13;
int *puVar8;
lVar12 = in_RSI[4];
lVar13 = *(long *)(in_FS_OFFSET + 0x28);
piVar2 = __errno_location();
iVar9 = *piVar2;
*piVar2 = 0;
lVar3 = __isoc23_strtol(lVar12,&stack0xffffffffffffffb8,10);
if (lVar12 != CONCAT71(uStack_47,in_stack_ffffffffffffffb8)) {
iVar1 = *piVar2;
if ((iVar1 == 0x22) || (0xffffffff < lVar3 + 0x80000000U)) {
LAB_001017a1:
if (lVar13 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_00101811;
/* try { // try from 001017b8 to 001017bc has its CatchHandler @ 0010183e */
std::__throw_out_of_range("stoi");
LAB_001017bd:
if (lVar13 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_00101811;
/* try { // try from 001017d4 to 001017d8 has its CatchHandler @ 00101832 */
std::__throw_invalid_argument("stoi");
}
else {
lVar12 = *in_RSI;
*piVar2 = 0;
if (iVar1 != 0) {
iVar9 = iVar1;
}
lVar4 = __isoc23_strtol(lVar12,&stack0xffffffffffffffb8,10);
if (lVar12 != CONCAT71(uStack_47,in_stack_ffffffffffffffb8)) {
iVar1 = *piVar2;
if (iVar1 == 0x22) {
LAB_00101785:
if (lVar13 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_00101811;
/* try { // try from 0010179c to 001017a0 has its CatchHandler @ 00101856 */
std::__throw_out_of_range("stoi");
goto LAB_001017a1;
}
if (0xffffffff < lVar4 + 0x80000000U) goto LAB_00101785;
lVar12 = in_RSI[0xc];
*piVar2 = 0;
if (iVar1 != 0) {
iVar9 = iVar1;
}
puVar8 = &stack0xffffffffffffffb8;
lVar5 = __isoc23_strtol(lVar12,&stack0xffffffffffffffb8,10);
uVar10 = (int4)lVar3;
uVar11 = (int4)lVar4;
uVar7 = SUB81(puVar8,0);
if (lVar12 == CONCAT71(uStack_47,in_stack_ffffffffffffffb8)) {
if (lVar13 == *(long *)(in_FS_OFFSET + 0x28)) {
/* try { // try from 0010182d to 00101831 has its CatchHandler @ 0010184a */
ptVar6 = (tuple *)std::__throw_invalid_argument("stoi");
/* catch() { ... } // from try @ 00101760 with catch @ 00101832
catch() { ... } // from try @ 001017d4 with catch @ 00101832 */
ptVar6 = (tuple *)func0(ptVar6,uVar7,extraout_DL,(char)lVar5,in_R8B,in_R9B,(char)lVar3,
(char)lVar4,(char)lVar12,in_stack_ffffffffffffffb8,lVar13);
return ptVar6;
}
goto LAB_00101811;
}
iVar1 = *piVar2;
if ((iVar1 == 0x22) || (0xffffffff < lVar5 + 0x80000000U)) {
LAB_00101765:
if (lVar13 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_00101811;
/* try { // try from 00101780 to 00101784 has its CatchHandler @ 0010184a */
std::__throw_out_of_range("stoi");
goto LAB_00101785;
}
lVar12 = in_RSI[8];
*piVar2 = 0;
if (iVar1 != 0) {
iVar9 = iVar1;
}
lVar3 = __isoc23_strtol(lVar12,&stack0xffffffffffffffb8,10);
if (lVar12 != CONCAT71(uStack_47,in_stack_ffffffffffffffb8)) {
if ((*piVar2 != 0x22) && (lVar3 + 0x80000000U >> 0x20 == 0)) {
if (*piVar2 == 0) {
*piVar2 = iVar9;
}
*(int *)(param_1 + 8) = (int)lVar3;
*(int *)(param_1 + 0xc) = (int)lVar5;
*(int4 *)param_1 = uVar11;
*(int4 *)(param_1 + 4) = uVar10;
if (lVar13 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
goto LAB_00101811;
}
if (lVar13 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_00101811;
/* try { // try from 00101760 to 00101764 has its CatchHandler @ 00101832 */
std::__throw_out_of_range("stoi");
goto LAB_00101765;
}
goto LAB_001017bd;
}
}
if (lVar13 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_00101811;
/* try { // try from 001017f0 to 001017f4 has its CatchHandler @ 00101856 */
std::__throw_invalid_argument("stoi");
}
if (lVar13 == *(long *)(in_FS_OFFSET + 0x28)) {
/* try { // try from 0010180c to 00101810 has its CatchHandler @ 0010183e */
std::__throw_invalid_argument("stoi");
}
LAB_00101811:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
624 | func0 |
#include <cassert>
#include <vector>
#include <string>
#include <utility>
template <typename T>
| std::vector<std::pair<int, T>> func0(const std::vector<T>& list1) {
std::vector<std::pair<int, T>> result;
if (list1.empty()) return result;
T current = list1[0];
int count = 1;
for (size_t i = 1; i < list1.size(); ++i) {
if (list1[i] == current) {
count++;
} else {
result.emplace_back(count, current);
current = list1[i];
count = 1;
}
}
result.emplace_back(count, current);
return result;
}
| int main() {
// Test case 1
std::vector<double> input1 = {1, 1, 2, 3, 4, 4.3, 5, 1};
std::vector<std::pair<int, double>> expected1 = {
{2, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 4.3}, {1, 5}, {1, 1}
};
assert(func0(input1) == expected1);
// Test case 2
std::string input2 = "automatically";
std::vector<char> vec2(input2.begin(), input2.end());
std::vector<std::pair<int, char>> expected2 = {
{1, 'a'}, {1, 'u'}, {1, 't'}, {1, 'o'}, {1, 'm'},
{1, 'a'}, {1, 't'}, {1, 'i'}, {1, 'c'}, {1, 'a'},
{2, 'l'}, {1, 'y'}
};
assert(func0(vec2) == expected2);
// Test case 3
std::string input3 = "python";
std::vector<char> vec3(input3.begin(), input3.end());
std::vector<std::pair<int, char>> expected3 = {
{1, 'p'}, {1, 'y'}, {1, 't'}, {1, 'h'}, {1, 'o'}, {1, 'n'}
};
assert(func0(vec3) == expected3);
return 0;
}
| O0 | cpp | std::vector<std::pair<int, double>, std::allocator<std::pair<int, double> > > func0<double>(std::vector<double, std::allocator<double> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 31b0 <_ZNSt6vectorISt4pairIidESaIS1_EEC1Ev>
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 3d4e <_ZNKSt6vectorIdSaIdEE5emptyEv>
test %al,%al
jne 3310 <_Z5func0IdESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x141>
mov -0x40(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 3db6 <_ZNKSt6vectorIdSaIdEEixEm>
movsd (%rax),%xmm0
movsd %xmm0,-0x28(%rbp)
movl $0x1,-0x2c(%rbp)
movq $0x1,-0x20(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 3dda <_ZNKSt6vectorIdSaIdEE4sizeEv>
cmp %rax,-0x20(%rbp)
setb %al
test %al,%al
je 32d9 <_Z5func0IdESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x10a>
mov -0x20(%rbp),%rdx
mov -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 3db6 <_ZNKSt6vectorIdSaIdEEixEm>
movsd (%rax),%xmm0
movsd -0x28(%rbp),%xmm1
ucomisd %xmm1,%xmm0
setnp %al
mov $0x0,%edx
ucomisd %xmm1,%xmm0
cmovne %edx,%eax
test %al,%al
je 3295 <_Z5func0IdESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xc6>
mov -0x2c(%rbp),%eax
add $0x1,%eax
mov %eax,-0x2c(%rbp)
jmp 32cf <_Z5func0IdESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x100>
lea -0x28(%rbp),%rdx
lea -0x2c(%rbp),%rcx
mov -0x38(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 3e02 <_ZNSt6vectorISt4pairIidESaIS1_EE12emplace_backIJRiRdEEERS1_DpOT_>
mov -0x20(%rbp),%rdx
mov -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 3db6 <_ZNKSt6vectorIdSaIdEEixEm>
movsd (%rax),%xmm0
movsd %xmm0,-0x28(%rbp)
movl $0x1,-0x2c(%rbp)
addq $0x1,-0x20(%rbp)
jmpq 323c <_Z5func0IdESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x6d>
lea -0x28(%rbp),%rdx
lea -0x2c(%rbp),%rcx
mov -0x38(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 3e02 <_ZNSt6vectorISt4pairIidESaIS1_EE12emplace_backIJRiRdEEERS1_DpOT_>
jmp 3311 <_Z5func0IdESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x142>
endbr64
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 3128 <_ZNSt6vectorISt4pairIidESaIS1_EED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 23a0 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 3325 <_Z5func0IdESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x156>
callq 2340 <__stack_chk_fail@plt>
mov -0x38(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0IdESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorISt4pairIidESaIS1_EEC2Ev; std::vector<std::pair<int,double>>::vector(void)
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIdSaIdEE5emptyEv; std::vector<double>::empty(void)
test al, al
jnz loc_31E9
mov rax, [rbp+var_40]
mov esi, 0
mov rdi, rax
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_28], xmm0
mov [rbp+var_2C], 1
mov [rbp+var_20], 1
jmp short loc_31B5
loc_3138:
mov rdx, [rbp+var_20]
mov rax, [rbp+var_40]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd xmm1, [rbp+var_28]
ucomisd xmm0, xmm1
setnp al
mov edx, 0
ucomisd xmm0, xmm1
cmovnz eax, edx
test al, al
jz short loc_3176
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_31B0
loc_3176:
lea rdx, [rbp+var_28]
lea rcx, [rbp+var_2C]
mov rax, [rbp+var_38]
mov rsi, rcx
mov rdi, rax
call _ZNSt6vectorISt4pairIidESaIS1_EE12emplace_backIJRiRdEEERS1_DpOT_; std::vector<std::pair<int,double>>::emplace_back<int &,double &>(int &,double &)
mov rdx, [rbp+var_20]
mov rax, [rbp+var_40]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
movsd xmm0, qword ptr [rax]
movsd [rbp+var_28], xmm0
mov [rbp+var_2C], 1
loc_31B0:
add [rbp+var_20], 1
loc_31B5:
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIdSaIdEE4sizeEv; std::vector<double>::size(void)
cmp [rbp+var_20], rax
setb al
test al, al
jnz loc_3138
lea rdx, [rbp+var_28]
lea rcx, [rbp+var_2C]
mov rax, [rbp+var_38]
mov rsi, rcx
mov rdi, rax
call _ZNSt6vectorISt4pairIidESaIS1_EE12emplace_backIJRiRdEEERS1_DpOT_; std::vector<std::pair<int,double>>::emplace_back<int &,double &>(int &,double &)
jmp short loc_31EA
loc_31E9:
nop
loc_31EA:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_3232
jmp short loc_322D
endbr64
mov rbx, rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorISt4pairIidESaIS1_EED2Ev; std::vector<std::pair<int,double>>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_3225
call ___stack_chk_fail
loc_3225:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_322D:
call ___stack_chk_fail
loc_3232:
mov rax, [rbp+var_38]
mov rbx, [rbp+var_8]
leave
retn | long long func0<double>(long long a1, long long a2)
{
double v2; // xmm0_8
unsigned long long v3; // rax
int v5; // [rsp+14h] [rbp-2Ch] BYREF
double v6; // [rsp+18h] [rbp-28h] BYREF
unsigned long long i; // [rsp+20h] [rbp-20h]
unsigned long long v8; // [rsp+28h] [rbp-18h]
v8 = __readfsqword(0x28u);
std::vector<std::pair<int,double>>::vector(a1);
if ( !(unsigned __int8)std::vector<double>::empty(a2) )
{
v6 = *(double *)std::vector<double>::operator[](a2, 0LL);
v5 = 1;
for ( i = 1LL; ; ++i )
{
v3 = std::vector<double>::size(a2);
if ( i >= v3 )
break;
v2 = *(double *)std::vector<double>::operator[](a2, i);
if ( v2 == v6 )
{
++v5;
}
else
{
std::vector<std::pair<int,double>>::emplace_back<int &,double &>(a1, &v5, &v6);
v6 = *(double *)std::vector<double>::operator[](a2, i);
v5 = 1;
}
}
std::vector<std::pair<int,double>>::emplace_back<int &,double &>(a1, &v5, &v6);
}
return a1;
} | func0<double>:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001030aa
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00103d8e
TEST AL,AL
JNZ 0x001031e9
MOV RAX,qword ptr [RBP + -0x40]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00103df6
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x28],XMM0
MOV dword ptr [RBP + -0x2c],0x1
MOV qword ptr [RBP + -0x20],0x1
JMP 0x001031b5
LAB_00103138:
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00103df6
MOVSD XMM0,qword ptr [RAX]
MOVSD XMM1,qword ptr [RBP + -0x28]
UCOMISD XMM0,XMM1
SETNP AL
MOV EDX,0x0
UCOMISD XMM0,XMM1
CMOVNZ EAX,EDX
TEST AL,AL
JZ 0x00103176
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001031b0
LAB_00103176:
LEA RDX,[RBP + -0x28]
LEA RCX,[RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RCX
MOV RDI,RAX
LAB_00103188:
CALL 0x00103e42
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00103df6
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x28],XMM0
MOV dword ptr [RBP + -0x2c],0x1
LAB_001031b0:
ADD qword ptr [RBP + -0x20],0x1
LAB_001031b5:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00103e1a
CMP qword ptr [RBP + -0x20],RAX
SETC AL
TEST AL,AL
JNZ 0x00103138
LEA RDX,[RBP + -0x28]
LEA RCX,[RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00103e42
JMP 0x001031ea
LAB_001031e9:
NOP
LAB_001031ea:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00103232
JMP 0x0010322d
LAB_0010322d:
CALL 0x001022c0
LAB_00103232:
MOV RAX,qword ptr [RBP + -0x38]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* std::vector<std::pair<int, double>, std::allocator<std::pair<int, double> > >
func0<double>(std::vector<double, std::allocator<double> > const&) */
vector func0<double>(vector_conflict *param_1)
{
char cVar1;
double *pdVar2;
ulong uVar3;
vector<double,std::allocator<double>> *in_RSI;
long in_FS_OFFSET;
int local_34;
double local_30;
ulong local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<std::pair<int,double>,std::allocator<std::pair<int,double>>>::vector
((vector<std::pair<int,double>,std::allocator<std::pair<int,double>>> *)param_1);
cVar1 = std::vector<double,std::allocator<double>>::empty(in_RSI);
if (cVar1 == '\0') {
pdVar2 = (double *)std::vector<double,std::allocator<double>>::operator[](in_RSI,0);
local_30 = *pdVar2;
local_34 = 1;
local_28 = 1;
while (uVar3 = std::vector<double,std::allocator<double>>::size(in_RSI), local_28 < uVar3) {
pdVar2 = (double *)std::vector<double,std::allocator<double>>::operator[](in_RSI,local_28);
if (*pdVar2 == local_30) {
local_34 = local_34 + 1;
}
else {
/* try { // try from 00103188 to 001031e6 has its CatchHandler @ 001031fb */
std::vector<std::pair<int,double>,std::allocator<std::pair<int,double>>>::
emplace_back<int&,double&>
((vector<std::pair<int,double>,std::allocator<std::pair<int,double>>> *)param_1,
&local_34,&local_30);
pdVar2 = (double *)std::vector<double,std::allocator<double>>::operator[](in_RSI,local_28);
local_30 = *pdVar2;
local_34 = 1;
}
local_28 = local_28 + 1;
}
std::vector<std::pair<int,double>,std::allocator<std::pair<int,double>>>::
emplace_back<int&,double&>
((vector<std::pair<int,double>,std::allocator<std::pair<int,double>>> *)param_1,
&local_34,&local_30);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return (vector)param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
625 | func0 |
#include <cassert>
#include <vector>
#include <string>
#include <utility>
template <typename T>
| std::vector<std::pair<int, T>> func0(const std::vector<T>& list1) {
std::vector<std::pair<int, T>> result;
if (list1.empty()) return result;
T current = list1[0];
int count = 1;
for (size_t i = 1; i < list1.size(); ++i) {
if (list1[i] == current) {
count++;
} else {
result.emplace_back(count, current);
current = list1[i];
count = 1;
}
}
result.emplace_back(count, current);
return result;
}
| int main() {
// Test case 1
std::vector<double> input1 = {1, 1, 2, 3, 4, 4.3, 5, 1};
std::vector<std::pair<int, double>> expected1 = {
{2, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 4.3}, {1, 5}, {1, 1}
};
assert(func0(input1) == expected1);
// Test case 2
std::string input2 = "automatically";
std::vector<char> vec2(input2.begin(), input2.end());
std::vector<std::pair<int, char>> expected2 = {
{1, 'a'}, {1, 'u'}, {1, 't'}, {1, 'o'}, {1, 'm'},
{1, 'a'}, {1, 't'}, {1, 'i'}, {1, 'c'}, {1, 'a'},
{2, 'l'}, {1, 'y'}
};
assert(func0(vec2) == expected2);
// Test case 3
std::string input3 = "python";
std::vector<char> vec3(input3.begin(), input3.end());
std::vector<std::pair<int, char>> expected3 = {
{1, 'p'}, {1, 'y'}, {1, 't'}, {1, 'h'}, {1, 'o'}, {1, 'n'}
};
assert(func0(vec3) == expected3);
return 0;
}
| O1 | cpp | std::vector<std::pair<int, char>, std::allocator<std::pair<int, char> > > func0<char>(std::vector<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
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov 0x8(%rsi),%rax
mov (%rsi),%rdx
cmp %rax,%rdx
je 1f86 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xe9>
mov %rsi,%rbp
movzbl (%rdx),%ecx
mov %cl,0x3(%rsp)
movl $0x1,0x4(%rsp)
sub %rdx,%rax
cmp $0x1,%rax
jbe 1f55 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xb8>
mov $0x1,%ebx
lea 0x3(%rsp),%r13
jmp 1f44 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xa7>
lea 0x4(%rsp),%rsi
mov %r13,%rdx
mov %r12,%rdi
callq 1d56 <_ZNSt6vectorISt4pairIicESaIS1_EE12emplace_backIJRiRcEEERS1_DpOT_>
mov 0x0(%rbp),%rax
movzbl (%rax,%rbx,1),%eax
mov %al,0x3(%rsp)
movl $0x1,0x4(%rsp)
add $0x1,%rbx
mov 0x0(%rbp),%rdx
mov 0x8(%rbp),%rax
sub %rdx,%rax
cmp %rax,%rbx
jae 1f55 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xb8>
movzbl 0x3(%rsp),%eax
cmp %al,(%rdx,%rbx,1)
jne 1f0c <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x6f>
addl $0x1,0x4(%rsp)
jmp 1f30 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x93>
lea 0x3(%rsp),%rdx
lea 0x4(%rsp),%rsi
mov %r12,%rdi
callq 1d56 <_ZNSt6vectorISt4pairIicESaIS1_EE12emplace_backIJRiRcEEERS1_DpOT_>
jmp 1f86 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xe9>
endbr64
mov %rax,%rbx
mov (%r12),%rdi
test %rdi,%rdi
je 1f7e <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xe1>
callq 1110 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1140 <_Unwind_Resume@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1fa4 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x107>
mov %r12,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1130 <__stack_chk_fail@plt>
| _Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE:
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
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp [rsi+8], rdx
jz loc_21A3
mov rbp, rsi
movzx eax, byte ptr [rdx]
mov [rsp+38h+var_35], al
mov [rsp+38h+var_34], 1
mov rax, [rsi+8]
sub rax, rdx
cmp rax, 1
jbe short loc_2163
mov ebx, 1
lea r13, [rsp+38h+var_35]
jmp short loc_2150
loc_2117:
lea rsi, [rsp+38h+var_34]
mov rdx, r13
mov rdi, r12
call _ZNSt6vectorISt4pairIicESaIS1_EE12emplace_backIJRiRcEEERS1_DpOT_; std::vector<std::pair<int,char>>::emplace_back<int &,char &>(int &,char &)
mov rax, [rbp+0]
movzx eax, byte ptr [rax+rbx]
mov [rsp+38h+var_35], al
mov eax, 1
loc_2138:
mov [rsp+38h+var_34], eax
add rbx, 1
mov rdx, [rbp+0]
mov rax, [rbp+8]
sub rax, rdx
cmp rbx, rax
jnb short loc_2163
loc_2150:
movzx eax, [rsp+38h+var_35]
cmp [rdx+rbx], al
jnz short loc_2117
mov eax, [rsp+38h+var_34]
add eax, 1
jmp short loc_2138
loc_2163:
lea rdx, [rsp+38h+var_35]
lea rsi, [rsp+38h+var_34]
mov rdi, r12
call _ZNSt6vectorISt4pairIicESaIS1_EE12emplace_backIJRiRcEEERS1_DpOT_; std::vector<std::pair<int,char>>::emplace_back<int &,char &>(int &,char &)
jmp short loc_21A3
endbr64
mov rbx, rax
mov rdi, r12
call _ZNSt6vectorISt4pairIicESaIS1_EED2Ev; std::vector<std::pair<int,char>>::~vector()
mov rax, [rsp+arg_0]
sub rax, fs:28h
jz short loc_219B
call ___stack_chk_fail
loc_219B:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_21A3:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_21C1
mov rax, r12
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_21C1:
call ___stack_chk_fail | _QWORD * func0<char>(_QWORD *a1, long long a2)
{
char *v2; // rdx
unsigned long long v3; // rbx
int v4; // eax
char v6; // [rsp+3h] [rbp-35h] BYREF
int v7; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v8; // [rsp+8h] [rbp-30h]
v8 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v2 = *(char **)a2;
if ( *(_QWORD *)(a2 + 8) != *(_QWORD *)a2 )
{
v6 = *v2;
v7 = 1;
if ( *(_QWORD *)(a2 + 8) - (_QWORD)v2 > 1uLL )
{
v3 = 1LL;
do
{
if ( v2[v3] == v6 )
{
v4 = v7 + 1;
}
else
{
std::vector<std::pair<int,char>>::emplace_back<int &,char &>(a1, &v7, &v6);
v6 = *(_BYTE *)(*(_QWORD *)a2 + v3);
v4 = 1;
}
v7 = v4;
++v3;
v2 = *(char **)a2;
}
while ( v3 < *(_QWORD *)(a2 + 8) - *(_QWORD *)a2 );
}
std::vector<std::pair<int,char>>::emplace_back<int &,char &>(a1, &v7, &v6);
}
return a1;
} | func0<char>:
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
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001021a3
MOV RBP,RSI
MOVZX EAX,byte ptr [RDX]
MOV byte ptr [RSP + 0x3],AL
MOV dword ptr [RSP + 0x4],0x1
MOV RAX,qword ptr [RSI + 0x8]
SUB RAX,RDX
CMP RAX,0x1
JBE 0x00102163
MOV EBX,0x1
LEA R13,[RSP + 0x3]
JMP 0x00102150
LAB_00102117:
LEA RSI,[RSP + 0x4]
MOV RDX,R13
MOV RDI,R12
LAB_00102122:
CALL 0x00101f6a
MOV RAX,qword ptr [RBP]
MOVZX EAX,byte ptr [RAX + RBX*0x1]
MOV byte ptr [RSP + 0x3],AL
MOV EAX,0x1
LAB_00102138:
MOV dword ptr [RSP + 0x4],EAX
ADD RBX,0x1
MOV RDX,qword ptr [RBP]
MOV RAX,qword ptr [RBP + 0x8]
SUB RAX,RDX
CMP RBX,RAX
JNC 0x00102163
LAB_00102150:
MOVZX EAX,byte ptr [RSP + 0x3]
CMP byte ptr [RDX + RBX*0x1],AL
JNZ 0x00102117
MOV EAX,dword ptr [RSP + 0x4]
ADD EAX,0x1
JMP 0x00102138
LAB_00102163:
LEA RDX,[RSP + 0x3]
LEA RSI,[RSP + 0x4]
MOV RDI,R12
CALL 0x00101f6a
JMP 0x001021a3
LAB_001021a3:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001021c1
MOV RAX,R12
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001021c1:
CALL 0x00101160 | /* std::vector<std::pair<int, char>, std::allocator<std::pair<int, char> > >
func0<char>(std::vector<char, std::allocator<char> > const&) */
vector<std::pair<int,char>,std::allocator<std::pair<int,char>>> *
func0<char>(vector<std::pair<int,char>,std::allocator<std::pair<int,char>>> *param_1,long *param_2)
{
char *pcVar1;
ulong uVar2;
long in_FS_OFFSET;
char local_35;
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;
pcVar1 = (char *)*param_2;
if ((char *)param_2[1] != pcVar1) {
local_35 = *pcVar1;
local_34 = 1;
if (1 < (ulong)(param_2[1] - (long)pcVar1)) {
uVar2 = 1;
do {
if (pcVar1[uVar2] == local_35) {
local_34 = local_34 + 1;
}
else {
/* try { // try from 00102122 to 00102174 has its CatchHandler @ 00102177 */
std::vector<std::pair<int,char>,std::allocator<std::pair<int,char>>>::
emplace_back<int&,char&>(param_1,&local_34,&local_35);
local_35 = *(char *)(*param_2 + uVar2);
local_34 = 1;
}
uVar2 = uVar2 + 1;
pcVar1 = (char *)*param_2;
} while (uVar2 < (ulong)(param_2[1] - (long)pcVar1));
}
std::vector<std::pair<int,char>,std::allocator<std::pair<int,char>>>::emplace_back<int&,char&>
(param_1,&local_34,&local_35);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
626 | func0 |
#include <cassert>
#include <vector>
#include <string>
#include <utility>
template <typename T>
| std::vector<std::pair<int, T>> func0(const std::vector<T>& list1) {
std::vector<std::pair<int, T>> result;
if (list1.empty()) return result;
T current = list1[0];
int count = 1;
for (size_t i = 1; i < list1.size(); ++i) {
if (list1[i] == current) {
count++;
} else {
result.emplace_back(count, current);
current = list1[i];
count = 1;
}
}
result.emplace_back(count, current);
return result;
}
| int main() {
// Test case 1
std::vector<double> input1 = {1, 1, 2, 3, 4, 4.3, 5, 1};
std::vector<std::pair<int, double>> expected1 = {
{2, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 4.3}, {1, 5}, {1, 1}
};
assert(func0(input1) == expected1);
// Test case 2
std::string input2 = "automatically";
std::vector<char> vec2(input2.begin(), input2.end());
std::vector<std::pair<int, char>> expected2 = {
{1, 'a'}, {1, 'u'}, {1, 't'}, {1, 'o'}, {1, 'm'},
{1, 'a'}, {1, 't'}, {1, 'i'}, {1, 'c'}, {1, 'a'},
{2, 'l'}, {1, 'y'}
};
assert(func0(vec2) == expected2);
// Test case 3
std::string input3 = "python";
std::vector<char> vec3(input3.begin(), input3.end());
std::vector<std::pair<int, char>> expected3 = {
{1, 'p'}, {1, 'y'}, {1, 't'}, {1, 'h'}, {1, 'o'}, {1, 'n'}
};
assert(func0(vec3) == expected3);
return 0;
}
| O2 | cpp | std::vector<std::pair<int, char>, std::allocator<std::pair<int, char> > > func0<char>(std::vector<char, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov 0x8(%rsi),%rcx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rsi),%rax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
cmp %rcx,%rax
je 20b9 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xe9>
movzbl (%rax),%edx
mov %rsi,%rbp
mov %rcx,%rsi
lea 0x3(%rsp),%r14
sub %rax,%rsi
movl $0x1,0x4(%rsp)
lea 0x4(%rsp),%r13
mov %dl,0x3(%rsp)
cmp $0x1,%rsi
je 20ab <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xdb>
mov $0x1,%ebx
lea 0x3(%rsp),%r14
lea 0x4(%rsp),%r13
jmp 2071 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xa1>
nopl 0x0(%rax,%rax,1)
mov %rcx,%rdx
add $0x1,%rbx
addl $0x1,0x4(%rsp)
sub %rax,%rdx
cmp %rdx,%rbx
jae 20ab <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xdb>
movzbl 0x3(%rsp),%edx
cmp %dl,(%rax,%rbx,1)
je 2058 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x88>
mov %r14,%rdx
mov %r13,%rsi
mov %r12,%rdi
callq 1f80 <_ZNSt6vectorISt4pairIicESaIS1_EE12emplace_backIJRiRcEEERS1_DpOT_>
mov 0x0(%rbp),%rax
mov 0x8(%rbp),%rcx
movzbl (%rax,%rbx,1),%edx
add $0x1,%rbx
movl $0x1,0x4(%rsp)
mov %dl,0x3(%rsp)
mov %rcx,%rdx
sub %rax,%rdx
cmp %rdx,%rbx
jb 206c <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x9c>
mov %r14,%rdx
mov %r13,%rsi
mov %r12,%rdi
callq 1f80 <_ZNSt6vectorISt4pairIicESaIS1_EE12emplace_backIJRiRcEEERS1_DpOT_>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 20d9 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x109>
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
mov (%r12),%rdi
test %rdi,%rdi
je 20f3 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x123>
callq 1110 <_ZdlPv@plt>
mov %rbp,%rdi
callq 1140 <_Unwind_Resume@plt>
nopl 0x0(%rax,%rax,1)
| _Z5func0IdESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE:
endbr64
push r13
pxor xmm0, xmm0
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 28h
mov rdx, [rsi]
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov rax, [rsi+8]
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
cmp rax, rdx
jz loc_1FC0
movsd xmm0, qword ptr [rdx]
sub rax, rdx
mov [rsp+48h+var_3C], 1
movsd [rsp+48h+var_38], xmm0
cmp rax, 8
jbe loc_2000
mov rbp, rsi
xor edi, edi
xor esi, esi
mov ebx, 1
jmp short loc_1F53
loc_1F30:
add [rsp+48h+var_3C], 1
mov rdx, [rbp+0]
loc_1F39:
mov rax, [rbp+8]
add rbx, 1
sub rax, rdx
sar rax, 3
cmp rbx, rax
jnb short loc_1FA0
movsd xmm0, [rsp+48h+var_38]
loc_1F53:
ucomisd xmm0, qword ptr [rdx+rbx*8]
lea r13, ds:0[rbx*8]
jp short loc_1F64
jz short loc_1F30
loc_1F64:
cmp rsi, rdi
jz short loc_1FE0
mov eax, [rsp+48h+var_3C]
movsd qword ptr [rsi+8], xmm0
add rsi, 10h
mov [rsi-10h], eax
mov [r12+8], rsi
loc_1F7E:
mov rdx, [rbp+0]
mov [rsp+48h+var_3C], 1
movsd xmm0, qword ptr [rdx+r13]
movsd [rsp+48h+var_38], xmm0
jmp short loc_1F39
loc_1FA0:
cmp rsi, rdi
jz short loc_2002
mov eax, [rsp+48h+var_3C]
movsd xmm0, [rsp+48h+var_38]
add rsi, 10h
mov [rsi-10h], eax
movsd qword ptr [rsi-8], xmm0
mov [r12+8], rsi
loc_1FC0:
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jnz short loc_2031
add rsp, 28h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1FE0:
lea rcx, [rsp+48h+var_38]
lea rdx, [rsp+48h+var_3C]
mov rdi, r12
call _ZNSt6vectorISt4pairIidESaIS1_EE17_M_realloc_insertIJRiRdEEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<std::pair<int,double>>::_M_realloc_insert<int &,double &>(__gnu_cxx::__normal_iterator<std::pair<int,double>*,std::vector<std::pair<int,double>>>,int &,double &)
mov rsi, [r12+8]
mov rdi, [r12+10h]
jmp short loc_1F7E
loc_2000:
xor edi, edi
loc_2002:
mov rsi, rdi
lea rcx, [rsp+48h+var_38]
lea rdx, [rsp+48h+var_3C]
mov rdi, r12
call _ZNSt6vectorISt4pairIidESaIS1_EE17_M_realloc_insertIJRiRdEEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<std::pair<int,double>>::_M_realloc_insert<int &,double &>(__gnu_cxx::__normal_iterator<std::pair<int,double>*,std::vector<std::pair<int,double>>>,int &,double &)
jmp short loc_1FC0
loc_2019:
mov rdi, r12
call _ZNSt6vectorISt4pairIidESaIS1_EED2Ev; std::vector<std::pair<int,double>>::~vector()
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jz short loc_203F
loc_2031:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp short loc_2019
loc_203F:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume | long long func0<double>(long long a1, double **a2)
{
double *v3; // rdx
double *v4; // rax
double v5; // xmm0_8
long long v7; // rdi
long long v8; // rsi
long long v9; // rbx
int v10; // eax
long long v11; // xmm0_8
long long v12; // rsi
int v14; // [rsp+4h] [rbp-3Ch] BYREF
_QWORD v15[7]; // [rsp+8h] [rbp-38h] BYREF
v3 = *a2;
v15[1] = __readfsqword(0x28u);
v4 = a2[1];
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
if ( v4 != v3 )
{
v5 = *v3;
v14 = 1;
*(double *)v15 = v5;
if ( (unsigned long long)((char *)v4 - (char *)v3) <= 8 )
{
v7 = 0LL;
}
else
{
v7 = 0LL;
v8 = 0LL;
v9 = 1LL;
while ( 1 )
{
if ( v5 == v3[v9] )
{
++v14;
v3 = *a2;
}
else
{
if ( v8 == v7 )
{
std::vector<std::pair<int,double>>::_M_realloc_insert<int &,double &>(a1, v8, &v14, v15);
v8 = *(_QWORD *)(a1 + 8);
v7 = *(_QWORD *)(a1 + 16);
}
else
{
v10 = v14;
*(double *)(v8 + 8) = v5;
v8 += 16LL;
*(_DWORD *)(v8 - 16) = v10;
*(_QWORD *)(a1 + 8) = v8;
}
v3 = *a2;
v14 = 1;
*(double *)v15 = v3[v9];
}
if ( ++v9 >= (unsigned long long)(a2[1] - v3) )
break;
v5 = *(double *)v15;
}
if ( v8 != v7 )
{
v11 = v15[0];
v12 = v8 + 16;
*(_DWORD *)(v12 - 16) = v14;
*(_QWORD *)(v12 - 8) = v11;
*(_QWORD *)(a1 + 8) = v12;
return a1;
}
}
std::vector<std::pair<int,double>>::_M_realloc_insert<int &,double &>(a1, v7, &v14, v15);
}
return a1;
} | func0<double>:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RDX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
CMP RAX,RDX
JZ 0x00101fc0
MOVSD XMM0,qword ptr [RDX]
SUB RAX,RDX
MOV dword ptr [RSP + 0xc],0x1
MOVSD qword ptr [RSP + 0x10],XMM0
CMP RAX,0x8
JBE 0x00102000
MOV RBP,RSI
XOR EDI,EDI
XOR ESI,ESI
MOV EBX,0x1
JMP 0x00101f53
LAB_00101f30:
ADD dword ptr [RSP + 0xc],0x1
MOV RDX,qword ptr [RBP]
LAB_00101f39:
MOV RAX,qword ptr [RBP + 0x8]
ADD RBX,0x1
SUB RAX,RDX
SAR RAX,0x3
CMP RBX,RAX
JNC 0x00101fa0
MOVSD XMM0,qword ptr [RSP + 0x10]
LAB_00101f53:
UCOMISD XMM0,qword ptr [RDX + RBX*0x8]
LEA R13,[RBX*0x8]
JP 0x00101f64
JZ 0x00101f30
LAB_00101f64:
CMP RSI,RDI
JZ 0x00101fe0
MOV EAX,dword ptr [RSP + 0xc]
MOVSD qword ptr [RSI + 0x8],XMM0
ADD RSI,0x10
MOV dword ptr [RSI + -0x10],EAX
MOV qword ptr [R12 + 0x8],RSI
LAB_00101f7e:
MOV RDX,qword ptr [RBP]
MOV dword ptr [RSP + 0xc],0x1
MOVSD XMM0,qword ptr [RDX + R13*0x1]
MOVSD qword ptr [RSP + 0x10],XMM0
JMP 0x00101f39
LAB_00101fa0:
CMP RSI,RDI
JZ 0x00102002
MOV EAX,dword ptr [RSP + 0xc]
MOVSD XMM0,qword ptr [RSP + 0x10]
ADD RSI,0x10
MOV dword ptr [RSI + -0x10],EAX
MOVSD qword ptr [RSI + -0x8],XMM0
MOV qword ptr [R12 + 0x8],RSI
LAB_00101fc0:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00102031
ADD RSP,0x28
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101fe0:
LEA RCX,[RSP + 0x10]
LEA RDX,[RSP + 0xc]
MOV RDI,R12
LAB_00101fed:
CALL 0x00101d10
MOV RSI,qword ptr [R12 + 0x8]
MOV RDI,qword ptr [R12 + 0x10]
JMP 0x00101f7e
LAB_00102000:
XOR EDI,EDI
LAB_00102002:
MOV RSI,RDI
LEA RCX,[RSP + 0x10]
LEA RDX,[RSP + 0xc]
MOV RDI,R12
CALL 0x00101d10
JMP 0x00101fc0
LAB_00102031:
CALL 0x00101160 | /* std::vector<std::pair<int, double>, std::allocator<std::pair<int, double> > >
func0<double>(std::vector<double, std::allocator<double> > const&) */
vector<std::pair<int,double>,std::allocator<std::pair<int,double>>> *
func0<double>(vector<std::pair<int,double>,std::allocator<std::pair<int,double>>> *param_1,
int8 *param_2)
{
double *pdVar1;
double *pdVar2;
ulong uVar3;
int *piVar4;
int *piVar5;
int *piVar6;
long in_FS_OFFSET;
int local_3c;
double local_38;
long local_30;
pdVar2 = (double *)*param_2;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pdVar1 = (double *)param_2[1];
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
if (pdVar1 != pdVar2) {
local_38 = *pdVar2;
local_3c = 1;
if ((ulong)((long)pdVar1 - (long)pdVar2) < 9) {
piVar6 = (int *)0x0;
}
else {
piVar6 = (int *)0x0;
piVar4 = (int *)0x0;
uVar3 = 1;
do {
if (local_38 == pdVar2[uVar3]) {
local_3c = local_3c + 1;
pdVar2 = (double *)*param_2;
}
else {
if (piVar4 == piVar6) {
/* try { // try from 00101fed to 00102016 has its CatchHandler @ 00102036 */
std::vector<std::pair<int,double>,std::allocator<std::pair<int,double>>>::
_M_realloc_insert<int&,double&>(param_1,(__normal_iterator)piVar4,&local_3c,&local_38);
piVar5 = *(int **)(param_1 + 8);
piVar6 = *(int **)(param_1 + 0x10);
}
else {
*(double *)(piVar4 + 2) = local_38;
piVar5 = piVar4 + 4;
*piVar4 = local_3c;
*(int **)(param_1 + 8) = piVar5;
}
pdVar2 = (double *)*param_2;
local_3c = 1;
local_38 = pdVar2[uVar3];
piVar4 = piVar5;
}
uVar3 = uVar3 + 1;
} while (uVar3 < (ulong)(param_2[1] - (long)pdVar2 >> 3));
if (piVar4 != piVar6) {
*piVar4 = local_3c;
*(double *)(piVar4 + 2) = local_38;
*(int **)(param_1 + 8) = piVar4 + 4;
goto LAB_00101fc0;
}
}
std::vector<std::pair<int,double>,std::allocator<std::pair<int,double>>>::
_M_realloc_insert<int&,double&>(param_1,(__normal_iterator)piVar6,&local_3c,&local_38);
}
LAB_00101fc0:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
627 | func0 |
#include <cassert>
#include <vector>
#include <string>
#include <utility>
template <typename T>
| std::vector<std::pair<int, T>> func0(const std::vector<T>& list1) {
std::vector<std::pair<int, T>> result;
if (list1.empty()) return result;
T current = list1[0];
int count = 1;
for (size_t i = 1; i < list1.size(); ++i) {
if (list1[i] == current) {
count++;
} else {
result.emplace_back(count, current);
current = list1[i];
count = 1;
}
}
result.emplace_back(count, current);
return result;
}
| int main() {
// Test case 1
std::vector<double> input1 = {1, 1, 2, 3, 4, 4.3, 5, 1};
std::vector<std::pair<int, double>> expected1 = {
{2, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 4.3}, {1, 5}, {1, 1}
};
assert(func0(input1) == expected1);
// Test case 2
std::string input2 = "automatically";
std::vector<char> vec2(input2.begin(), input2.end());
std::vector<std::pair<int, char>> expected2 = {
{1, 'a'}, {1, 'u'}, {1, 't'}, {1, 'o'}, {1, 'm'},
{1, 'a'}, {1, 't'}, {1, 'i'}, {1, 'c'}, {1, 'a'},
{2, 'l'}, {1, 'y'}
};
assert(func0(vec2) == expected2);
// Test case 3
std::string input3 = "python";
std::vector<char> vec3(input3.begin(), input3.end());
std::vector<std::pair<int, char>> expected3 = {
{1, 'p'}, {1, 'y'}, {1, 't'}, {1, 'h'}, {1, 'o'}, {1, 'n'}
};
assert(func0(vec3) == expected3);
return 0;
}
| O3 | cpp | std::vector<std::pair<int, char>, std::allocator<std::pair<int, char> > > func0<char>(std::vector<char, std::allocator<char> > const&):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov 0x8(%rsi),%r8
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rsi),%rax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
cmp %r8,%rax
je 237d <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xed>
movzbl (%rax),%edx
mov %r8,%rcx
movl $0x1,0x4(%rsp)
sub %rax,%rcx
mov %dl,0x3(%rsp)
cmp $0x1,%rcx
je 23c0 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x130>
mov %rsi,%rbp
mov $0x1,%ecx
xor %r9d,%r9d
xor %esi,%esi
mov $0x1,%ebx
lea 0x3(%rsp),%r13
jmp 2326 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x96>
nopl 0x0(%rax,%rax,1)
mov %r8,%rdi
add $0x1,%ecx
add $0x1,%rbx
sub %rax,%rdi
mov %ecx,0x4(%rsp)
cmp %rdi,%rbx
jae 236a <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xda>
cmp %dl,(%rax,%rbx,1)
je 2310 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x80>
cmp %r9,%rsi
je 23a0 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x110>
mov %ecx,(%rsi)
add $0x8,%rsi
mov %dl,-0x4(%rsi)
mov %rsi,0x8(%r12)
mov 0x0(%rbp),%rax
mov 0x8(%rbp),%r8
mov $0x1,%ecx
movzbl (%rax,%rbx,1),%edx
mov %r8,%rdi
add $0x1,%rbx
movl $0x1,0x4(%rsp)
sub %rax,%rdi
mov %dl,0x3(%rsp)
cmp %rdi,%rbx
jb 2326 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x96>
cmp %r9,%rsi
je 23c2 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x132>
mov %ecx,(%rsi)
add $0x8,%rsi
mov %dl,-0x4(%rsi)
mov %rsi,0x8(%r12)
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 23d6 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x146>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
lea 0x4(%rsp),%rdx
mov %r13,%rcx
mov %r12,%rdi
callq 2100 <_ZNSt6vectorISt4pairIicESaIS1_EE17_M_realloc_insertIJRiRcEEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_>
mov 0x8(%r12),%rsi
mov 0x10(%r12),%r9
jmp 233e <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xae>
nopl 0x0(%rax)
xor %esi,%esi
lea 0x3(%rsp),%rcx
lea 0x4(%rsp),%rdx
mov %r12,%rdi
callq 2100 <_ZNSt6vectorISt4pairIicESaIS1_EE17_M_realloc_insertIJRiRcEEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_>
jmp 237d <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0xed>
callq 1100 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
mov (%r12),%rdi
test %rdi,%rdi
je 23f0 <_Z5func0IcESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE+0x160>
callq 10e0 <_ZdlPv@plt>
mov %rbp,%rdi
callq 1110 <_Unwind_Resume@plt>
nopl 0x0(%rax,%rax,1)
| _Z5func0IdESt6vectorISt4pairIiT_ESaIS3_EERKS0_IS2_SaIS2_EE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
mov rcx, [rsi]
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rdi, [rsi+8]
cmp rdi, rcx
jz loc_1F5C
movsd xmm0, qword ptr [rcx]
mov rax, rdi
mov [rsp+48h+var_3C], 1
sub rax, rcx
movsd [rsp+48h+var_38], xmm0
cmp rax, 8
jbe loc_1FA8
mov r12, rsi
mov edx, 1
xor r8d, r8d
xor esi, esi
mov ebx, 1
jmp short loc_1F0A
loc_1EF0:
add edx, 1
loc_1EF3:
mov rax, rdi
add rbx, 1
mov [rsp+48h+var_3C], edx
sub rax, rcx
sar rax, 3
cmp rbx, rax
jnb short loc_1F48
loc_1F0A:
ucomisd xmm0, qword ptr [rcx+rbx*8]
lea r13, ds:0[rbx*8]
jp short loc_1F1B
jz short loc_1EF0
loc_1F1B:
cmp rsi, r8
jz short loc_1F80
mov [rsi], edx
add rsi, 10h
movsd qword ptr [rsi-8], xmm0
mov [rbp+8], rsi
loc_1F2F:
movsd xmm0, qword ptr [rcx+r13]
mov edx, 1
movsd [rsp+48h+var_38], xmm0
jmp short loc_1EF3
loc_1F48:
cmp rsi, r8
jz short loc_1FAB
mov [rsi], edx
add rsi, 10h
movsd qword ptr [rsi-8], xmm0
mov [rbp+8], rsi
loc_1F5C:
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jnz short loc_1FDA
add rsp, 28h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1F80:
lea rcx, [rsp+48h+var_38]
lea rdx, [rsp+48h+var_3C]
mov rdi, rbp
call _ZNSt6vectorISt4pairIidESaIS1_EE17_M_realloc_insertIJRiRdEEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<std::pair<int,double>>::_M_realloc_insert<int &,double &>(__gnu_cxx::__normal_iterator<std::pair<int,double>*,std::vector<std::pair<int,double>>>,int &,double &)
mov rcx, [r12]
mov rdi, [r12+8]
mov rsi, [rbp+8]
mov r8, [rbp+10h]
jmp short loc_1F2F
loc_1FA8:
xor r8d, r8d
loc_1FAB:
lea rcx, [rsp+48h+var_38]
lea rdx, [rsp+48h+var_3C]
mov rsi, r8
mov rdi, rbp
call _ZNSt6vectorISt4pairIidESaIS1_EE17_M_realloc_insertIJRiRdEEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<std::pair<int,double>>::_M_realloc_insert<int &,double &>(__gnu_cxx::__normal_iterator<std::pair<int,double>*,std::vector<std::pair<int,double>>>,int &,double &)
jmp short loc_1F5C
loc_1FC2:
mov rdi, rbp
call _ZNSt6vectorISt4pairIidESaIS1_EED2Ev; std::vector<std::pair<int,double>>::~vector()
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jz short loc_1FE8
loc_1FDA:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp short loc_1FC2
loc_1FE8:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume | long long func0<double>(long long a1, double **a2)
{
double *v3; // rcx
double *v4; // rdi
double v5; // xmm0_8
int v7; // edx
int *v8; // r8
int *v9; // rsi
unsigned long long v10; // rbx
double *v11; // rsi
int v13; // [rsp+4h] [rbp-3Ch] BYREF
_QWORD v14[7]; // [rsp+8h] [rbp-38h] BYREF
v3 = *a2;
v14[1] = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v4 = a2[1];
if ( v4 != v3 )
{
v5 = *v3;
v13 = 1;
*(double *)v14 = v5;
if ( (unsigned long long)((char *)v4 - (char *)v3) <= 8 )
{
v8 = 0LL;
}
else
{
v7 = 1;
v8 = 0LL;
v9 = 0LL;
v10 = 1LL;
do
{
if ( v5 == v3[v10] )
{
++v7;
}
else
{
if ( v9 == v8 )
{
std::vector<std::pair<int,double>>::_M_realloc_insert<int &,double &>(a1, v9, &v13, v14);
v3 = *a2;
v4 = a2[1];
v9 = *(int **)(a1 + 8);
v8 = *(int **)(a1 + 16);
}
else
{
*v9 = v7;
v9 += 4;
*((double *)v9 - 1) = v5;
*(_QWORD *)(a1 + 8) = v9;
}
v5 = v3[v10];
v7 = 1;
*(double *)v14 = v5;
}
++v10;
v13 = v7;
}
while ( v10 < v4 - v3 );
if ( v9 != v8 )
{
*v9 = v7;
v11 = (double *)(v9 + 4);
*(v11 - 1) = v5;
*(_QWORD *)(a1 + 8) = v11;
return a1;
}
}
std::vector<std::pair<int,double>>::_M_realloc_insert<int &,double &>(a1, v8, &v13, v14);
}
return a1;
} | func0<double>:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x28
MOV RCX,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,qword ptr [RSI + 0x8]
CMP RDI,RCX
JZ 0x00101f5c
MOVSD XMM0,qword ptr [RCX]
MOV RAX,RDI
MOV dword ptr [RSP + 0xc],0x1
SUB RAX,RCX
MOVSD qword ptr [RSP + 0x10],XMM0
CMP RAX,0x8
JBE 0x00101fa8
MOV R12,RSI
MOV EDX,0x1
XOR R8D,R8D
XOR ESI,ESI
MOV EBX,0x1
JMP 0x00101f0a
LAB_00101ef0:
ADD EDX,0x1
LAB_00101ef3:
MOV RAX,RDI
ADD RBX,0x1
MOV dword ptr [RSP + 0xc],EDX
SUB RAX,RCX
SAR RAX,0x3
CMP RBX,RAX
JNC 0x00101f48
LAB_00101f0a:
UCOMISD XMM0,qword ptr [RCX + RBX*0x8]
LEA R13,[RBX*0x8]
JP 0x00101f1b
JZ 0x00101ef0
LAB_00101f1b:
CMP RSI,R8
JZ 0x00101f80
MOV dword ptr [RSI],EDX
ADD RSI,0x10
MOVSD qword ptr [RSI + -0x8],XMM0
MOV qword ptr [RBP + 0x8],RSI
LAB_00101f2f:
MOVSD XMM0,qword ptr [RCX + R13*0x1]
MOV EDX,0x1
MOVSD qword ptr [RSP + 0x10],XMM0
JMP 0x00101ef3
LAB_00101f48:
CMP RSI,R8
JZ 0x00101fab
MOV dword ptr [RSI],EDX
ADD RSI,0x10
MOVSD qword ptr [RSI + -0x8],XMM0
MOV qword ptr [RBP + 0x8],RSI
LAB_00101f5c:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101fda
ADD RSP,0x28
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101f80:
LEA RCX,[RSP + 0x10]
LEA RDX,[RSP + 0xc]
MOV RDI,RBP
LAB_00101f8d:
CALL 0x00101cc0
MOV RCX,qword ptr [R12]
MOV RDI,qword ptr [R12 + 0x8]
MOV RSI,qword ptr [RBP + 0x8]
MOV R8,qword ptr [RBP + 0x10]
JMP 0x00101f2f
LAB_00101fa8:
XOR R8D,R8D
LAB_00101fab:
LEA RCX,[RSP + 0x10]
LEA RDX,[RSP + 0xc]
MOV RSI,R8
MOV RDI,RBP
CALL 0x00101cc0
JMP 0x00101f5c
LAB_00101fda:
CALL 0x00101160 | /* std::vector<std::pair<int, double>, std::allocator<std::pair<int, double> > >
func0<double>(std::vector<double, std::allocator<double> > const&) */
vector func0<double>(vector_conflict *param_1)
{
double *pdVar1;
ulong uVar2;
int8 *in_RSI;
int *piVar3;
int *piVar4;
double *pdVar5;
int *piVar6;
long in_FS_OFFSET;
double dVar7;
int local_3c;
double local_38;
long local_30;
pdVar1 = (double *)*in_RSI;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
pdVar5 = (double *)in_RSI[1];
if (pdVar5 != pdVar1) {
dVar7 = *pdVar1;
local_3c = 1;
local_38 = dVar7;
if ((ulong)((long)pdVar5 - (long)pdVar1) < 9) {
piVar6 = (int *)0x0;
}
else {
piVar6 = (int *)0x0;
piVar3 = (int *)0x0;
uVar2 = 1;
do {
if (dVar7 == pdVar1[uVar2]) {
local_3c = local_3c + 1;
}
else {
if (piVar3 == piVar6) {
/* try { // try from 00101f8d to 00101fbf has its CatchHandler @ 00101fdf */
std::vector<std::pair<int,double>,std::allocator<std::pair<int,double>>>::
_M_realloc_insert<int&,double&>
((vector<std::pair<int,double>,std::allocator<std::pair<int,double>>> *)
param_1,(__normal_iterator)piVar3,&local_3c,&local_38);
pdVar1 = (double *)*in_RSI;
pdVar5 = (double *)in_RSI[1];
piVar4 = *(int **)(param_1 + 8);
piVar6 = *(int **)(param_1 + 0x10);
}
else {
*piVar3 = local_3c;
piVar4 = piVar3 + 4;
*(double *)(piVar3 + 2) = dVar7;
*(int **)(param_1 + 8) = piVar4;
}
dVar7 = pdVar1[uVar2];
local_3c = 1;
piVar3 = piVar4;
local_38 = dVar7;
}
uVar2 = uVar2 + 1;
} while (uVar2 < (ulong)((long)pdVar5 - (long)pdVar1 >> 3));
if (piVar3 != piVar6) {
*piVar3 = local_3c;
*(double *)(piVar3 + 2) = dVar7;
*(int **)(param_1 + 8) = piVar3 + 4;
goto LAB_00101f5c;
}
}
std::vector<std::pair<int,double>,std::allocator<std::pair<int,double>>>::
_M_realloc_insert<int&,double&>
((vector<std::pair<int,double>,std::allocator<std::pair<int,double>>> *)param_1,
(__normal_iterator)piVar6,&local_3c,&local_38);
}
LAB_00101f5c:
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (vector)param_1;
} |
628 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(const std::vector<int>& arr, int n, int k) {
int max1 = *std::max_element(arr.begin(), arr.end());
int res = 0;
for (int i = 0; i < n; ++i) {
if ((max1 - arr[i]) % k != 0) {
return -1;
} else {
res += (max1 - arr[i]) / k;
}
}
return res;
}
| int main() {
assert(func0({2,2,2,2}, 4, 3) == 0);
assert(func0({4,2,6,8}, 4, 3) == -1);
assert(func0({21,33,9,45,63}, 5, 6) == 24);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %edx,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 175e <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1706 <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rbx,%rsi
mov %rax,%rdi
callq 17b6 <_ZSt11max_elementIN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEEET_S8_S8_>
mov %rax,-0x20(%rbp)
lea -0x20(%rbp),%rax
mov %rax,%rdi
callq 17e4 <_ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%eax
mov %eax,-0x24(%rbp)
movl $0x0,-0x2c(%rbp)
movl $0x0,-0x28(%rbp)
mov -0x28(%rbp),%eax
cmp -0x3c(%rbp),%eax
jge 133f <_Z5func0RKSt6vectorIiSaIiEEii+0xd6>
mov -0x28(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 17fa <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
mov -0x24(%rbp),%edx
sub %eax,%edx
mov %edx,%eax
cltd
idivl -0x40(%rbp)
mov %edx,%eax
test %eax,%eax
setne %al
test %al,%al
je 1314 <_Z5func0RKSt6vectorIiSaIiEEii+0xab>
mov $0xffffffff,%eax
jmp 1342 <_Z5func0RKSt6vectorIiSaIiEEii+0xd9>
mov -0x28(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 17fa <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
mov -0x24(%rbp),%edx
sub %eax,%edx
mov %edx,%eax
cltd
idivl -0x40(%rbp)
add %eax,-0x2c(%rbp)
addl $0x1,-0x28(%rbp)
jmp 12d8 <_Z5func0RKSt6vectorIiSaIiEEii+0x6f>
mov -0x2c(%rbp),%eax
mov -0x18(%rbp),%rcx
xor %fs:0x28,%rcx
je 1356 <_Z5func0RKSt6vectorIiSaIiEEii+0xed>
callq 1140 <__stack_chk_fail@plt>
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [rbp+var_38]
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_20], rax
lea rax, [rbp+var_20]
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_24], eax
mov [rbp+var_2C], 0
mov [rbp+var_28], 0
jmp short loc_1317
loc_12BA:
mov eax, [rbp+var_28]
movsxd rdx, eax
mov rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
mov edx, [rbp+var_24]
sub edx, eax
mov eax, edx
cdq
idiv [rbp+var_40]
mov eax, edx
test eax, eax
setnz al
test al, al
jz short loc_12EE
mov eax, 0FFFFFFFFh
jmp short loc_1322
loc_12EE:
mov eax, [rbp+var_28]
movsxd rdx, eax
mov rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
mov edx, [rbp+var_24]
sub edx, eax
mov eax, edx
cdq
idiv [rbp+var_40]
add [rbp+var_2C], eax
add [rbp+var_28], 1
loc_1317:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_3C]
jl short loc_12BA
mov eax, [rbp+var_2C]
loc_1322:
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1336
call ___stack_chk_fail
loc_1336:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2, int a3)
{
long long v3; // rbx
long long v4; // rax
unsigned int v7; // [rsp+14h] [rbp-2Ch]
int i; // [rsp+18h] [rbp-28h]
int v9; // [rsp+1Ch] [rbp-24h]
_QWORD v10[3]; // [rsp+20h] [rbp-20h] BYREF
v10[1] = __readfsqword(0x28u);
v3 = std::vector<int>::end(a1);
v4 = std::vector<int>::begin(a1);
v10[0] = std::max_element<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(v4, v3);
v9 = *(_DWORD *)__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator*(v10);
v7 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (v9 - *(_DWORD *)std::vector<int>::operator[](a1, i)) % a3 )
return 0xFFFFFFFFLL;
v7 += (v9 - *(_DWORD *)std::vector<int>::operator[](a1, i)) / a3;
}
return v7;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
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 0x001016fa
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001016ae
MOV RSI,RBX
MOV RDI,RAX
CALL 0x0010174a
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[RBP + -0x20]
MOV RDI,RAX
CALL 0x00101778
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x2c],0x0
MOV dword ptr [RBP + -0x28],0x0
JMP 0x00101317
LAB_001012ba:
MOV EAX,dword ptr [RBP + -0x28]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010178e
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x24]
SUB EDX,EAX
MOV EAX,EDX
CDQ
IDIV dword ptr [RBP + -0x40]
MOV EAX,EDX
TEST EAX,EAX
SETNZ AL
TEST AL,AL
JZ 0x001012ee
MOV EAX,0xffffffff
JMP 0x00101322
LAB_001012ee:
MOV EAX,dword ptr [RBP + -0x28]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010178e
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x24]
SUB EDX,EAX
MOV EAX,EDX
CDQ
IDIV dword ptr [RBP + -0x40]
ADD dword ptr [RBP + -0x2c],EAX
ADD dword ptr [RBP + -0x28],0x1
LAB_00101317:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x001012ba
MOV EAX,dword ptr [RBP + -0x2c]
LAB_00101322:
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101336
CALL 0x00101130
LAB_00101336:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
int iVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int4 extraout_var;
int *piVar4;
long in_FS_OFFSET;
int local_34;
int local_30;
int8 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
_Var2 = std::vector<int,std::allocator<int>>::end((vector<int,std::allocator<int>> *)param_1);
_Var3 = std::vector<int,std::allocator<int>>::begin((vector<int,std::allocator<int>> *)param_1);
_Var2 = std::max_element<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>>
(_Var3,_Var2);
local_28 = CONCAT44(extraout_var,_Var2);
piVar4 = (int *)__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)
&local_28);
iVar1 = *piVar4;
local_34 = 0;
local_30 = 0;
do {
if (param_2 <= local_30) {
LAB_00101322:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_34;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
piVar4 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_30);
if ((iVar1 - *piVar4) % param_3 != 0) {
local_34 = -1;
goto LAB_00101322;
}
piVar4 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_30);
local_34 = local_34 + (iVar1 - *piVar4) / param_3;
local_30 = local_30 + 1;
} while( true );
} |
629 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(const std::vector<int>& arr, int n, int k) {
int max1 = *std::max_element(arr.begin(), arr.end());
int res = 0;
for (int i = 0; i < n; ++i) {
if ((max1 - arr[i]) % k != 0) {
return -1;
} else {
res += (max1 - arr[i]) / k;
}
}
return res;
}
| int main() {
assert(func0({2,2,2,2}, 4, 3) == 0);
assert(func0({4,2,6,8}, 4, 3) == -1);
assert(func0({21,33,9,45,63}, 5, 6) == 24);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
mov %edx,%r8d
mov 0x8(%rdi),%rcx
mov (%rdi),%r10
mov %rcx,%rdx
cmp %rcx,%r10
je 127c <_Z5func0RKSt6vectorIiSaIiEEii+0x33>
lea 0x4(%r10),%rax
cmp %rax,%rcx
je 12b5 <_Z5func0RKSt6vectorIiSaIiEEii+0x6c>
mov %r10,%rdx
mov (%rax),%edi
cmp %edi,(%rdx)
cmovl %rax,%rdx
add $0x4,%rax
cmp %rax,%rcx
jne 126b <_Z5func0RKSt6vectorIiSaIiEEii+0x22>
mov (%rdx),%r9d
test %esi,%esi
jle 12ba <_Z5func0RKSt6vectorIiSaIiEEii+0x71>
mov %r10,%rdi
lea -0x1(%rsi),%eax
lea 0x4(%r10,%rax,4),%r10
mov $0x0,%esi
mov %r9d,%ecx
sub (%rdi),%ecx
mov %ecx,%eax
cltd
idiv %r8d
test %edx,%edx
jne 12c1 <_Z5func0RKSt6vectorIiSaIiEEii+0x78>
mov %ecx,%eax
cltd
idiv %r8d
add %eax,%esi
add $0x4,%rdi
cmp %rdi,%r10
jne 1293 <_Z5func0RKSt6vectorIiSaIiEEii+0x4a>
jmp 12c6 <_Z5func0RKSt6vectorIiSaIiEEii+0x7d>
mov %r10,%rdx
jmp 127c <_Z5func0RKSt6vectorIiSaIiEEii+0x33>
mov $0x0,%esi
jmp 12c6 <_Z5func0RKSt6vectorIiSaIiEEii+0x7d>
mov $0xffffffff,%esi
mov %esi,%eax
retq
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
mov r8d, edx
mov rdx, [rdi+8]
mov r10, [rdi]
cmp r10, rdx
jz short loc_123C
lea rax, [r10+4]
cmp rdx, rax
jz short loc_1274
mov rcx, rdx
mov rdx, r10
loc_122B:
mov edi, [rax]
cmp [rdx], edi
cmovl rdx, rax
add rax, 4
cmp rax, rcx
jnz short loc_122B
loc_123C:
mov r9d, [rdx]
test esi, esi
jle short loc_1279
mov rdi, r10
movsxd rsi, esi
lea r10, [r10+rsi*4]
mov esi, 0
loc_1252:
mov ecx, r9d
sub ecx, [rdi]
mov eax, ecx
cdq
idiv r8d
test edx, edx
jnz short loc_1280
mov eax, ecx
cdq
idiv r8d
add esi, eax
add rdi, 4
cmp r10, rdi
jnz short loc_1252
jmp short loc_1285
loc_1274:
mov rdx, r10
jmp short loc_123C
loc_1279:
mov esi, 0
jmp short loc_1285
loc_1280:
mov esi, 0FFFFFFFFh
loc_1285:
mov eax, esi
retn | long long func0(int **a1, int a2, int a3)
{
int *v4; // rdx
int *v5; // r10
int *v6; // rax
int v7; // r9d
int *v8; // rdi
int *v9; // r10
unsigned int v10; // esi
v4 = a1[1];
v5 = *a1;
if ( *a1 != v4 )
{
v6 = v5 + 1;
if ( v4 == v5 + 1 )
{
v4 = *a1;
}
else
{
v4 = *a1;
do
{
if ( *v4 < *v6 )
v4 = v6;
++v6;
}
while ( v6 != a1[1] );
}
}
v7 = *v4;
if ( a2 <= 0 )
{
return 0;
}
else
{
v8 = *a1;
v9 = &v5[a2];
v10 = 0;
while ( !((v7 - *v8) % a3) )
{
v10 += (v7 - *v8++) / a3;
if ( v9 == v8 )
return v10;
}
return (unsigned int)-1;
}
} | func0:
ENDBR64
MOV R8D,EDX
MOV RDX,qword ptr [RDI + 0x8]
MOV R10,qword ptr [RDI]
CMP R10,RDX
JZ 0x0010123c
LEA RAX,[R10 + 0x4]
CMP RDX,RAX
JZ 0x00101274
MOV RCX,RDX
MOV RDX,R10
LAB_0010122b:
MOV EDI,dword ptr [RAX]
CMP dword ptr [RDX],EDI
CMOVL RDX,RAX
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x0010122b
LAB_0010123c:
MOV R9D,dword ptr [RDX]
TEST ESI,ESI
JLE 0x00101279
MOV RDI,R10
MOVSXD RSI,ESI
LEA R10,[R10 + RSI*0x4]
MOV ESI,0x0
LAB_00101252:
MOV ECX,R9D
SUB ECX,dword ptr [RDI]
MOV EAX,ECX
CDQ
IDIV R8D
TEST EDX,EDX
JNZ 0x00101280
MOV EAX,ECX
CDQ
IDIV R8D
ADD ESI,EAX
ADD RDI,0x4
CMP R10,RDI
JNZ 0x00101252
JMP 0x00101285
LAB_00101274:
MOV RDX,R10
JMP 0x0010123c
LAB_00101279:
MOV ESI,0x0
JMP 0x00101285
LAB_00101280:
MOV ESI,0xffffffff
LAB_00101285:
MOV EAX,ESI
RET | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int [16] func0(vector *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int iVar5;
int *piVar6;
uint uVar7;
int *piVar8;
int auVar9 [16];
piVar2 = *(int **)(param_1 + 8);
piVar8 = *(int **)param_1;
piVar6 = piVar2;
piVar4 = piVar8;
piVar3 = piVar8;
if (piVar8 != piVar2) {
while (piVar6 = piVar4, piVar3 = piVar3 + 1, piVar2 != piVar3) {
piVar4 = piVar6;
if (*piVar6 < *piVar3) {
piVar4 = piVar3;
}
}
}
iVar1 = *piVar6;
if (param_2 < 1) {
uVar7 = 0;
}
else {
piVar2 = piVar8 + param_2;
uVar7 = 0;
do {
iVar5 = iVar1 - *piVar8;
piVar6 = (int *)((long)iVar5 % (long)param_3 & 0xffffffff);
if ((int)((long)iVar5 % (long)param_3) != 0) {
uVar7 = 0xffffffff;
break;
}
piVar6 = (int *)((long)iVar5 % (long)param_3 & 0xffffffff);
uVar7 = uVar7 + iVar5 / param_3;
piVar8 = piVar8 + 1;
} while (piVar2 != piVar8);
}
auVar9._4_4_ = 0;
auVar9._0_4_ = uVar7;
auVar9._8_8_ = piVar6;
return auVar9;
} |
630 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(const std::vector<int>& arr, int n, int k) {
int max1 = *std::max_element(arr.begin(), arr.end());
int res = 0;
for (int i = 0; i < n; ++i) {
if ((max1 - arr[i]) % k != 0) {
return -1;
} else {
res += (max1 - arr[i]) / k;
}
}
return res;
}
| int main() {
assert(func0({2,2,2,2}, 4, 3) == 0);
assert(func0({4,2,6,8}, 4, 3) == -1);
assert(func0({21,33,9,45,63}, 5, 6) == 24);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%r10
mov %edx,%r8d
mov (%rcx),%edx
mov %edx,%edi
cmp %rcx,%r10
je 1483 <_Z5func0RKSt6vectorIiSaIiEEii+0x33>
lea 0x4(%rcx),%rax
cmp %rax,%r10
je 1483 <_Z5func0RKSt6vectorIiSaIiEEii+0x33>
mov (%rax),%r9d
cmp %r9d,%edi
cmovl %r9d,%edi
add $0x4,%rax
cmp %rax,%r10
jne 1470 <_Z5func0RKSt6vectorIiSaIiEEii+0x20>
test %esi,%esi
jle 14c4 <_Z5func0RKSt6vectorIiSaIiEEii+0x74>
add $0x4,%rcx
lea -0x1(%rsi),%eax
xor %r9d,%r9d
lea (%rcx,%rax,4),%rsi
jmp 14ae <_Z5func0RKSt6vectorIiSaIiEEii+0x5e>
nopw 0x0(%rax,%rax,1)
add %eax,%r9d
cmp %rcx,%rsi
je 14c0 <_Z5func0RKSt6vectorIiSaIiEEii+0x70>
mov (%rcx),%edx
add $0x4,%rcx
mov %edi,%eax
sub %edx,%eax
cltd
idiv %r8d
test %edx,%edx
je 14a0 <_Z5func0RKSt6vectorIiSaIiEEii+0x50>
mov $0xffffffff,%r9d
mov %r9d,%eax
retq
xor %r9d,%r9d
jmp 14c0 <_Z5func0RKSt6vectorIiSaIiEEii+0x70>
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
mov r9, [rdi+8]
mov rcx, [rdi]
mov r8d, edx
cmp rcx, r9
jz short loc_1420
lea rax, [rcx+4]
mov edi, [rcx]
cmp r9, rax
jz short loc_13E8
mov rdx, r9
sub rdx, rax
and edx, 4
jz short loc_13D0
mov eax, [rax]
cmp edi, eax
cmovl edi, eax
lea rax, [rcx+8]
cmp rax, r9
jz short loc_13E8
nop dword ptr [rax+00000000h]
loc_13D0:
mov edx, [rax]
cmp edi, edx
cmovl edi, edx
mov edx, [rax+4]
cmp edi, edx
cmovl edi, edx
add rax, 8
cmp rax, r9
jnz short loc_13D0
loc_13E8:
test esi, esi
jle short loc_1424
movsxd rsi, esi
lea r9, [rcx+rsi*4]
xor esi, esi
jmp short loc_140B
loc_1400:
add rcx, 4
add esi, eax
cmp rcx, r9
jz short loc_141C
loc_140B:
mov eax, edi
sub eax, [rcx]
cdq
idiv r8d
test edx, edx
jz short loc_1400
mov esi, 0FFFFFFFFh
loc_141C:
mov eax, esi
retn
loc_1420:
mov edi, [rcx]
jmp short loc_13E8
loc_1424:
xor esi, esi
jmp short loc_141C | long long func0(int **a1, int a2, int a3)
{
int *v3; // r9
int *v4; // rcx
int *v5; // rax
int v6; // edi
int v7; // eax
int *v8; // r9
unsigned int v9; // esi
int v10; // eax
v3 = a1[1];
v4 = *a1;
if ( *a1 == v3 )
{
v6 = *v4;
}
else
{
v5 = v4 + 1;
v6 = *v4;
if ( v3 != v4 + 1 )
{
if ( (((_BYTE)v3 - (_BYTE)v5) & 4) == 0 )
goto LABEL_22;
v7 = *v5;
if ( v6 < v7 )
v6 = v7;
v5 = v4 + 2;
if ( v4 + 2 != v3 )
{
LABEL_22:
do
{
if ( v6 < *v5 )
v6 = *v5;
if ( v6 < v5[1] )
v6 = v5[1];
v5 += 2;
}
while ( v5 != v3 );
}
}
}
if ( a2 <= 0 )
{
return 0;
}
else
{
v8 = &v4[a2];
v9 = 0;
while ( 1 )
{
v10 = (v6 - *v4) / a3;
if ( (v6 - *v4) % a3 )
break;
++v4;
v9 += v10;
if ( v4 == v8 )
return v9;
}
return (unsigned int)-1;
}
} | func0:
ENDBR64
MOV R9,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV R8D,EDX
CMP RCX,R9
JZ 0x00101420
LEA RAX,[RCX + 0x4]
MOV EDI,dword ptr [RCX]
CMP R9,RAX
JZ 0x001013e8
MOV RDX,R9
SUB RDX,RAX
AND EDX,0x4
JZ 0x001013d0
MOV EAX,dword ptr [RAX]
CMP EDI,EAX
CMOVL EDI,EAX
LEA RAX,[RCX + 0x8]
CMP RAX,R9
JZ 0x001013e8
NOP dword ptr [RAX]
LAB_001013d0:
MOV EDX,dword ptr [RAX]
CMP EDI,EDX
CMOVL EDI,EDX
MOV EDX,dword ptr [RAX + 0x4]
CMP EDI,EDX
CMOVL EDI,EDX
ADD RAX,0x8
CMP RAX,R9
JNZ 0x001013d0
LAB_001013e8:
TEST ESI,ESI
JLE 0x00101424
MOVSXD RSI,ESI
LEA R9,[RCX + RSI*0x4]
XOR ESI,ESI
JMP 0x0010140b
LAB_00101400:
ADD RCX,0x4
ADD ESI,EAX
CMP RCX,R9
JZ 0x0010141c
LAB_0010140b:
MOV EAX,EDI
SUB EAX,dword ptr [RCX]
CDQ
IDIV R8D
TEST EDX,EDX
JZ 0x00101400
MOV ESI,0xffffffff
LAB_0010141c:
MOV EAX,ESI
RET
LAB_00101420:
MOV EDI,dword ptr [RCX]
JMP 0x001013e8
LAB_00101424:
XOR ESI,ESI
JMP 0x0010141c | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int iVar5;
int iVar6;
piVar2 = *(int **)(param_1 + 8);
piVar4 = *(int **)param_1;
if (piVar4 == piVar2) {
iVar6 = *piVar4;
}
else {
piVar3 = piVar4 + 1;
iVar6 = *piVar4;
if (piVar2 != piVar3) {
if (((int)piVar2 - (int)piVar3 & 4U) != 0) {
if (iVar6 < *piVar3) {
iVar6 = *piVar3;
}
piVar3 = piVar4 + 2;
if (piVar3 == piVar2) goto LAB_001013e8;
}
do {
if (iVar6 < *piVar3) {
iVar6 = *piVar3;
}
if (iVar6 < piVar3[1]) {
iVar6 = piVar3[1];
}
piVar3 = piVar3 + 2;
} while (piVar3 != piVar2);
}
}
LAB_001013e8:
if (param_2 < 1) {
iVar5 = 0;
}
else {
piVar2 = piVar4 + param_2;
iVar5 = 0;
do {
iVar1 = *piVar4;
if ((iVar6 - iVar1) % param_3 != 0) {
return -1;
}
piVar4 = piVar4 + 1;
iVar5 = iVar5 + (iVar6 - iVar1) / param_3;
} while (piVar4 != piVar2);
}
return iVar5;
} |
631 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(const std::vector<int>& arr, int n, int k) {
int max1 = *std::max_element(arr.begin(), arr.end());
int res = 0;
for (int i = 0; i < n; ++i) {
if ((max1 - arr[i]) % k != 0) {
return -1;
} else {
res += (max1 - arr[i]) / k;
}
}
return res;
}
| int main() {
assert(func0({2,2,2,2}, 4, 3) == 0);
assert(func0({4,2,6,8}, 4, 3) == -1);
assert(func0({21,33,9,45,63}, 5, 6) == 24);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
mov 0x8(%rdi),%r10
mov (%rdi),%rcx
mov %edx,%r9d
mov (%rcx),%edi
cmp %rcx,%r10
je 1520 <_Z5func0RKSt6vectorIiSaIiEEii+0x100>
lea 0x4(%rcx),%r8
cmp %r8,%r10
je 1520 <_Z5func0RKSt6vectorIiSaIiEEii+0x100>
lea -0x8(%r10),%rdx
mov %rcx,%rax
sub %rcx,%rdx
mov %rdx,%r11
shr $0x2,%r11
add $0x1,%r11
cmp $0x8,%rdx
jbe 14f4 <_Z5func0RKSt6vectorIiSaIiEEii+0xd4>
mov %r11,%rdx
movd %edi,%xmm3
shr $0x2,%rdx
pshufd $0x0,%xmm3,%xmm2
shl $0x4,%rdx
add %rcx,%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 %rdx,%rax
jne 1480 <_Z5func0RKSt6vectorIiSaIiEEii+0x60>
movdqa %xmm2,%xmm0
mov %r11,%rax
psrldq $0x8,%xmm0
and $0xfffffffffffffffc,%rax
movdqa %xmm0,%xmm1
lea (%r8,%rax,4),%r8
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,%edi
cmp %rax,%r11
je 1520 <_Z5func0RKSt6vectorIiSaIiEEii+0x100>
mov (%r8),%eax
cmp %eax,%edi
cmovl %eax,%edi
lea 0x4(%r8),%rax
cmp %rax,%r10
je 1520 <_Z5func0RKSt6vectorIiSaIiEEii+0x100>
mov 0x4(%r8),%eax
cmp %eax,%edi
cmovl %eax,%edi
lea 0x8(%r8),%rax
cmp %rax,%r10
je 1520 <_Z5func0RKSt6vectorIiSaIiEEii+0x100>
mov 0x8(%r8),%eax
cmp %eax,%edi
cmovl %eax,%edi
test %esi,%esi
jle 155a <_Z5func0RKSt6vectorIiSaIiEEii+0x13a>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rcx,%rax,4),%rsi
jmp 1544 <_Z5func0RKSt6vectorIiSaIiEEii+0x124>
nopl 0x0(%rax)
add $0x4,%rcx
add %eax,%r8d
cmp %rsi,%rcx
je 1556 <_Z5func0RKSt6vectorIiSaIiEEii+0x136>
mov %edi,%eax
sub (%rcx),%eax
cltd
idiv %r9d
test %edx,%edx
je 1538 <_Z5func0RKSt6vectorIiSaIiEEii+0x118>
mov $0xffffffff,%r8d
mov %r8d,%eax
retq
xor %r8d,%r8d
jmp 1556 <_Z5func0RKSt6vectorIiSaIiEEii+0x136>
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
mov r11, [rdi+8]
mov rcx, [rdi]
movsxd r9, esi
mov r8d, edx
cmp rcx, r11
jz loc_14C0
lea rdi, [rcx+4]
mov esi, [rcx]
cmp r11, rdi
jz loc_148B
lea rdx, [r11-8]
mov rax, rcx
sub rdx, rcx
mov r10, rdx
shr r10, 2
add r10, 1
cmp rdx, 8
jbe loc_1462
mov rdx, r10
movd xmm3, esi
shr rdx, 2
pshufd xmm2, xmm3, 0
shl rdx, 4
add rdx, rcx
nop
loc_13F0:
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_13F0
movdqa xmm1, xmm2
psrldq xmm1, 8
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 esi, xmm1
test r10b, 3
jz short loc_148B
and r10, 0FFFFFFFFFFFFFFFCh
lea rdi, [rdi+r10*4]
loc_1462:
mov eax, [rdi]
cmp esi, eax
cmovl esi, eax
lea rax, [rdi+4]
cmp r11, rax
jz short loc_148B
mov eax, [rdi+4]
cmp esi, eax
cmovl esi, eax
lea rax, [rdi+8]
cmp r11, rax
jz short loc_148B
mov eax, [rdi+8]
cmp esi, eax
cmovl esi, eax
loc_148B:
test r9d, r9d
jle short loc_14C4
lea r9, [rcx+r9*4]
xor edi, edi
jmp short loc_14AB
loc_14A0:
add rcx, 4
add edi, eax
cmp r9, rcx
jz short loc_14BC
loc_14AB:
mov eax, esi
sub eax, [rcx]
cdq
idiv r8d
test edx, edx
jz short loc_14A0
mov edi, 0FFFFFFFFh
loc_14BC:
mov eax, edi
retn
loc_14C0:
mov esi, [rcx]
jmp short loc_148B
loc_14C4:
xor edi, edi
jmp short loc_14BC | long long func0(signed int **a1, int a2, int a3)
{
signed int *v3; // r11
signed int *v4; // rcx
long long v5; // r9
signed int *v6; // rdi
signed int v7; // esi
signed int *v8; // rax
unsigned long long v9; // r10
__m128i v10; // xmm2
__m128i v11; // xmm0
__m128i v12; // xmm1
__m128i v13; // xmm1
__m128i v14; // xmm0
__m128i v15; // xmm0
__m128i v16; // xmm2
__m128i v17; // xmm1
signed int *v18; // r9
unsigned int v19; // edi
int v20; // eax
v3 = a1[1];
v4 = *a1;
v5 = a2;
if ( *a1 == v3 )
{
v7 = *v4;
goto LABEL_16;
}
v6 = v4 + 1;
v7 = *v4;
if ( v3 == v4 + 1 )
goto LABEL_16;
v8 = v4;
v9 = ((unsigned long long)((char *)(v3 - 2) - (char *)v4) >> 2) + 1;
if ( (unsigned long long)((char *)(v3 - 2) - (char *)v4) > 8 )
{
v10 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v7), 0);
do
{
v11 = _mm_loadu_si128((const __m128i *)(v8 + 1));
v8 += 4;
v12 = _mm_cmpgt_epi32(v11, v10);
v10 = _mm_or_si128(_mm_andnot_si128(v12, v10), _mm_and_si128(v11, v12));
}
while ( v8 != &v4[4 * (v9 >> 2)] );
v13 = _mm_srli_si128(v10, 8);
v14 = _mm_cmpgt_epi32(v13, v10);
v15 = _mm_or_si128(_mm_andnot_si128(v14, v10), _mm_and_si128(v13, v14));
v16 = _mm_srli_si128(v15, 4);
v17 = _mm_cmpgt_epi32(v16, v15);
v7 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v17, v15), _mm_and_si128(v16, v17)));
if ( (v9 & 3) == 0 )
goto LABEL_16;
v6 += v9 & 0xFFFFFFFFFFFFFFFCLL;
}
if ( v7 < *v6 )
v7 = *v6;
if ( v3 != v6 + 1 )
{
if ( v7 < v6[1] )
v7 = v6[1];
if ( v3 != v6 + 2 && v7 < v6[2] )
v7 = v6[2];
}
LABEL_16:
if ( (int)v5 <= 0 )
{
return 0;
}
else
{
v18 = &v4[v5];
v19 = 0;
while ( 1 )
{
v20 = (v7 - *v4) / a3;
if ( (v7 - *v4) % a3 )
break;
++v4;
v19 += v20;
if ( v18 == v4 )
return v19;
}
return (unsigned int)-1;
}
} | func0:
ENDBR64
MOV R11,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOVSXD R9,ESI
MOV R8D,EDX
CMP RCX,R11
JZ 0x001014c0
LEA RDI,[RCX + 0x4]
MOV ESI,dword ptr [RCX]
CMP R11,RDI
JZ 0x0010148b
LEA RDX,[R11 + -0x8]
MOV RAX,RCX
SUB RDX,RCX
MOV R10,RDX
SHR R10,0x2
ADD R10,0x1
CMP RDX,0x8
JBE 0x00101462
MOV RDX,R10
MOVD XMM3,ESI
SHR RDX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RDX,0x4
ADD RDX,RCX
NOP
LAB_001013f0:
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 RAX,RDX
JNZ 0x001013f0
MOVDQA XMM1,XMM2
PSRLDQ XMM1,0x8
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 ESI,XMM1
TEST R10B,0x3
JZ 0x0010148b
AND R10,-0x4
LEA RDI,[RDI + R10*0x4]
LAB_00101462:
MOV EAX,dword ptr [RDI]
CMP ESI,EAX
CMOVL ESI,EAX
LEA RAX,[RDI + 0x4]
CMP R11,RAX
JZ 0x0010148b
MOV EAX,dword ptr [RDI + 0x4]
CMP ESI,EAX
CMOVL ESI,EAX
LEA RAX,[RDI + 0x8]
CMP R11,RAX
JZ 0x0010148b
MOV EAX,dword ptr [RDI + 0x8]
CMP ESI,EAX
CMOVL ESI,EAX
LAB_0010148b:
TEST R9D,R9D
JLE 0x001014c4
LEA R9,[RCX + R9*0x4]
XOR EDI,EDI
JMP 0x001014ab
LAB_001014a0:
ADD RCX,0x4
ADD EDI,EAX
CMP R9,RCX
JZ 0x001014bc
LAB_001014ab:
MOV EAX,ESI
SUB EAX,dword ptr [RCX]
CDQ
IDIV R8D
TEST EDX,EDX
JZ 0x001014a0
MOV EDI,0xffffffff
LAB_001014bc:
MOV EAX,EDI
RET
LAB_001014c0:
MOV ESI,dword ptr [RCX]
JMP 0x0010148b
LAB_001014c4:
XOR EDI,EDI
JMP 0x001014bc | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
ulong uVar8;
uint uVar9;
int iVar10;
uint *puVar11;
ulong uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uint uVar18;
uint uVar19;
puVar2 = *(uint **)(param_1 + 8);
puVar7 = *(uint **)param_1;
if (puVar7 == puVar2) {
uVar9 = *puVar7;
}
else {
puVar11 = puVar7 + 1;
uVar9 = *puVar7;
if (puVar2 != puVar11) {
uVar8 = (long)puVar2 + (-8 - (long)puVar7);
uVar12 = (uVar8 >> 2) + 1;
if (8 < uVar8) {
puVar6 = puVar7;
uVar18 = uVar9;
uVar14 = uVar9;
uVar19 = uVar9;
do {
puVar1 = puVar6 + 1;
puVar3 = puVar6 + 2;
puVar4 = puVar6 + 3;
puVar5 = puVar6 + 4;
puVar6 = puVar6 + 4;
uVar13 = -(uint)((int)uVar9 < (int)*puVar1);
uVar15 = -(uint)((int)uVar18 < (int)*puVar3);
uVar16 = -(uint)((int)uVar14 < (int)*puVar4);
uVar17 = -(uint)((int)uVar19 < (int)*puVar5);
uVar9 = ~uVar13 & uVar9 | *puVar1 & uVar13;
uVar18 = ~uVar15 & uVar18 | *puVar3 & uVar15;
uVar14 = ~uVar16 & uVar14 | *puVar4 & uVar16;
uVar19 = ~uVar17 & uVar19 | *puVar5 & uVar17;
} while (puVar6 != puVar7 + (uVar12 & 0xfffffffffffffffc));
uVar9 = ~-(uint)((int)uVar9 < (int)uVar14) & uVar9 |
uVar14 & -(uint)((int)uVar9 < (int)uVar14);
uVar18 = ~-(uint)((int)uVar18 < (int)uVar19) & uVar18 |
uVar19 & -(uint)((int)uVar18 < (int)uVar19);
uVar14 = -(uint)((int)uVar9 < (int)uVar18);
uVar9 = ~uVar14 & uVar9 | uVar18 & uVar14;
if ((uVar12 & 3) == 0) goto LAB_0010148b;
puVar11 = puVar11 + (uVar12 & 0xfffffffffffffffc);
}
if ((int)uVar9 < (int)*puVar11) {
uVar9 = *puVar11;
}
if (puVar2 != puVar11 + 1) {
if ((int)uVar9 < (int)puVar11[1]) {
uVar9 = puVar11[1];
}
if ((puVar2 != puVar11 + 2) && ((int)uVar9 < (int)puVar11[2])) {
uVar9 = puVar11[2];
}
}
}
}
LAB_0010148b:
if (param_2 < 1) {
iVar10 = 0;
}
else {
puVar2 = puVar7 + param_2;
iVar10 = 0;
do {
uVar18 = *puVar7;
if ((int)(uVar9 - uVar18) % param_3 != 0) {
return -1;
}
puVar7 = puVar7 + 1;
iVar10 = iVar10 + (int)(uVar9 - uVar18) / param_3;
} while (puVar2 != puVar7);
}
return iVar10;
} |
632 | func0 |
#include <string>
#include <assert.h>
| std::string func0(std::string month, int days) {
std::string season;
if (month == "January" || month == "February" || month == "March") {
season = "winter";
} else if (month == "April" || month == "May" || month == "June") {
season = "spring";
} else if (month == "July" || month == "August" || month == "September") {
season = "summer";
} else {
season = "autumn";
}
if ((month == "March") && (days > 19)) {
season = "spring";
} else if ((month == "June") && (days > 20)) {
season = "summer";
} else if ((month == "September") && (days > 21)) {
season = "autumn";
} else if ((month == "October") && (days > 21)) {
season = "autumn";
} else if ((month == "November") && (days > 21)) {
season = "autumn";
} else if ((month == "December") && (days > 20)) {
season = "winter";
}
return season;
}
| int main() {
assert(func0("January", 4) == "winter");
assert(func0("October", 28) == "autumn");
assert(func0("June", 6) == "spring");
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %edx,-0x34(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 12b0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev@plt>
mov -0x30(%rbp),%rax
lea 0xbc1(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
jne 1481 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x78>
mov -0x30(%rbp),%rax
lea 0xbb2(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
jne 1481 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x78>
mov -0x30(%rbp),%rax
lea 0xba4(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
je 1488 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x7f>
mov $0x1,%eax
jmp 148d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x84>
mov $0x0,%eax
test %al,%al
je 14a9 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xa0>
mov -0x28(%rbp),%rax
lea 0xb83(%rip),%rsi
mov %rax,%rdi
callq 12a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc@plt>
jmpq 1590 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x187>
mov -0x30(%rbp),%rax
lea 0xb72(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
jne 14ee <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xe5>
mov -0x30(%rbp),%rax
lea 0xb61(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
jne 14ee <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xe5>
mov -0x30(%rbp),%rax
lea 0xb4e(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
je 14f5 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xec>
mov $0x1,%eax
jmp 14fa <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xf1>
mov $0x0,%eax
test %al,%al
je 1513 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x10a>
mov -0x28(%rbp),%rax
lea 0xb2c(%rip),%rsi
mov %rax,%rdi
callq 12a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc@plt>
jmp 1590 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x187>
mov -0x30(%rbp),%rax
lea 0xb1e(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
jne 1558 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x14f>
mov -0x30(%rbp),%rax
lea 0xb0c(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
jne 1558 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x14f>
mov -0x30(%rbp),%rax
lea 0xafc(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
je 155f <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x156>
mov $0x1,%eax
jmp 1564 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x15b>
mov $0x0,%eax
test %al,%al
je 157d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x174>
mov -0x28(%rbp),%rax
lea 0xadf(%rip),%rsi
mov %rax,%rdi
callq 12a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc@plt>
jmp 1590 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x187>
mov -0x28(%rbp),%rax
lea 0xad1(%rip),%rsi
mov %rax,%rdi
callq 12a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc@plt>
mov -0x30(%rbp),%rax
lea 0xa7e(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
je 15b4 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1ab>
cmpl $0x13,-0x34(%rbp)
jle 15b4 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1ab>
mov $0x1,%eax
jmp 15b9 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1b0>
mov $0x0,%eax
test %al,%al
je 15d5 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1cc>
mov -0x28(%rbp),%rax
lea 0xa6d(%rip),%rsi
mov %rax,%rdi
callq 12a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc@plt>
jmpq 1746 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x33d>
mov -0x30(%rbp),%rax
lea 0xa50(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
je 15f9 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1f0>
cmpl $0x14,-0x34(%rbp)
jle 15f9 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1f0>
mov $0x1,%eax
jmp 15fe <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1f5>
mov $0x0,%eax
test %al,%al
je 161a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x211>
mov -0x28(%rbp),%rax
lea 0xa45(%rip),%rsi
mov %rax,%rdi
callq 12a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc@plt>
jmpq 1746 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x33d>
mov -0x30(%rbp),%rax
lea 0xa23(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
je 163e <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x235>
cmpl $0x15,-0x34(%rbp)
jle 163e <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x235>
mov $0x1,%eax
jmp 1643 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x23a>
mov $0x0,%eax
test %al,%al
je 165f <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x256>
mov -0x28(%rbp),%rax
lea 0xa07(%rip),%rsi
mov %rax,%rdi
callq 12a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc@plt>
jmpq 1746 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x33d>
mov -0x30(%rbp),%rax
lea 0x9f6(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
je 1683 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x27a>
cmpl $0x15,-0x34(%rbp)
jle 1683 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x27a>
mov $0x1,%eax
jmp 1688 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x27f>
mov $0x0,%eax
test %al,%al
je 16a4 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x29b>
mov -0x28(%rbp),%rax
lea 0x9c2(%rip),%rsi
mov %rax,%rdi
callq 12a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc@plt>
jmpq 1746 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x33d>
mov -0x30(%rbp),%rax
lea 0x9b9(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
je 16c8 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x2bf>
cmpl $0x15,-0x34(%rbp)
jle 16c8 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x2bf>
mov $0x1,%eax
jmp 16cd <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x2c4>
mov $0x0,%eax
test %al,%al
je 16e6 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x2dd>
mov -0x28(%rbp),%rax
lea 0x97d(%rip),%rsi
mov %rax,%rdi
callq 12a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc@plt>
jmp 1746 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x33d>
mov -0x30(%rbp),%rax
lea 0x980(%rip),%rsi
mov %rax,%rdi
callq 1b09 <_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_>
test %al,%al
je 170a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x301>
cmpl $0x14,-0x34(%rbp)
jle 170a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x301>
mov $0x1,%eax
jmp 170f <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x306>
mov $0x0,%eax
test %al,%al
je 1746 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x33d>
mov -0x28(%rbp),%rax
lea 0x901(%rip),%rsi
mov %rax,%rdi
callq 12a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc@plt>
jmp 1746 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x33d>
endbr64
mov %rax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 11e0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
mov %rbx,%rax
mov %rax,%rdi
callq 12e0 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 175b <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x352>
callq 1280 <__stack_chk_fail@plt>
mov -0x28(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov rax, [rbp+var_18]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rax, [rbp+var_20]
lea rdx, aJanuary; "January"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_141B
mov rax, [rbp+var_20]
lea rdx, aFebruary; "February"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_141B
mov rax, [rbp+var_20]
lea rdx, aMarch; "March"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_1422
loc_141B:
mov eax, 1
jmp short loc_1427
loc_1422:
mov eax, 0
loc_1427:
test al, al
jz short loc_1446
mov rax, [rbp+var_18]
lea rdx, aWinter; "winter"
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp loc_154B
loc_1446:
mov rax, [rbp+var_20]
lea rdx, aApril; "April"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_1494
mov rax, [rbp+var_20]
lea rdx, aMay; "May"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_1494
mov rax, [rbp+var_20]
lea rdx, aJune; "June"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_149B
loc_1494:
mov eax, 1
jmp short loc_14A0
loc_149B:
mov eax, 0
loc_14A0:
test al, al
jz short loc_14BF
mov rax, [rbp+var_18]
lea rdx, aSpring; "spring"
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp loc_154B
loc_14BF:
mov rax, [rbp+var_20]
lea rdx, aJuly; "July"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_150D
mov rax, [rbp+var_20]
lea rdx, aAugust; "August"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_150D
mov rax, [rbp+var_20]
lea rdx, aSeptember; "September"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_1514
loc_150D:
mov eax, 1
jmp short loc_1519
loc_1514:
mov eax, 0
loc_1519:
test al, al
jz short loc_1535
mov rax, [rbp+var_18]
lea rdx, aSummer; "summer"
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp short loc_154B
loc_1535:
mov rax, [rbp+var_18]
lea rdx, aAutumn; "autumn"
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
loc_154B:
mov rax, [rbp+var_20]
lea rdx, aMarch; "March"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_1572
cmp [rbp+var_24], 13h
jle short loc_1572
mov eax, 1
jmp short loc_1577
loc_1572:
mov eax, 0
loc_1577:
test al, al
jz short loc_1596
mov rax, [rbp+var_18]
lea rdx, aSpring; "spring"
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp loc_1725
loc_1596:
mov rax, [rbp+var_20]
lea rdx, aJune; "June"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_15BD
cmp [rbp+var_24], 14h
jle short loc_15BD
mov eax, 1
jmp short loc_15C2
loc_15BD:
mov eax, 0
loc_15C2:
test al, al
jz short loc_15E1
mov rax, [rbp+var_18]
lea rdx, aSummer; "summer"
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp loc_1725
loc_15E1:
mov rax, [rbp+var_20]
lea rdx, aSeptember; "September"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_1608
cmp [rbp+var_24], 15h
jle short loc_1608
mov eax, 1
jmp short loc_160D
loc_1608:
mov eax, 0
loc_160D:
test al, al
jz short loc_162C
mov rax, [rbp+var_18]
lea rdx, aAutumn; "autumn"
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp loc_1725
loc_162C:
mov rax, [rbp+var_20]
lea rdx, aOctober; "October"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_1653
cmp [rbp+var_24], 15h
jle short loc_1653
mov eax, 1
jmp short loc_1658
loc_1653:
mov eax, 0
loc_1658:
test al, al
jz short loc_1677
mov rax, [rbp+var_18]
lea rdx, aAutumn; "autumn"
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp loc_1725
loc_1677:
mov rax, [rbp+var_20]
lea rdx, aNovember; "November"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_169E
cmp [rbp+var_24], 15h
jle short loc_169E
mov eax, 1
jmp short loc_16A3
loc_169E:
mov eax, 0
loc_16A3:
test al, al
jz short loc_16BF
mov rax, [rbp+var_18]
lea rdx, aAutumn; "autumn"
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp short loc_1725
loc_16BF:
mov rax, [rbp+var_20]
lea rdx, aDecember; "December"
mov rsi, rdx
mov rdi, rax
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_16E6
cmp [rbp+var_24], 14h
jle short loc_16E6
mov eax, 1
jmp short loc_16EB
loc_16E6:
mov eax, 0
loc_16EB:
test al, al
jz short loc_1725
mov rax, [rbp+var_18]
lea rdx, aWinter; "winter"
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp short loc_1725
endbr64
mov rbx, rax
mov rax, [rbp+var_18]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, rbx
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1725:
nop
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, int a3)
{
bool v8; // al
char v9; // al
char v10; // al
std::string::basic_string(a1);
if ( (unsigned __int8)std::operator==<char>(a2, "January")
|| (unsigned __int8)std::operator==<char>(a2, "February")
|| (unsigned __int8)std::operator==<char>(a2, "March") )
{
std::string::operator=(a1, "winter");
}
else if ( (unsigned __int8)std::operator==<char>(a2, "April")
|| (unsigned __int8)std::operator==<char>(a2, "May")
|| (unsigned __int8)std::operator==<char>(a2, "June") )
{
std::string::operator=(a1, "spring");
}
else if ( (unsigned __int8)std::operator==<char>(a2, "July")
|| (unsigned __int8)std::operator==<char>(a2, "August")
|| (unsigned __int8)std::operator==<char>(a2, "September") )
{
std::string::operator=(a1, "summer");
}
else
{
std::string::operator=(a1, "autumn");
}
if ( (unsigned __int8)std::operator==<char>(a2, "March") && a3 > 19 )
{
std::string::operator=(a1, "spring");
}
else if ( (unsigned __int8)std::operator==<char>(a2, "June") && a3 > 20 )
{
std::string::operator=(a1, "summer");
}
else
{
v8 = (unsigned __int8)std::operator==<char>(a2, "September") && a3 > 21;
if ( v8
|| (!(unsigned __int8)std::operator==<char>(a2, "October") || a3 <= 21 ? (v9 = 0) : (v9 = 1),
v9 || (!(unsigned __int8)std::operator==<char>(a2, "November") || a3 <= 21 ? (v10 = 0) : (v10 = 1), v10)) )
{
std::string::operator=(a1, "autumn");
}
else if ( (unsigned __int8)std::operator==<char>(a2, "December") && a3 > 20 )
{
std::string::operator=(a1, "winter");
}
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101280
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102008]
MOV RSI,RDX
MOV RDI,RAX
LAB_001013de:
CALL 0x00101c3a
TEST AL,AL
JNZ 0x0010141b
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102010]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JNZ 0x0010141b
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102019]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JZ 0x00101422
LAB_0010141b:
MOV EAX,0x1
JMP 0x00101427
LAB_00101422:
MOV EAX,0x0
LAB_00101427:
TEST AL,AL
JZ 0x00101446
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x10201f]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101270
JMP 0x0010154b
LAB_00101446:
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102026]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JNZ 0x00101494
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x10202c]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JNZ 0x00101494
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102030]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JZ 0x0010149b
LAB_00101494:
MOV EAX,0x1
JMP 0x001014a0
LAB_0010149b:
MOV EAX,0x0
LAB_001014a0:
TEST AL,AL
JZ 0x001014bf
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102035]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101270
JMP 0x0010154b
LAB_001014bf:
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x10203c]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JNZ 0x0010150d
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102041]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JNZ 0x0010150d
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102048]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JZ 0x00101514
LAB_0010150d:
MOV EAX,0x1
JMP 0x00101519
LAB_00101514:
MOV EAX,0x0
LAB_00101519:
TEST AL,AL
JZ 0x00101535
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102052]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101270
JMP 0x0010154b
LAB_00101535:
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102059]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101270
LAB_0010154b:
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102019]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JZ 0x00101572
CMP dword ptr [RBP + -0x24],0x13
JLE 0x00101572
MOV EAX,0x1
JMP 0x00101577
LAB_00101572:
MOV EAX,0x0
LAB_00101577:
TEST AL,AL
JZ 0x00101596
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102035]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101270
JMP 0x00101725
LAB_00101596:
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102030]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JZ 0x001015bd
CMP dword ptr [RBP + -0x24],0x14
JLE 0x001015bd
MOV EAX,0x1
JMP 0x001015c2
LAB_001015bd:
MOV EAX,0x0
LAB_001015c2:
TEST AL,AL
JZ 0x001015e1
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102052]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101270
JMP 0x00101725
LAB_001015e1:
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102048]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JZ 0x00101608
CMP dword ptr [RBP + -0x24],0x15
JLE 0x00101608
MOV EAX,0x1
JMP 0x0010160d
LAB_00101608:
MOV EAX,0x0
LAB_0010160d:
TEST AL,AL
JZ 0x0010162c
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102059]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101270
JMP 0x00101725
LAB_0010162c:
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102060]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JZ 0x00101653
CMP dword ptr [RBP + -0x24],0x15
JLE 0x00101653
MOV EAX,0x1
JMP 0x00101658
LAB_00101653:
MOV EAX,0x0
LAB_00101658:
TEST AL,AL
JZ 0x00101677
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102059]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101270
JMP 0x00101725
LAB_00101677:
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102068]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JZ 0x0010169e
CMP dword ptr [RBP + -0x24],0x15
JLE 0x0010169e
MOV EAX,0x1
JMP 0x001016a3
LAB_0010169e:
MOV EAX,0x0
LAB_001016a3:
TEST AL,AL
JZ 0x001016bf
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x102059]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101270
JMP 0x00101725
LAB_001016bf:
MOV RAX,qword ptr [RBP + -0x20]
LEA RDX,[0x102071]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101c3a
TEST AL,AL
JZ 0x001016e6
CMP dword ptr [RBP + -0x24],0x14
JLE 0x001016e6
MOV EAX,0x1
JMP 0x001016eb
LAB_001016e6:
MOV EAX,0x0
LAB_001016eb:
TEST AL,AL
JZ 0x00101725
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[0x10201f]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101270
JMP 0x00101725
LAB_00101725:
NOP
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::string, int) */
string * func0(string *param_1,string *param_2,int param_3)
{
bool bVar1;
std::string::string(param_1);
/* try { // try from 001013de to 00101704 has its CatchHandler @ 00101707 */
bVar1 = std::operator==(param_2,"January");
if (bVar1) {
LAB_0010141b:
bVar1 = true;
}
else {
bVar1 = std::operator==(param_2,"February");
if (bVar1) goto LAB_0010141b;
bVar1 = std::operator==(param_2,"March");
if (bVar1) goto LAB_0010141b;
bVar1 = false;
}
if (bVar1) {
std::string::operator=(param_1,"winter");
goto LAB_0010154b;
}
bVar1 = std::operator==(param_2,"April");
if (bVar1) {
LAB_00101494:
bVar1 = true;
}
else {
bVar1 = std::operator==(param_2,"May");
if (bVar1) goto LAB_00101494;
bVar1 = std::operator==(param_2,"June");
if (bVar1) goto LAB_00101494;
bVar1 = false;
}
if (bVar1) {
std::string::operator=(param_1,"spring");
goto LAB_0010154b;
}
bVar1 = std::operator==(param_2,"July");
if (bVar1) {
LAB_0010150d:
bVar1 = true;
}
else {
bVar1 = std::operator==(param_2,"August");
if (bVar1) goto LAB_0010150d;
bVar1 = std::operator==(param_2,"September");
if (bVar1) goto LAB_0010150d;
bVar1 = false;
}
if (bVar1) {
std::string::operator=(param_1,"summer");
}
else {
std::string::operator=(param_1,"autumn");
}
LAB_0010154b:
bVar1 = std::operator==(param_2,"March");
if ((bVar1) && (0x13 < param_3)) {
bVar1 = true;
}
else {
bVar1 = false;
}
if (bVar1) {
std::string::operator=(param_1,"spring");
}
else {
bVar1 = std::operator==(param_2,"June");
if ((bVar1) && (0x14 < param_3)) {
bVar1 = true;
}
else {
bVar1 = false;
}
if (bVar1) {
std::string::operator=(param_1,"summer");
}
else {
bVar1 = std::operator==(param_2,"September");
if ((bVar1) && (0x15 < param_3)) {
bVar1 = true;
}
else {
bVar1 = false;
}
if (bVar1) {
std::string::operator=(param_1,"autumn");
}
else {
bVar1 = std::operator==(param_2,"October");
if ((bVar1) && (0x15 < param_3)) {
bVar1 = true;
}
else {
bVar1 = false;
}
if (bVar1) {
std::string::operator=(param_1,"autumn");
}
else {
bVar1 = std::operator==(param_2,"November");
if ((bVar1) && (0x15 < param_3)) {
bVar1 = true;
}
else {
bVar1 = false;
}
if (bVar1) {
std::string::operator=(param_1,"autumn");
}
else {
bVar1 = std::operator==(param_2,"December");
if ((bVar1) && (0x14 < param_3)) {
bVar1 = true;
}
else {
bVar1 = false;
}
if (bVar1) {
std::string::operator=(param_1,"winter");
}
}
}
}
}
}
return param_1;
} |
633 | func0 |
#include <string>
#include <assert.h>
| std::string func0(std::string month, int days) {
std::string season;
if (month == "January" || month == "February" || month == "March") {
season = "winter";
} else if (month == "April" || month == "May" || month == "June") {
season = "spring";
} else if (month == "July" || month == "August" || month == "September") {
season = "summer";
} else {
season = "autumn";
}
if ((month == "March") && (days > 19)) {
season = "spring";
} else if ((month == "June") && (days > 20)) {
season = "summer";
} else if ((month == "September") && (days > 21)) {
season = "autumn";
} else if ((month == "October") && (days > 21)) {
season = "autumn";
} else if ((month == "November") && (days > 21)) {
season = "autumn";
} else if ((month == "December") && (days > 20)) {
season = "winter";
}
return season;
}
| int main() {
assert(func0("January", 4) == "winter");
assert(func0("October", 28) == "autumn");
assert(func0("June", 6) == "spring");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %rsi,%rbp
mov %edx,%r12d
lea 0x10(%rdi),%r13
mov %r13,(%rdi)
movq $0x0,0x8(%rdi)
movb $0x0,0x10(%rdi)
lea 0xd6c(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 12b7 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x4e>
lea 0xd61(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 12da <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x71>
mov 0x8(%rbx),%rdx
mov $0x6,%r8d
lea 0xd53(%rip),%rcx
mov $0x0,%esi
mov %rbx,%rdi
callq 1140 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmpq 13ae <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x145>
lea 0xd34(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 12b7 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x4e>
lea 0xd2e(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1313 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xaa>
lea 0xd21(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1333 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xca>
mov 0x8(%rbx),%rdx
mov $0x6,%r8d
lea 0xd12(%rip),%rcx
mov $0x0,%esi
mov %rbx,%rdi
callq 1140 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmp 13ae <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x145>
lea 0xcf2(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1313 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xaa>
lea 0xce4(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 136c <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x103>
lea 0xcdd(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 138c <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x123>
mov 0x8(%rbx),%rdx
mov $0x6,%r8d
lea 0xcd8(%rip),%rcx
mov $0x0,%esi
mov %rbx,%rdi
callq 1140 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmp 13ae <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x145>
lea 0xcb1(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 136c <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x103>
lea 0xca8(%rip),%rsi
mov %rbx,%rdi
callq 1170 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc@plt>
lea 0xc60(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
cmp $0x13,%r12d
jle 13cb <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x162>
test %eax,%eax
je 1473 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x20a>
lea 0xc5a(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
cmp $0x14,%r12d
setg %r14b
test %eax,%eax
jne 13ef <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x186>
test %r14b,%r14b
jne 1493 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x22a>
lea 0xc4e(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
cmp $0x15,%r12d
setg %r12b
test %eax,%eax
jne 1413 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1aa>
test %r12b,%r12b
jne 14b3 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x24a>
lea 0xc42(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 142f <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1c6>
test %r12b,%r12b
jne 14d3 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x26a>
lea 0xc2e(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 144b <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1e2>
test %r12b,%r12b
jne 14f6 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x28d>
lea 0xc1b(%rip),%rsi
mov %rbp,%rdi
callq 10e0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1467 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1fe>
test %r14b,%r14b
jne 1519 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x2b0>
mov %rbx,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov 0x8(%rbx),%rdx
mov $0x6,%r8d
lea 0xbb2(%rip),%rcx
mov $0x0,%esi
mov %rbx,%rdi
callq 1140 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmp 1467 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1fe>
mov 0x8(%rbx),%rdx
mov $0x6,%r8d
lea 0xbb1(%rip),%rcx
mov $0x0,%esi
mov %rbx,%rdi
callq 1140 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmp 1467 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1fe>
mov 0x8(%rbx),%rdx
mov $0x6,%r8d
lea 0xb8a(%rip),%rcx
mov $0x0,%esi
mov %rbx,%rdi
callq 1140 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmp 1467 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1fe>
mov 0x8(%rbx),%rdx
mov $0x6,%r8d
lea 0xb6a(%rip),%rcx
mov $0x0,%esi
mov %rbx,%rdi
callq 1140 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmpq 1467 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1fe>
mov 0x8(%rbx),%rdx
mov $0x6,%r8d
lea 0xb47(%rip),%rcx
mov $0x0,%esi
mov %rbx,%rdi
callq 1140 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmpq 1467 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1fe>
mov 0x8(%rbx),%rdx
mov $0x6,%r8d
lea 0xaf1(%rip),%rcx
mov $0x0,%esi
mov %rbx,%rdi
callq 1140 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmpq 1467 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1fe>
endbr64
mov %rax,%rbp
mov (%rbx),%rdi
cmp %rdi,%r13
je 1550 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x2e7>
callq 1120 <_ZdlPv@plt>
mov %rbp,%rdi
callq 1150 <_Unwind_Resume@plt>
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
mov rbp, rsi
mov r12d, edx
lea rax, [rdi+10h]
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rax, [rsi+8]
cmp rax, 7
jz short loc_12EB
cmp rax, 8
jz loc_1327
cmp rax, 5
jz loc_1363
cmp rax, 3
jz loc_13BA
cmp rax, 4
jz loc_13D7
cmp rax, 6
jnz loc_142F
mov rdi, [rsi]; s1
mov edx, 6; n
lea rsi, aAugust; "August"
call _memcmp
test eax, eax
jz loc_140E
jmp short loc_133F
loc_12EB:
mov rdi, [rsi]; s1
mov edx, 7; n
lea rsi, aJanuary; "January"
call _memcmp
test eax, eax
jnz short loc_133F
loc_1303:
mov r8d, 6
lea rcx, aWinter; "winter"
mov edx, 0
mov esi, 0
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_1456
loc_1327:
mov rdi, [rsi]; s1
mov edx, 8; n
lea rsi, aFebruary; "February"
call _memcmp
test eax, eax
jz short loc_1303
loc_133F:
mov r8d, 6
lea rcx, aAutumn; "autumn"
mov edx, 0
mov esi, 0
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_1456
loc_1363:
mov r13, [rsi]
mov edx, 5; n
lea rsi, aMarch; "March"
mov rdi, r13; s1
call _memcmp
test eax, eax
jz short loc_1303
mov edx, 5; n
lea rsi, aApril; "April"
mov rdi, r13; s1
call _memcmp
test eax, eax
jnz short loc_133F
loc_1396:
mov r8d, 6
lea rcx, aSpring; "spring"
mov edx, 0
mov esi, 0
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_1456
loc_13BA:
mov rdi, [rsi]; s1
mov edx, 3; n
lea rsi, aMay; "May"
call _memcmp
test eax, eax
jz short loc_1396
jmp loc_133F
loc_13D7:
mov r13, [rsi]
mov edx, 4; n
lea rsi, aJune; "June"
mov rdi, r13; s1
call _memcmp
test eax, eax
jz short loc_1396
mov edx, 4; n
lea rsi, aJuly; "July"
mov rdi, r13; s1
call _memcmp
test eax, eax
jnz loc_133F
loc_140E:
mov r8d, 6
lea rcx, aSummer; "summer"
mov edx, 0
mov esi, 0
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp short loc_1456
loc_142F:
cmp rax, 9
jnz loc_133F
mov rdi, [rsi]; s1
mov edx, 9; n
lea rsi, aSeptember; "September"
call _memcmp
test eax, eax
jz short loc_140E
jmp loc_133F
loc_1456:
mov r13, [rbp+8]
cmp r13, 5
jz loc_14E8
cmp r13, 4
jz loc_1532
loc_146E:
cmp r13, 9
jz loc_1583
cmp r12d, 14h
setnle r14b
loc_1480:
cmp r12d, 15h
setnle r12b
cmp r13, 7
jz loc_15CD
cmp r13, 8
jnz loc_165F
mov rbp, [rbp+0]
mov edx, 8; n
lea rsi, aNovember; "November"
mov rdi, rbp; s1
call _memcmp
test eax, eax
jnz loc_160B
test r12b, r12b
jz loc_160B
mov rdx, [rbx+8]
mov r8d, 6
lea rcx, aAutumn; "autumn"
mov esi, 0
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_165F
loc_14E8:
mov rdi, [rbp+0]; s1
mov edx, 5; n
lea rsi, aMarch; "March"
call _memcmp
cmp r12d, 13h
jle loc_146E
test eax, eax
jnz loc_146E
mov rdx, [rbx+8]
mov r8d, 6
lea rcx, aSpring; "spring"
mov esi, 0
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_165F
loc_1532:
mov rdi, [rbp+0]; s1
mov edx, 4; n
lea rsi, aJune; "June"
call _memcmp
cmp r12d, 14h
setnle r14b
test eax, eax
jnz loc_1480
test r14b, r14b
jz loc_1480
mov rdx, [rbx+8]
mov r8d, 6
lea rcx, aSummer; "summer"
mov esi, 0
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_165F
loc_1583:
mov rdi, [rbp+0]; s1
mov edx, 9; n
lea rsi, aSeptember; "September"
call _memcmp
test eax, eax
jnz loc_165F
cmp r12d, 15h
jle loc_165F
mov rdx, [rbx+8]
mov r8d, 6
lea rcx, aAutumn; "autumn"
mov esi, 0
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_165F
loc_15CD:
mov rdi, [rbp+0]; s1
mov edx, 7; n
lea rsi, aOctober; "October"
call _memcmp
test eax, eax
jnz short loc_165F
test r12b, r12b
jz short loc_165F
mov rdx, [rbx+8]
mov r8d, 6
lea rcx, aAutumn; "autumn"
mov esi, 0
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp short loc_165F
loc_160B:
mov edx, 8; n
lea rsi, aDecember; "December"
mov rdi, rbp; s1
call _memcmp
test eax, eax
jnz short loc_165F
test r14b, r14b
jz short loc_165F
mov rdx, [rbx+8]
mov r8d, 6
lea rcx, aWinter; "winter"
mov esi, 0
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp short loc_165F
endbr64
mov rbp, rax
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rdi, rbp; struct _Unwind_Exception *
call __Unwind_Resume
loc_165F:
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn | long long func0(long long a1, long long a2, int a3)
{
long long v4; // rax
const void *v5; // r13
const void *v6; // r13
long long v7; // r13
bool v8; // r14
bool v9; // r12
const void *v10; // rbp
int v11; // eax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = *(_QWORD *)(a2 + 8);
switch ( v4 )
{
case 7LL:
if ( memcmp(*(const void **)a2, "January", 7uLL) )
goto LABEL_12;
goto LABEL_10;
case 8LL:
if ( memcmp(*(const void **)a2, "February", 8uLL) )
goto LABEL_12;
goto LABEL_10;
case 5LL:
v5 = *(const void **)a2;
if ( memcmp(*(const void **)a2, "March", 5uLL) )
{
if ( !memcmp(v5, "April", 5uLL) )
goto LABEL_15;
LABEL_12:
std::string::_M_replace(a1, 0LL, 0LL, "autumn", 6LL);
goto LABEL_24;
}
LABEL_10:
std::string::_M_replace(a1, 0LL, 0LL, "winter", 6LL);
goto LABEL_24;
case 3LL:
if ( memcmp(*(const void **)a2, "May", 3uLL) )
goto LABEL_12;
goto LABEL_15;
}
if ( v4 != 4 )
{
if ( v4 == 6 )
{
if ( memcmp(*(const void **)a2, "August", 6uLL) )
goto LABEL_12;
}
else if ( v4 != 9 || memcmp(*(const void **)a2, "September", 9uLL) )
{
goto LABEL_12;
}
goto LABEL_20;
}
v6 = *(const void **)a2;
if ( !memcmp(*(const void **)a2, "June", 4uLL) )
{
LABEL_15:
std::string::_M_replace(a1, 0LL, 0LL, "spring", 6LL);
goto LABEL_24;
}
if ( memcmp(v6, "July", 4uLL) )
goto LABEL_12;
LABEL_20:
std::string::_M_replace(a1, 0LL, 0LL, "summer", 6LL);
LABEL_24:
v7 = *(_QWORD *)(a2 + 8);
switch ( v7 )
{
case 5LL:
v11 = memcmp(*(const void **)a2, "March", 5uLL);
if ( a3 > 19 && !v11 )
{
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "spring", 6LL);
return a1;
}
break;
case 4LL:
v8 = a3 > 20;
if ( !memcmp(*(const void **)a2, "June", 4uLL) && a3 > 20 )
{
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "summer", 6LL);
return a1;
}
goto LABEL_28;
case 9LL:
if ( !memcmp(*(const void **)a2, "September", 9uLL) && a3 > 21 )
goto LABEL_44;
return a1;
}
v8 = a3 > 20;
LABEL_28:
v9 = a3 > 21;
if ( v7 == 7 )
{
if ( !memcmp(*(const void **)a2, "October", 7uLL) && v9 )
goto LABEL_44;
}
else if ( v7 == 8 )
{
v10 = *(const void **)a2;
if ( !memcmp(*(const void **)a2, "November", 8uLL) && v9 )
{
LABEL_44:
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "autumn", 6LL);
return a1;
}
if ( !memcmp(v10, "December", 8uLL) && v8 )
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "winter", 6LL);
}
return a1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV RBP,RSI
MOV R12D,EDX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI + 0x8]
CMP RAX,0x7
JZ 0x001012eb
CMP RAX,0x8
JZ 0x00101327
CMP RAX,0x5
JZ 0x00101363
CMP RAX,0x3
JZ 0x001013ba
CMP RAX,0x4
JZ 0x001013d7
CMP RAX,0x6
JNZ 0x0010142f
MOV RDI,qword ptr [RSI]
MOV EDX,0x6
LEA RSI,[0x10203d]
CALL 0x001010f0
TEST EAX,EAX
JZ 0x0010140e
JMP 0x0010133f
LAB_001012eb:
MOV RDI,qword ptr [RSI]
MOV EDX,0x7
LEA RSI,[0x102004]
CALL 0x001010f0
TEST EAX,EAX
JNZ 0x0010133f
LAB_00101303:
MOV R8D,0x6
LEA RCX,[0x10201b]
MOV EDX,0x0
MOV ESI,0x0
MOV RDI,RBX
LAB_0010131d:
CALL 0x00101150
JMP 0x00101456
LAB_00101327:
MOV RDI,qword ptr [RSI]
MOV EDX,0x8
LEA RSI,[0x10200c]
CALL 0x001010f0
TEST EAX,EAX
JZ 0x00101303
LAB_0010133f:
MOV R8D,0x6
LEA RCX,[0x10204e]
MOV EDX,0x0
MOV ESI,0x0
MOV RDI,RBX
CALL 0x00101150
JMP 0x00101456
LAB_00101363:
MOV R13,qword ptr [RSI]
MOV EDX,0x5
LEA RSI,[0x102015]
MOV RDI,R13
CALL 0x001010f0
TEST EAX,EAX
JZ 0x00101303
MOV EDX,0x5
LEA RSI,[0x102022]
MOV RDI,R13
CALL 0x001010f0
TEST EAX,EAX
JNZ 0x0010133f
LAB_00101396:
MOV R8D,0x6
LEA RCX,[0x102036]
MOV EDX,0x0
MOV ESI,0x0
MOV RDI,RBX
CALL 0x00101150
JMP 0x00101456
LAB_001013ba:
MOV RDI,qword ptr [RSI]
MOV EDX,0x3
LEA RSI,[0x102028]
CALL 0x001010f0
TEST EAX,EAX
JZ 0x00101396
JMP 0x0010133f
LAB_001013d7:
MOV R13,qword ptr [RSI]
MOV EDX,0x4
LEA RSI,[0x10202c]
MOV RDI,R13
CALL 0x001010f0
TEST EAX,EAX
JZ 0x00101396
MOV EDX,0x4
LEA RSI,[0x102031]
MOV RDI,R13
CALL 0x001010f0
TEST EAX,EAX
JNZ 0x0010133f
LAB_0010140e:
MOV R8D,0x6
LEA RCX,[0x102055]
MOV EDX,0x0
MOV ESI,0x0
MOV RDI,RBX
CALL 0x00101150
JMP 0x00101456
LAB_0010142f:
CMP RAX,0x9
JNZ 0x0010133f
MOV RDI,qword ptr [RSI]
MOV EDX,0x9
LEA RSI,[0x102044]
CALL 0x001010f0
TEST EAX,EAX
JZ 0x0010140e
JMP 0x0010133f
LAB_00101456:
MOV R13,qword ptr [RBP + 0x8]
CMP R13,0x5
JZ 0x001014e8
CMP R13,0x4
JZ 0x00101532
LAB_0010146e:
CMP R13,0x9
JZ 0x00101583
CMP R12D,0x14
SETG R14B
LAB_00101480:
CMP R12D,0x15
SETG R12B
CMP R13,0x7
JZ 0x001015cd
CMP R13,0x8
JNZ 0x0010165f
MOV RBP,qword ptr [RBP]
MOV EDX,0x8
LEA RSI,[0x102064]
MOV RDI,RBP
CALL 0x001010f0
TEST EAX,EAX
JNZ 0x0010160b
TEST R12B,R12B
JZ 0x0010160b
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
LEA RCX,[0x10204e]
MOV ESI,0x0
MOV RDI,RBX
CALL 0x00101150
JMP 0x0010165f
LAB_001014e8:
MOV RDI,qword ptr [RBP]
MOV EDX,0x5
LEA RSI,[0x102015]
CALL 0x001010f0
CMP R12D,0x13
JLE 0x0010146e
TEST EAX,EAX
JNZ 0x0010146e
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
LEA RCX,[0x102036]
MOV ESI,0x0
MOV RDI,RBX
CALL 0x00101150
JMP 0x0010165f
LAB_00101532:
MOV RDI,qword ptr [RBP]
MOV EDX,0x4
LEA RSI,[0x10202c]
CALL 0x001010f0
CMP R12D,0x14
SETG R14B
TEST EAX,EAX
JNZ 0x00101480
TEST R14B,R14B
JZ 0x00101480
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
LEA RCX,[0x102055]
MOV ESI,0x0
MOV RDI,RBX
CALL 0x00101150
JMP 0x0010165f
LAB_00101583:
MOV RDI,qword ptr [RBP]
MOV EDX,0x9
LEA RSI,[0x102044]
CALL 0x001010f0
TEST EAX,EAX
JNZ 0x0010165f
CMP R12D,0x15
JLE 0x0010165f
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
LEA RCX,[0x10204e]
MOV ESI,0x0
MOV RDI,RBX
CALL 0x00101150
JMP 0x0010165f
LAB_001015cd:
MOV RDI,qword ptr [RBP]
MOV EDX,0x7
LEA RSI,[0x10205c]
CALL 0x001010f0
TEST EAX,EAX
JNZ 0x0010165f
TEST R12B,R12B
JZ 0x0010165f
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
LEA RCX,[0x10204e]
MOV ESI,0x0
MOV RDI,RBX
CALL 0x00101150
JMP 0x0010165f
LAB_0010160b:
MOV EDX,0x8
LEA RSI,[0x10206d]
MOV RDI,RBP
CALL 0x001010f0
TEST EAX,EAX
JNZ 0x0010165f
TEST R14B,R14B
JZ 0x0010165f
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
LEA RCX,[0x10201b]
MOV ESI,0x0
MOV RDI,RBX
CALL 0x00101150
JMP 0x0010165f
LAB_0010165f:
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET | /* func0(std::string, int) */
long * func0(long *param_1,int8 *param_2,int param_3)
{
long lVar1;
void *pvVar2;
int iVar3;
*param_1 = (long)(param_1 + 2);
param_1[1] = 0;
*(int *)(param_1 + 2) = 0;
lVar1 = param_2[1];
if (lVar1 == 7) {
iVar3 = memcmp((void *)*param_2,"January",7);
if (iVar3 != 0) goto LAB_0010133f;
LAB_00101303:
/* try { // try from 0010131d to 00101645 has its CatchHandler @ 00101648 */
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x10201b);
}
else if (lVar1 == 8) {
iVar3 = memcmp((void *)*param_2,"February",8);
if (iVar3 == 0) goto LAB_00101303;
LAB_0010133f:
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x10204e);
}
else {
if (lVar1 == 5) {
pvVar2 = (void *)*param_2;
iVar3 = memcmp(pvVar2,"March",5);
if (iVar3 == 0) goto LAB_00101303;
iVar3 = memcmp(pvVar2,"April",5);
joined_r0x00101394:
if (iVar3 != 0) goto LAB_0010133f;
}
else {
if (lVar1 == 3) {
iVar3 = memcmp((void *)*param_2,&DAT_00102028,3);
goto joined_r0x00101394;
}
if (lVar1 != 4) {
if (lVar1 == 6) {
iVar3 = memcmp((void *)*param_2,"August",6);
}
else {
if (lVar1 != 9) goto LAB_0010133f;
iVar3 = memcmp((void *)*param_2,"September",9);
}
joined_r0x0010144f:
if (iVar3 == 0) {
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x102055);
goto LAB_00101456;
}
goto LAB_0010133f;
}
pvVar2 = (void *)*param_2;
iVar3 = memcmp(pvVar2,&DAT_0010202c,4);
if (iVar3 != 0) {
iVar3 = memcmp(pvVar2,&DAT_00102031,4);
goto joined_r0x0010144f;
}
}
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x102036);
}
LAB_00101456:
lVar1 = param_2[1];
if (lVar1 == 5) {
iVar3 = memcmp((void *)*param_2,"March",5);
if ((0x13 < param_3) && (iVar3 == 0)) {
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x102036);
return param_1;
}
}
else if (lVar1 == 4) {
iVar3 = memcmp((void *)*param_2,&DAT_0010202c,4);
if ((iVar3 == 0) && (0x14 < param_3)) {
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x102055);
return param_1;
}
goto LAB_00101480;
}
if (lVar1 == 9) {
iVar3 = memcmp((void *)*param_2,"September",9);
if (iVar3 != 0) {
return param_1;
}
if (param_3 < 0x16) {
return param_1;
}
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x10204e);
return param_1;
}
LAB_00101480:
if (lVar1 == 7) {
iVar3 = memcmp((void *)*param_2,"October",7);
if ((iVar3 == 0) && (0x15 < param_3)) {
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x10204e);
}
}
else if (lVar1 == 8) {
pvVar2 = (void *)*param_2;
iVar3 = memcmp(pvVar2,"November",8);
if ((iVar3 == 0) && (0x15 < param_3)) {
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x10204e);
}
else {
iVar3 = memcmp(pvVar2,"December",8);
if ((iVar3 == 0) && (0x14 < param_3)) {
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x10201b);
}
}
}
return param_1;
} |
634 | func0 |
#include <string>
#include <assert.h>
| std::string func0(std::string month, int days) {
std::string season;
if (month == "January" || month == "February" || month == "March") {
season = "winter";
} else if (month == "April" || month == "May" || month == "June") {
season = "spring";
} else if (month == "July" || month == "August" || month == "September") {
season = "summer";
} else {
season = "autumn";
}
if ((month == "March") && (days > 19)) {
season = "spring";
} else if ((month == "June") && (days > 20)) {
season = "summer";
} else if ((month == "September") && (days > 21)) {
season = "autumn";
} else if ((month == "October") && (days > 21)) {
season = "autumn";
} else if ((month == "November") && (days > 21)) {
season = "autumn";
} else if ((month == "December") && (days > 20)) {
season = "winter";
}
return season;
}
| int main() {
assert(func0("January", 4) == "winter");
assert(func0("October", 28) == "autumn");
assert(func0("June", 6) == "spring");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r14
push %r13
lea 0x10(%rdi),%r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
lea 0xb38(%rip),%rsi
push %rbx
mov %edx,%ebx
mov %r13,(%rdi)
movq $0x0,0x8(%rdi)
movb $0x0,0x10(%rdi)
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1501 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x51>
lea 0xb22(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1680 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1d0>
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0xaf4(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
lea 0xaf8(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
cmp $0x13,%ebx
jle 1539 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x89>
test %eax,%eax
je 15d0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x120>
lea 0xaec(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
cmp $0x14,%ebx
setg %r14b
test %eax,%eax
jne 155c <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xac>
test %r14b,%r14b
jne 1650 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1a0>
lea 0xae1(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1600 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x150>
cmp $0x15,%ebx
jg 1620 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x170>
lea 0xad9(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
lea 0xad2(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
lea 0xacc(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 15ec <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x13c>
test %r14b,%r14b
je 15ec <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x13c>
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0xa43(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmp 15ec <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x13c>
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0xa4f(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
lea 0xa55(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1720 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x270>
cmp $0x15,%ebx
jle 158b <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xdb>
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0xa17(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0x9ee(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
lea 0x995(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1501 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x51>
lea 0x984(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1748 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x298>
lea 0x973(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1748 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x298>
lea 0x960(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1748 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x298>
lea 0x952(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 16fe <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x24e>
lea 0x94b(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1769 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x2b9>
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0x940(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmpq 151d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x6d>
lea 0x93d(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 159a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xea>
cmp $0x15,%ebx
jg 1620 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x170>
jmpq 159a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xea>
nopl (%rax)
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0x8d7(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmpq 151d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x6d>
lea 0x8d4(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 16fe <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x24e>
lea 0x8c7(%rip),%rsi
mov %r12,%rdi
callq 1190 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc@plt>
jmpq 151d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x6d>
endbr64
mov %rax,%rbp
jmpq 11a0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi.cold>
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
lea rax, [rdi+10h]
push r12
mov r12d, edx
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rax, [rsi+8]
cmp rax, 7
jz loc_15D0
cmp rax, 8
jnz loc_1520
mov rax, 7972617572626546h
mov rdx, [rsi]
cmp [rdx], rax
jnz loc_15DF
loc_14B2:
mov r8d, 6
xor edx, edx
xor esi, esi
mov rdi, rbx
lea rcx, aWinter; "winter"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
loc_14CB:
mov rax, [rbp+8]
cmp rax, 5
jz loc_1580
loc_14D9:
cmp rax, 4
jnz loc_1600
mov rax, [rbp+0]
cmp dword ptr [rax], 656E754Ah
jnz short loc_1510
cmp r12d, 14h
jle short loc_1510
mov rdx, [rbx+8]
mov r8d, 6
xor esi, esi
mov rdi, rbx
lea rcx, aSummer; "summer"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
loc_1510:
mov rax, rbx
pop rbx
pop rbp
pop r12
retn
loc_1520:
cmp rax, 5
jnz loc_1728
mov rax, [rsi]
cmp dword ptr [rax], 6372614Dh
jz loc_1790
loc_1539:
cmp dword ptr [rax], 69727041h
jnz loc_15DF
cmp byte ptr [rax+4], 6Ch ; 'l'
jnz loc_15DF
loc_154F:
mov r8d, 6
xor edx, edx
xor esi, esi
mov rdi, rbx
lea rcx, aSpring; "spring"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov rax, [rbp+8]
cmp rax, 5
jnz loc_14D9
nop word ptr [rax+rax+00000000h]
loc_1580:
mov rax, [rbp+0]
cmp dword ptr [rax], 6372614Dh
jz loc_16F8
loc_1590:
mov eax, 1
loc_1595:
test eax, eax
jnz loc_1510
cmp r12d, 13h
jle loc_1510
mov rdx, [rbx+8]
mov r8d, 6
xor esi, esi
mov rdi, rbx
lea rcx, aSpring; "spring"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov rax, rbx
pop rbx
pop rbp
pop r12
retn
loc_15D0:
mov rax, [rsi]
cmp dword ptr [rax], 756E614Ah
jz loc_1710
loc_15DF:
mov r8d, 6
xor edx, edx
xor esi, esi
mov rdi, rbx
lea rcx, aAutumn; "autumn"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_14CB
loc_1600:
cmp rax, 9
jnz short loc_1660
mov rdx, 65626D6574706553h
mov rax, [rbp+0]
cmp [rax], rdx
jnz loc_1510
cmp byte ptr [rax+8], 72h ; 'r'
jnz loc_1510
cmp r12d, 15h
jle loc_1510
nop dword ptr [rax+00000000h]
loc_1638:
mov rdx, [rbx+8]
mov r8d, 6
xor esi, esi
mov rdi, rbx
lea rcx, aAutumn; "autumn"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov rax, rbx
pop rbx
pop rbp
pop r12
retn
loc_1660:
cmp rax, 7
jnz short loc_1690
mov rax, [rbp+0]
cmp dword ptr [rax], 6F74634Fh
jz loc_17C8
loc_1676:
mov eax, 1
loc_167B:
cmp r12d, 15h
jle loc_1510
test eax, eax
jnz loc_1510
jmp short loc_1638
loc_1690:
cmp rax, 8
jnz loc_1510
mov rdx, 7265626D65766F4Eh
mov rax, [rbp+0]
cmp [rax], rdx
jnz short loc_16B7
cmp r12d, 15h
jg loc_1638
loc_16B7:
mov rdx, 7265626D65636544h
cmp [rax], rdx
jnz loc_1510
cmp r12d, 14h
jle loc_1510
mov rdx, [rbx+8]
mov r8d, 6
xor esi, esi
mov rdi, rbx
lea rcx, aWinter; "winter"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_1510
loc_16F8:
cmp byte ptr [rax+4], 68h ; 'h'
jnz loc_1590
xor eax, eax
jmp loc_1595
loc_1710:
cmp dword ptr [rax+3], 79726175h
jnz loc_15DF
jmp loc_14B2
loc_1728:
cmp rax, 3
jnz short loc_1750
mov rax, [rsi]
cmp word ptr [rax], 614Dh
jnz loc_15DF
cmp byte ptr [rax+2], 79h ; 'y'
jnz loc_15DF
jmp loc_154F
loc_1750:
cmp rax, 4
jnz short loc_17A0
mov rax, [rsi]
cmp dword ptr [rax], 656E754Ah
jz loc_154F
cmp dword ptr [rax], 796C754Ah
jnz loc_15DF
loc_1771:
mov r8d, 6
xor edx, edx
xor esi, esi
mov rdi, rbx
lea rcx, aSummer; "summer"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_14CB
loc_1790:
cmp byte ptr [rax+4], 68h ; 'h'
jnz loc_1539
jmp loc_14B2
loc_17A0:
cmp rax, 6
jnz short loc_17DC
mov rax, [rsi]
cmp dword ptr [rax], 75677541h
jnz loc_15DF
cmp word ptr [rax+4], 7473h
jnz loc_15DF
jmp short loc_1771
loc_17C8:
cmp dword ptr [rax+3], 7265626Fh
jnz loc_1676
xor eax, eax
jmp loc_167B
loc_17DC:
cmp rax, 9
jnz loc_15DF
mov rdx, 65626D6574706553h
mov rax, [rsi]
cmp [rax], rdx
jnz loc_15DF
cmp byte ptr [rax+8], 72h ; 'r'
jnz loc_15DF
jmp loc_1771
endbr64
mov rbp, rax
jmp _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi_cold; func0(std::string,int) [clone] | long long func0(long long a1, _QWORD *a2, int a3)
{
long long v4; // rax
long long v5; // rax
long long v7; // rax
_BOOL4 v8; // eax
_BOOL4 v9; // eax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = a2[1];
if ( v4 == 7 )
{
if ( *(_DWORD *)*a2 == 1970168138 && *(_DWORD *)(*a2 + 3LL) == 2037539189 )
goto LABEL_4;
goto LABEL_22;
}
if ( v4 == 8 )
{
if ( *(_QWORD *)*a2 == 0x7972617572626546LL )
{
LABEL_4:
std::string::_M_replace(a1, 0LL, 0LL, "winter", 6LL);
goto LABEL_5;
}
goto LABEL_22;
}
if ( v4 != 5 )
{
switch ( v4 )
{
case 3LL:
if ( *(_WORD *)*a2 == 24909 && *(_BYTE *)(*a2 + 2LL) == 121 )
goto LABEL_15;
LABEL_22:
std::string::_M_replace(a1, 0LL, 0LL, "autumn", 6LL);
goto LABEL_5;
case 4LL:
if ( *(_DWORD *)*a2 == 1701737802 )
goto LABEL_15;
if ( *(_DWORD *)*a2 != 2037151050 )
goto LABEL_22;
break;
case 6LL:
if ( *(_DWORD *)*a2 != 1969714497 || *(_WORD *)(*a2 + 4LL) != 29811 )
goto LABEL_22;
break;
default:
if ( v4 != 9 || *(_QWORD *)*a2 != 0x65626D6574706553LL || *(_BYTE *)(*a2 + 8LL) != 114 )
goto LABEL_22;
break;
}
std::string::_M_replace(a1, 0LL, 0LL, "summer", 6LL);
LABEL_5:
v5 = a2[1];
if ( v5 != 5 )
goto LABEL_6;
goto LABEL_16;
}
v7 = *a2;
if ( *(_DWORD *)*a2 == 1668440397 && *(_BYTE *)(v7 + 4) == 104 )
goto LABEL_4;
if ( *(_DWORD *)v7 != 1769107521 || *(_BYTE *)(v7 + 4) != 108 )
goto LABEL_22;
LABEL_15:
std::string::_M_replace(a1, 0LL, 0LL, "spring", 6LL);
v5 = a2[1];
if ( v5 != 5 )
{
LABEL_6:
switch ( v5 )
{
case 4LL:
if ( *(_DWORD *)*a2 == 1701737802 && a3 > 20 )
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "summer", 6LL);
return a1;
case 9LL:
if ( *(_QWORD *)*a2 == 0x65626D6574706553LL && *(_BYTE *)(*a2 + 8LL) == 114 && a3 > 21 )
{
LABEL_27:
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "autumn", 6LL);
return a1;
}
break;
case 7LL:
v9 = *(_DWORD *)*a2 != 1869898575 || *(_DWORD *)(*a2 + 3LL) != 1919246959;
if ( a3 <= 21 || v9 )
return a1;
goto LABEL_27;
case 8LL:
if ( *(_QWORD *)*a2 != 0x7265626D65766F4ELL || a3 <= 21 )
{
if ( *(_QWORD *)*a2 == 0x7265626D65636544LL && a3 > 20 )
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "winter", 6LL);
return a1;
}
goto LABEL_27;
}
return a1;
}
LABEL_16:
v8 = *(_DWORD *)*a2 != 1668440397 || *(_BYTE *)(*a2 + 4LL) != 104;
if ( v8 || a3 <= 19 )
return a1;
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "spring", 6LL);
return a1;
} | func0:
ENDBR64
LEA RAX,[RDI + 0x10]
PUSH R12
MOV R12D,EDX
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI + 0x8]
CMP RAX,0x7
JZ 0x001015d0
CMP RAX,0x8
JNZ 0x00101520
MOV RAX,0x7972617572626546
MOV RDX,qword ptr [RSI]
CMP qword ptr [RDX],RAX
JNZ 0x001015df
LAB_001014b2:
MOV R8D,0x6
XOR EDX,EDX
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102012]
LAB_001014c6:
CALL 0x00101150
LAB_001014cb:
MOV RAX,qword ptr [RBP + 0x8]
CMP RAX,0x5
JZ 0x00101580
LAB_001014d9:
CMP RAX,0x4
JNZ 0x00101600
MOV RAX,qword ptr [RBP]
CMP dword ptr [RAX],0x656e754a
JNZ 0x00101510
CMP R12D,0x14
JLE 0x00101510
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102042]
CALL 0x00101150
LAB_00101510:
MOV RAX,RBX
POP RBX
POP RBP
POP R12
RET
LAB_00101520:
CMP RAX,0x5
JNZ 0x00101728
MOV RAX,qword ptr [RSI]
CMP dword ptr [RAX],0x6372614d
JZ 0x00101790
LAB_00101539:
CMP dword ptr [RAX],0x69727041
JNZ 0x001015df
CMP byte ptr [RAX + 0x4],0x6c
JNZ 0x001015df
LAB_0010154f:
MOV R8D,0x6
XOR EDX,EDX
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102023]
CALL 0x00101150
MOV RAX,qword ptr [RBP + 0x8]
CMP RAX,0x5
JNZ 0x001014d9
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101580:
MOV RAX,qword ptr [RBP]
CMP dword ptr [RAX],0x6372614d
JZ 0x001016f8
LAB_00101590:
MOV EAX,0x1
LAB_00101595:
TEST EAX,EAX
JNZ 0x00101510
CMP R12D,0x13
JLE 0x00101510
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102023]
CALL 0x00101150
MOV RAX,RBX
POP RBX
POP RBP
POP R12
RET
LAB_001015d0:
MOV RAX,qword ptr [RSI]
CMP dword ptr [RAX],0x756e614a
JZ 0x00101710
LAB_001015df:
MOV R8D,0x6
XOR EDX,EDX
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x10203b]
CALL 0x00101150
JMP 0x001014cb
LAB_00101600:
CMP RAX,0x9
JNZ 0x00101660
MOV RDX,0x65626d6574706553
MOV RAX,qword ptr [RBP]
CMP qword ptr [RAX],RDX
JNZ 0x00101510
CMP byte ptr [RAX + 0x8],0x72
JNZ 0x00101510
CMP R12D,0x15
JLE 0x00101510
NOP dword ptr [RAX]
LAB_00101638:
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x10203b]
CALL 0x00101150
MOV RAX,RBX
POP RBX
POP RBP
POP R12
RET
LAB_00101660:
CMP RAX,0x7
JNZ 0x00101690
MOV RAX,qword ptr [RBP]
CMP dword ptr [RAX],0x6f74634f
JZ 0x001017c8
LAB_00101676:
MOV EAX,0x1
LAB_0010167b:
CMP R12D,0x15
JLE 0x00101510
TEST EAX,EAX
JNZ 0x00101510
JMP 0x00101638
LAB_00101690:
CMP RAX,0x8
JNZ 0x00101510
MOV RDX,0x7265626d65766f4e
MOV RAX,qword ptr [RBP]
CMP qword ptr [RAX],RDX
JNZ 0x001016b7
CMP R12D,0x15
JG 0x00101638
LAB_001016b7:
MOV RDX,0x7265626d65636544
CMP qword ptr [RAX],RDX
JNZ 0x00101510
CMP R12D,0x14
JLE 0x00101510
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102012]
CALL 0x00101150
JMP 0x00101510
LAB_001016f8:
CMP byte ptr [RAX + 0x4],0x68
JNZ 0x00101590
XOR EAX,EAX
JMP 0x00101595
LAB_00101710:
CMP dword ptr [RAX + 0x3],0x79726175
JNZ 0x001015df
JMP 0x001014b2
LAB_00101728:
CMP RAX,0x3
JNZ 0x00101750
MOV RAX,qword ptr [RSI]
CMP word ptr [RAX],0x614d
JNZ 0x001015df
CMP byte ptr [RAX + 0x2],0x79
JNZ 0x001015df
JMP 0x0010154f
LAB_00101750:
CMP RAX,0x4
JNZ 0x001017a0
MOV RAX,qword ptr [RSI]
CMP dword ptr [RAX],0x656e754a
JZ 0x0010154f
CMP dword ptr [RAX],0x796c754a
JNZ 0x001015df
LAB_00101771:
MOV R8D,0x6
XOR EDX,EDX
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102042]
CALL 0x00101150
JMP 0x001014cb
LAB_00101790:
CMP byte ptr [RAX + 0x4],0x68
JNZ 0x00101539
JMP 0x001014b2
LAB_001017a0:
CMP RAX,0x6
JNZ 0x001017dc
MOV RAX,qword ptr [RSI]
CMP dword ptr [RAX],0x75677541
JNZ 0x001015df
CMP word ptr [RAX + 0x4],0x7473
JNZ 0x001015df
JMP 0x00101771
LAB_001017c8:
CMP dword ptr [RAX + 0x3],0x7265626f
JNZ 0x00101676
XOR EAX,EAX
JMP 0x0010167b
LAB_001017dc:
CMP RAX,0x9
JNZ 0x001015df
MOV RDX,0x65626d6574706553
MOV RAX,qword ptr [RSI]
CMP qword ptr [RAX],RDX
JNZ 0x001015df
CMP byte ptr [RAX + 0x8],0x72
JNZ 0x001015df
JMP 0x00101771 | /* func0(std::string, int) */
long * func0(long *param_1,long *param_2,int param_3)
{
long lVar1;
int *piVar2;
bool bVar3;
*param_1 = (long)(param_1 + 2);
param_1[1] = 0;
*(int *)(param_1 + 2) = 0;
lVar1 = param_2[1];
if (lVar1 == 7) {
if ((*(int *)*param_2 != 0x756e614a) || (*(int *)(*param_2 + 3) != 0x79726175))
goto LAB_001015df;
LAB_001014b2:
/* try { // try from 001014c6 to 00101789 has its CatchHandler @ 0010180b */
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x102012);
LAB_001014cb:
lVar1 = param_2[1];
}
else {
if (lVar1 == 8) {
if (*(long *)*param_2 == 0x7972617572626546) goto LAB_001014b2;
LAB_001015df:
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x10203b);
goto LAB_001014cb;
}
if (lVar1 == 5) {
piVar2 = (int *)*param_2;
if ((*piVar2 == 0x6372614d) && (*(char *)(piVar2 + 1) == 'h')) goto LAB_001014b2;
if ((*piVar2 != 0x69727041) || (*(char *)(piVar2 + 1) != 'l')) goto LAB_001015df;
}
else if (lVar1 == 3) {
if ((*(short *)*param_2 != 0x614d) || (*(char *)((short *)*param_2 + 1) != 'y'))
goto LAB_001015df;
}
else {
if (lVar1 != 4) {
if (lVar1 == 6) {
if ((*(int *)*param_2 == 0x75677541) && (*(short *)((int *)*param_2 + 1) == 0x7473)) {
LAB_00101771:
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x102042);
goto LAB_001014cb;
}
}
else if (((lVar1 == 9) && (*(long *)*param_2 == 0x65626d6574706553)) &&
(*(char *)((long *)*param_2 + 1) == 'r')) goto LAB_00101771;
goto LAB_001015df;
}
if (*(int *)*param_2 != 0x656e754a) {
if (*(int *)*param_2 == 0x796c754a) goto LAB_00101771;
goto LAB_001015df;
}
}
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x102023);
lVar1 = param_2[1];
}
if (lVar1 == 5) {
if ((*(int *)*param_2 == 0x6372614d) && (*(char *)((int *)*param_2 + 1) == 'h')) {
bVar3 = false;
}
else {
bVar3 = true;
}
if ((!bVar3) && (0x13 < param_3)) {
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x102023);
return param_1;
}
}
else if (lVar1 == 4) {
if ((*(int *)*param_2 == 0x656e754a) && (0x14 < param_3)) {
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x102042);
}
}
else if (lVar1 == 9) {
if ((*(long *)*param_2 == 0x65626d6574706553) &&
((*(char *)((long *)*param_2 + 1) == 'r' && (0x15 < param_3)))) {
LAB_00101638:
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x10203b);
return param_1;
}
}
else if (lVar1 == 7) {
if ((*(int *)*param_2 == 0x6f74634f) && (*(int *)(*param_2 + 3) == 0x7265626f)) {
bVar3 = false;
}
else {
bVar3 = true;
}
if ((0x15 < param_3) && (!bVar3)) goto LAB_00101638;
}
else if (lVar1 == 8) {
if ((*(long *)*param_2 == 0x7265626d65766f4e) && (0x15 < param_3)) goto LAB_00101638;
if ((*(long *)*param_2 == 0x7265626d65636544) && (0x14 < param_3)) {
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x102012);
}
}
return param_1;
} |
635 | func0 |
#include <string>
#include <assert.h>
| std::string func0(std::string month, int days) {
std::string season;
if (month == "January" || month == "February" || month == "March") {
season = "winter";
} else if (month == "April" || month == "May" || month == "June") {
season = "spring";
} else if (month == "July" || month == "August" || month == "September") {
season = "summer";
} else {
season = "autumn";
}
if ((month == "March") && (days > 19)) {
season = "spring";
} else if ((month == "June") && (days > 20)) {
season = "summer";
} else if ((month == "September") && (days > 21)) {
season = "autumn";
} else if ((month == "October") && (days > 21)) {
season = "autumn";
} else if ((month == "November") && (days > 21)) {
season = "autumn";
} else if ((month == "December") && (days > 20)) {
season = "winter";
}
return season;
}
| int main() {
assert(func0("January", 4) == "winter");
assert(func0("October", 28) == "autumn");
assert(func0("June", 6) == "spring");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int):
endbr64
push %r14
push %r13
lea 0x10(%rdi),%r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
lea 0xb38(%rip),%rsi
push %rbx
mov %edx,%ebx
mov %r13,(%rdi)
movq $0x0,0x8(%rdi)
movb $0x0,0x10(%rdi)
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1501 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x51>
lea 0xb22(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1680 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1d0>
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0xaf4(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
lea 0xaf8(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
cmp $0x13,%ebx
jle 1539 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x89>
test %eax,%eax
je 15d0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x120>
lea 0xaec(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
cmp $0x14,%ebx
setg %r14b
test %eax,%eax
jne 155c <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xac>
test %r14b,%r14b
jne 1650 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x1a0>
lea 0xae1(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1600 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x150>
cmp $0x15,%ebx
jg 1620 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x170>
lea 0xad9(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
lea 0xad2(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
lea 0xacc(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 15ec <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x13c>
test %r14b,%r14b
je 15ec <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x13c>
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0xa43(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmp 15ec <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x13c>
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0xa4f(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
lea 0xa55(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1720 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x270>
cmp $0x15,%ebx
jle 158b <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xdb>
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0xa17(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0x9ee(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
pop %rbx
mov %r12,%rax
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
lea 0x995(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1501 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x51>
lea 0x984(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1748 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x298>
lea 0x973(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1748 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x298>
lea 0x960(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 1748 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x298>
lea 0x952(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 16fe <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x24e>
lea 0x94b(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 1769 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x2b9>
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0x940(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmpq 151d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x6d>
lea 0x93d(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
jne 159a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xea>
cmp $0x15,%ebx
jg 1620 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x170>
jmpq 159a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0xea>
nopl (%rax)
mov 0x8(%r12),%rdx
mov $0x6,%r8d
xor %esi,%esi
mov %r12,%rdi
lea 0x8d7(%rip),%rcx
callq 1160 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@plt>
jmpq 151d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x6d>
lea 0x8d4(%rip),%rsi
mov %rbp,%rdi
callq 10f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@plt>
test %eax,%eax
je 16fe <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x24e>
lea 0x8c7(%rip),%rsi
mov %r12,%rdi
callq 1190 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc@plt>
jmpq 151d <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi+0x6d>
endbr64
mov %rax,%rbp
jmpq 11a0 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi.cold>
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
endbr64
lea rax, [rdi+10h]
push r12
mov r12d, edx
push rbp
mov rbp, rsi
push rbx
mov rbx, rdi
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rax, [rsi+8]
cmp rax, 7
jz loc_15D0
cmp rax, 8
jnz loc_1520
mov rax, 7972617572626546h
mov rdx, [rsi]
cmp [rdx], rax
jnz loc_15DF
loc_14B2:
mov r8d, 6
xor edx, edx
xor esi, esi
mov rdi, rbx
lea rcx, aWinter; "winter"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
loc_14CB:
mov rax, [rbp+8]
cmp rax, 5
jz loc_1580
loc_14D9:
cmp rax, 4
jnz loc_1600
mov rax, [rbp+0]
cmp dword ptr [rax], 656E754Ah
jnz short loc_1510
cmp r12d, 14h
jle short loc_1510
mov rdx, [rbx+8]
mov r8d, 6
xor esi, esi
mov rdi, rbx
lea rcx, aSummer; "summer"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
loc_1510:
mov rax, rbx
pop rbx
pop rbp
pop r12
retn
loc_1520:
cmp rax, 5
jnz loc_1728
mov rax, [rsi]
cmp dword ptr [rax], 6372614Dh
jz loc_1790
loc_1539:
cmp dword ptr [rax], 69727041h
jnz loc_15DF
cmp byte ptr [rax+4], 6Ch ; 'l'
jnz loc_15DF
loc_154F:
mov r8d, 6
xor edx, edx
xor esi, esi
mov rdi, rbx
lea rcx, aSpring; "spring"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov rax, [rbp+8]
cmp rax, 5
jnz loc_14D9
nop word ptr [rax+rax+00000000h]
loc_1580:
mov rax, [rbp+0]
cmp dword ptr [rax], 6372614Dh
jz loc_16F8
loc_1590:
mov eax, 1
loc_1595:
test eax, eax
jnz loc_1510
cmp r12d, 13h
jle loc_1510
mov rdx, [rbx+8]
mov r8d, 6
xor esi, esi
mov rdi, rbx
lea rcx, aSpring; "spring"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov rax, rbx
pop rbx
pop rbp
pop r12
retn
loc_15D0:
mov rax, [rsi]
cmp dword ptr [rax], 756E614Ah
jz loc_1710
loc_15DF:
mov r8d, 6
xor edx, edx
xor esi, esi
mov rdi, rbx
lea rcx, aAutumn; "autumn"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_14CB
loc_1600:
cmp rax, 9
jnz short loc_1660
mov rdx, 65626D6574706553h
mov rax, [rbp+0]
cmp [rax], rdx
jnz loc_1510
cmp byte ptr [rax+8], 72h ; 'r'
jnz loc_1510
cmp r12d, 15h
jle loc_1510
nop dword ptr [rax+00000000h]
loc_1638:
mov rdx, [rbx+8]
mov r8d, 6
xor esi, esi
mov rdi, rbx
lea rcx, aAutumn; "autumn"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov rax, rbx
pop rbx
pop rbp
pop r12
retn
loc_1660:
cmp rax, 7
jnz short loc_1690
mov rax, [rbp+0]
cmp dword ptr [rax], 6F74634Fh
jz loc_17C8
loc_1676:
mov eax, 1
loc_167B:
cmp r12d, 15h
jle loc_1510
test eax, eax
jnz loc_1510
jmp short loc_1638
loc_1690:
cmp rax, 8
jnz loc_1510
mov rdx, 7265626D65766F4Eh
mov rax, [rbp+0]
cmp [rax], rdx
jnz short loc_16B7
cmp r12d, 15h
jg loc_1638
loc_16B7:
mov rdx, 7265626D65636544h
cmp [rax], rdx
jnz loc_1510
cmp r12d, 14h
jle loc_1510
mov rdx, [rbx+8]
mov r8d, 6
xor esi, esi
mov rdi, rbx
lea rcx, aWinter; "winter"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_1510
loc_16F8:
cmp byte ptr [rax+4], 68h ; 'h'
jnz loc_1590
xor eax, eax
jmp loc_1595
loc_1710:
cmp dword ptr [rax+3], 79726175h
jnz loc_15DF
jmp loc_14B2
loc_1728:
cmp rax, 3
jnz short loc_1750
mov rax, [rsi]
cmp word ptr [rax], 614Dh
jnz loc_15DF
cmp byte ptr [rax+2], 79h ; 'y'
jnz loc_15DF
jmp loc_154F
loc_1750:
cmp rax, 4
jnz short loc_17A0
mov rax, [rsi]
cmp dword ptr [rax], 656E754Ah
jz loc_154F
cmp dword ptr [rax], 796C754Ah
jnz loc_15DF
loc_1771:
mov r8d, 6
xor edx, edx
xor esi, esi
mov rdi, rbx
lea rcx, aSummer; "summer"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_14CB
loc_1790:
cmp byte ptr [rax+4], 68h ; 'h'
jnz loc_1539
jmp loc_14B2
loc_17A0:
cmp rax, 6
jnz short loc_17DC
mov rax, [rsi]
cmp dword ptr [rax], 75677541h
jnz loc_15DF
cmp word ptr [rax+4], 7473h
jnz loc_15DF
jmp short loc_1771
loc_17C8:
cmp dword ptr [rax+3], 7265626Fh
jnz loc_1676
xor eax, eax
jmp loc_167B
loc_17DC:
cmp rax, 9
jnz loc_15DF
mov rdx, 65626D6574706553h
mov rax, [rsi]
cmp [rax], rdx
jnz loc_15DF
cmp byte ptr [rax+8], 72h ; 'r'
jnz loc_15DF
jmp loc_1771
endbr64
mov rbp, rax
jmp _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi_cold; func0(std::string,int) [clone] | long long func0(long long a1, _QWORD *a2, int a3)
{
long long v4; // rax
long long v5; // rax
long long v7; // rax
_BOOL4 v8; // eax
_BOOL4 v9; // eax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = a2[1];
if ( v4 == 7 )
{
if ( *(_DWORD *)*a2 == 1970168138 && *(_DWORD *)(*a2 + 3LL) == 2037539189 )
goto LABEL_4;
goto LABEL_22;
}
if ( v4 == 8 )
{
if ( *(_QWORD *)*a2 == 0x7972617572626546LL )
{
LABEL_4:
std::string::_M_replace(a1, 0LL, 0LL, "winter", 6LL);
goto LABEL_5;
}
goto LABEL_22;
}
if ( v4 != 5 )
{
switch ( v4 )
{
case 3LL:
if ( *(_WORD *)*a2 == 24909 && *(_BYTE *)(*a2 + 2LL) == 121 )
goto LABEL_15;
LABEL_22:
std::string::_M_replace(a1, 0LL, 0LL, "autumn", 6LL);
goto LABEL_5;
case 4LL:
if ( *(_DWORD *)*a2 == 1701737802 )
goto LABEL_15;
if ( *(_DWORD *)*a2 != 2037151050 )
goto LABEL_22;
break;
case 6LL:
if ( *(_DWORD *)*a2 != 1969714497 || *(_WORD *)(*a2 + 4LL) != 29811 )
goto LABEL_22;
break;
default:
if ( v4 != 9 || *(_QWORD *)*a2 != 0x65626D6574706553LL || *(_BYTE *)(*a2 + 8LL) != 114 )
goto LABEL_22;
break;
}
std::string::_M_replace(a1, 0LL, 0LL, "summer", 6LL);
LABEL_5:
v5 = a2[1];
if ( v5 != 5 )
goto LABEL_6;
goto LABEL_16;
}
v7 = *a2;
if ( *(_DWORD *)*a2 == 1668440397 && *(_BYTE *)(v7 + 4) == 104 )
goto LABEL_4;
if ( *(_DWORD *)v7 != 1769107521 || *(_BYTE *)(v7 + 4) != 108 )
goto LABEL_22;
LABEL_15:
std::string::_M_replace(a1, 0LL, 0LL, "spring", 6LL);
v5 = a2[1];
if ( v5 != 5 )
{
LABEL_6:
switch ( v5 )
{
case 4LL:
if ( *(_DWORD *)*a2 == 1701737802 && a3 > 20 )
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "summer", 6LL);
return a1;
case 9LL:
if ( *(_QWORD *)*a2 == 0x65626D6574706553LL && *(_BYTE *)(*a2 + 8LL) == 114 && a3 > 21 )
{
LABEL_27:
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "autumn", 6LL);
return a1;
}
break;
case 7LL:
v9 = *(_DWORD *)*a2 != 1869898575 || *(_DWORD *)(*a2 + 3LL) != 1919246959;
if ( a3 <= 21 || v9 )
return a1;
goto LABEL_27;
case 8LL:
if ( *(_QWORD *)*a2 != 0x7265626D65766F4ELL || a3 <= 21 )
{
if ( *(_QWORD *)*a2 == 0x7265626D65636544LL && a3 > 20 )
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "winter", 6LL);
return a1;
}
goto LABEL_27;
}
return a1;
}
LABEL_16:
v8 = *(_DWORD *)*a2 != 1668440397 || *(_BYTE *)(*a2 + 4LL) != 104;
if ( v8 || a3 <= 19 )
return a1;
std::string::_M_replace(a1, 0LL, *(_QWORD *)(a1 + 8), "spring", 6LL);
return a1;
} | func0:
ENDBR64
LEA RAX,[RDI + 0x10]
PUSH R12
MOV R12D,EDX
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV RBX,RDI
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI + 0x8]
CMP RAX,0x7
JZ 0x001015d0
CMP RAX,0x8
JNZ 0x00101520
MOV RAX,0x7972617572626546
MOV RDX,qword ptr [RSI]
CMP qword ptr [RDX],RAX
JNZ 0x001015df
LAB_001014b2:
MOV R8D,0x6
XOR EDX,EDX
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102012]
LAB_001014c6:
CALL 0x00101150
LAB_001014cb:
MOV RAX,qword ptr [RBP + 0x8]
CMP RAX,0x5
JZ 0x00101580
LAB_001014d9:
CMP RAX,0x4
JNZ 0x00101600
MOV RAX,qword ptr [RBP]
CMP dword ptr [RAX],0x656e754a
JNZ 0x00101510
CMP R12D,0x14
JLE 0x00101510
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102042]
CALL 0x00101150
LAB_00101510:
MOV RAX,RBX
POP RBX
POP RBP
POP R12
RET
LAB_00101520:
CMP RAX,0x5
JNZ 0x00101728
MOV RAX,qword ptr [RSI]
CMP dword ptr [RAX],0x6372614d
JZ 0x00101790
LAB_00101539:
CMP dword ptr [RAX],0x69727041
JNZ 0x001015df
CMP byte ptr [RAX + 0x4],0x6c
JNZ 0x001015df
LAB_0010154f:
MOV R8D,0x6
XOR EDX,EDX
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102023]
CALL 0x00101150
MOV RAX,qword ptr [RBP + 0x8]
CMP RAX,0x5
JNZ 0x001014d9
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101580:
MOV RAX,qword ptr [RBP]
CMP dword ptr [RAX],0x6372614d
JZ 0x001016f8
LAB_00101590:
MOV EAX,0x1
LAB_00101595:
TEST EAX,EAX
JNZ 0x00101510
CMP R12D,0x13
JLE 0x00101510
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102023]
CALL 0x00101150
MOV RAX,RBX
POP RBX
POP RBP
POP R12
RET
LAB_001015d0:
MOV RAX,qword ptr [RSI]
CMP dword ptr [RAX],0x756e614a
JZ 0x00101710
LAB_001015df:
MOV R8D,0x6
XOR EDX,EDX
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x10203b]
CALL 0x00101150
JMP 0x001014cb
LAB_00101600:
CMP RAX,0x9
JNZ 0x00101660
MOV RDX,0x65626d6574706553
MOV RAX,qword ptr [RBP]
CMP qword ptr [RAX],RDX
JNZ 0x00101510
CMP byte ptr [RAX + 0x8],0x72
JNZ 0x00101510
CMP R12D,0x15
JLE 0x00101510
NOP dword ptr [RAX]
LAB_00101638:
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x10203b]
CALL 0x00101150
MOV RAX,RBX
POP RBX
POP RBP
POP R12
RET
LAB_00101660:
CMP RAX,0x7
JNZ 0x00101690
MOV RAX,qword ptr [RBP]
CMP dword ptr [RAX],0x6f74634f
JZ 0x001017c8
LAB_00101676:
MOV EAX,0x1
LAB_0010167b:
CMP R12D,0x15
JLE 0x00101510
TEST EAX,EAX
JNZ 0x00101510
JMP 0x00101638
LAB_00101690:
CMP RAX,0x8
JNZ 0x00101510
MOV RDX,0x7265626d65766f4e
MOV RAX,qword ptr [RBP]
CMP qword ptr [RAX],RDX
JNZ 0x001016b7
CMP R12D,0x15
JG 0x00101638
LAB_001016b7:
MOV RDX,0x7265626d65636544
CMP qword ptr [RAX],RDX
JNZ 0x00101510
CMP R12D,0x14
JLE 0x00101510
MOV RDX,qword ptr [RBX + 0x8]
MOV R8D,0x6
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102012]
CALL 0x00101150
JMP 0x00101510
LAB_001016f8:
CMP byte ptr [RAX + 0x4],0x68
JNZ 0x00101590
XOR EAX,EAX
JMP 0x00101595
LAB_00101710:
CMP dword ptr [RAX + 0x3],0x79726175
JNZ 0x001015df
JMP 0x001014b2
LAB_00101728:
CMP RAX,0x3
JNZ 0x00101750
MOV RAX,qword ptr [RSI]
CMP word ptr [RAX],0x614d
JNZ 0x001015df
CMP byte ptr [RAX + 0x2],0x79
JNZ 0x001015df
JMP 0x0010154f
LAB_00101750:
CMP RAX,0x4
JNZ 0x001017a0
MOV RAX,qword ptr [RSI]
CMP dword ptr [RAX],0x656e754a
JZ 0x0010154f
CMP dword ptr [RAX],0x796c754a
JNZ 0x001015df
LAB_00101771:
MOV R8D,0x6
XOR EDX,EDX
XOR ESI,ESI
MOV RDI,RBX
LEA RCX,[0x102042]
CALL 0x00101150
JMP 0x001014cb
LAB_00101790:
CMP byte ptr [RAX + 0x4],0x68
JNZ 0x00101539
JMP 0x001014b2
LAB_001017a0:
CMP RAX,0x6
JNZ 0x001017dc
MOV RAX,qword ptr [RSI]
CMP dword ptr [RAX],0x75677541
JNZ 0x001015df
CMP word ptr [RAX + 0x4],0x7473
JNZ 0x001015df
JMP 0x00101771
LAB_001017c8:
CMP dword ptr [RAX + 0x3],0x7265626f
JNZ 0x00101676
XOR EAX,EAX
JMP 0x0010167b
LAB_001017dc:
CMP RAX,0x9
JNZ 0x001015df
MOV RDX,0x65626d6574706553
MOV RAX,qword ptr [RSI]
CMP qword ptr [RAX],RDX
JNZ 0x001015df
CMP byte ptr [RAX + 0x8],0x72
JNZ 0x001015df
JMP 0x00101771 | /* func0(std::string, int) */
long * func0(long *param_1,long *param_2,int param_3)
{
long lVar1;
int *piVar2;
bool bVar3;
*param_1 = (long)(param_1 + 2);
param_1[1] = 0;
*(int *)(param_1 + 2) = 0;
lVar1 = param_2[1];
if (lVar1 == 7) {
if ((*(int *)*param_2 != 0x756e614a) || (*(int *)(*param_2 + 3) != 0x79726175))
goto LAB_001015df;
LAB_001014b2:
/* try { // try from 001014c6 to 00101789 has its CatchHandler @ 0010180b */
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x102012);
LAB_001014cb:
lVar1 = param_2[1];
}
else {
if (lVar1 == 8) {
if (*(long *)*param_2 == 0x7972617572626546) goto LAB_001014b2;
LAB_001015df:
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x10203b);
goto LAB_001014cb;
}
if (lVar1 == 5) {
piVar2 = (int *)*param_2;
if ((*piVar2 == 0x6372614d) && (*(char *)(piVar2 + 1) == 'h')) goto LAB_001014b2;
if ((*piVar2 != 0x69727041) || (*(char *)(piVar2 + 1) != 'l')) goto LAB_001015df;
}
else if (lVar1 == 3) {
if ((*(short *)*param_2 != 0x614d) || (*(char *)((short *)*param_2 + 1) != 'y'))
goto LAB_001015df;
}
else {
if (lVar1 != 4) {
if (lVar1 == 6) {
if ((*(int *)*param_2 == 0x75677541) && (*(short *)((int *)*param_2 + 1) == 0x7473)) {
LAB_00101771:
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x102042);
goto LAB_001014cb;
}
}
else if (((lVar1 == 9) && (*(long *)*param_2 == 0x65626d6574706553)) &&
(*(char *)((long *)*param_2 + 1) == 'r')) goto LAB_00101771;
goto LAB_001015df;
}
if (*(int *)*param_2 != 0x656e754a) {
if (*(int *)*param_2 == 0x796c754a) goto LAB_00101771;
goto LAB_001015df;
}
}
std::string::_M_replace((ulong)param_1,0,(char *)0x0,0x102023);
lVar1 = param_2[1];
}
if (lVar1 == 5) {
if ((*(int *)*param_2 == 0x6372614d) && (*(char *)((int *)*param_2 + 1) == 'h')) {
bVar3 = false;
}
else {
bVar3 = true;
}
if ((!bVar3) && (0x13 < param_3)) {
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x102023);
return param_1;
}
}
else if (lVar1 == 4) {
if ((*(int *)*param_2 == 0x656e754a) && (0x14 < param_3)) {
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x102042);
}
}
else if (lVar1 == 9) {
if ((*(long *)*param_2 == 0x65626d6574706553) &&
((*(char *)((long *)*param_2 + 1) == 'r' && (0x15 < param_3)))) {
LAB_00101638:
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x10203b);
return param_1;
}
}
else if (lVar1 == 7) {
if ((*(int *)*param_2 == 0x6f74634f) && (*(int *)(*param_2 + 3) == 0x7265626f)) {
bVar3 = false;
}
else {
bVar3 = true;
}
if ((0x15 < param_3) && (!bVar3)) goto LAB_00101638;
}
else if (lVar1 == 8) {
if ((*(long *)*param_2 == 0x7265626d65766f4e) && (0x15 < param_3)) goto LAB_00101638;
if ((*(long *)*param_2 == 0x7265626d65636544) && (0x14 < param_3)) {
std::string::_M_replace((ulong)param_1,0,(char *)param_1[1],0x102012);
}
}
return param_1;
} |
636 | func0 |
#include <iostream>
#include <tuple>
#include <assert.h>
| std::tuple<std::string, int, std::string, int> func0(int a, int b, int n) {
int i = 0;
while (i * a <= n) {
if ((n - (i * a)) % b == 0) {
return std::make_tuple("x = ", i, ", y = ", (n - (i * a)) / b);
}
i++;
}
throw std::runtime_error("No solution");
}
| int main() {
try {
assert(func0(2, 3, 7) == std::make_tuple("x = ", 2, ", y = ", 1));
assert(func0(4, 2, 7) == std::make_tuple("x = ", 4, ", y = ", 1)); // Corrected wrong expected result
assert(func0(1, 13, 17) == std::make_tuple("x = ", 4, ", y = ", 1));
}
catch (std::runtime_error& e) {
assert(std::string(e.what()) == "No solution");
}
return 0;
}
| O0 | cpp | func0[abi:cxx11](int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x60,%rsp
mov %rdi,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %edx,-0x60(%rbp)
mov %ecx,-0x64(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x48(%rbp)
mov -0x48(%rbp),%eax
imul -0x5c(%rbp),%eax
cmp %eax,-0x64(%rbp)
jl 254f <_Z5func0B5cxx11iii+0xc6>
mov -0x48(%rbp),%eax
imul -0x5c(%rbp),%eax
mov -0x64(%rbp),%edx
sub %eax,%edx
mov %edx,%eax
cltd
idivl -0x60(%rbp)
mov %edx,%eax
test %eax,%eax
jne 2541 <_Z5func0B5cxx11iii+0xb8>
mov -0x48(%rbp),%eax
imul -0x5c(%rbp),%eax
mov -0x64(%rbp),%edx
sub %eax,%edx
mov %edx,%eax
cltd
idivl -0x60(%rbp)
mov %eax,-0x44(%rbp)
lea -0x40(%rbp),%rax
lea -0x44(%rbp),%rcx
lea -0x48(%rbp),%rdx
mov %rcx,%r8
lea 0x1afa(%rip),%rcx
lea 0x1afa(%rip),%rsi
mov %rax,%rdi
callq 2b71 <_ZSt10make_tupleIJRA5_KcRiRA7_S0_iEESt5tupleIJDpNSt17__decay_and_stripIT_E6__typeEEEDpOS8_>
lea -0x40(%rbp),%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2bf6 <_ZNSt5tupleIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiS5_iEEC1IJPKciS9_iEvLb1EEEOS_IJDpT_EE>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 25a3 <_Z5func0B5cxx11iii+0x11a>
jmp 259e <_Z5func0B5cxx11iii+0x115>
mov -0x48(%rbp),%eax
add $0x1,%eax
mov %eax,-0x48(%rbp)
jmpq 24bb <_Z5func0B5cxx11iii+0x32>
mov $0x10,%edi
callq 2230 <__cxa_allocate_exception@plt>
mov %rax,%rbx
lea 0x1ab1(%rip),%rsi
mov %rbx,%rdi
callq 2210 <_ZNSt13runtime_errorC1EPKc@plt>
mov 0x4a4e(%rip),%rax
mov %rax,%rdx
lea 0x4724(%rip),%rsi
mov %rbx,%rdi
callq 2350 <__cxa_throw@plt>
endbr64
mov %rax,%r12
mov %rbx,%rdi
callq 2280 <__cxa_free_exception@plt>
mov %r12,%rax
mov %rax,%rdi
callq 2360 <_Unwind_Resume@plt>
callq 2300 <__stack_chk_fail@plt>
mov -0x58(%rbp),%rax
add $0x60,%rsp
pop %rbx
pop %r12
pop %rbp
retq
| _Z5func0B5cxx11iii:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 60h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov [rbp+var_60], edx
mov [rbp+var_64], ecx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_48], 0
jmp loc_24E6
loc_2460:
mov eax, [rbp+var_48]
imul eax, [rbp+var_5C]
mov edx, [rbp+var_64]
sub edx, eax
mov eax, edx
cdq
idiv [rbp+var_60]
mov eax, edx
test eax, eax
jnz short loc_24DD
mov eax, [rbp+var_48]
imul eax, [rbp+var_5C]
mov edx, [rbp+var_64]
sub edx, eax
mov eax, edx
cdq
idiv [rbp+var_60]
mov [rbp+var_44], eax
lea rax, [rbp+var_40]
lea rcx, [rbp+var_44]
lea rdx, [rbp+var_48]
mov r8, rcx
lea rcx, aY; ", y = "
lea rsi, asc_400F; "x = "
mov rdi, rax
call _ZSt10make_tupleIJRA5_KcRiRA7_S0_iEESt5tupleIJDpNSt25__strip_reference_wrapperINSt5decayIT_E4typeEE6__typeEEEDpOS9_; std::make_tuple<char const(&)[5],int &,char const(&)[7],int>(char const(&)[5],int &,char const(&)[7],int&&)
lea rdx, [rbp+var_40]
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNSt5tupleIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiS5_iEEC2IJPKciS9_iELb1ELb1EEEOS_IJDpT_EE; std::tuple<std::string,int,std::string,int>::tuple<char const*,int,char const*,int,true,true>(std::tuple&&<char const*,int,char const*,int>)
mov rax, [rbp+var_18]
sub rax, fs:28h
jz loc_2578
jmp loc_2573
loc_24DD:
mov eax, [rbp+var_48]
add eax, 1
mov [rbp+var_48], eax
loc_24E6:
mov eax, [rbp+var_48]
imul eax, [rbp+var_5C]
cmp [rbp+var_64], eax
jge loc_2460
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rax, aNoSolution; "No solution"
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_2529
call ___stack_chk_fail
loc_2529:
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 r12, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rax, r12
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_256B
call ___stack_chk_fail
loc_256B:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_2573:
call ___stack_chk_fail
loc_2578:
mov rax, [rbp+var_58]
add rsp, 60h
pop rbx
pop r12
pop rbp
retn | long long func0[abi:cxx11](long long a1, int a2, int a3, int a4)
{
std::runtime_error *exception; // rbx
int i; // [rsp+28h] [rbp-48h] BYREF
int v7; // [rsp+2Ch] [rbp-44h] BYREF
_BYTE v8[40]; // [rsp+30h] [rbp-40h] BYREF
unsigned long long v9; // [rsp+58h] [rbp-18h]
v9 = __readfsqword(0x28u);
for ( i = 0; ; ++i )
{
if ( a4 < a2 * i )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "No solution");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !((a4 - a2 * i) % a3) )
break;
}
v7 = (a4 - a2 * i) / a3;
std::make_tuple<char const(&)[5],int &,char const(&)[7],int>(v8, "x = ", &i, ", y = ", &v7);
std::tuple<std::string,int,std::string,int>::tuple<char const*,int,char const*,int,true,true>(a1, v8);
return a1;
} | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x60
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV dword ptr [RBP + -0x60],EDX
MOV dword ptr [RBP + -0x64],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x48],0x0
JMP 0x001024e6
LAB_00102460:
MOV EAX,dword ptr [RBP + -0x48]
IMUL EAX,dword ptr [RBP + -0x5c]
MOV EDX,dword ptr [RBP + -0x64]
SUB EDX,EAX
MOV EAX,EDX
CDQ
IDIV dword ptr [RBP + -0x60]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x001024dd
MOV EAX,dword ptr [RBP + -0x48]
IMUL EAX,dword ptr [RBP + -0x5c]
MOV EDX,dword ptr [RBP + -0x64]
SUB EDX,EAX
MOV EAX,EDX
CDQ
IDIV dword ptr [RBP + -0x60]
MOV dword ptr [RBP + -0x44],EAX
LEA RAX,[RBP + -0x40]
LEA RCX,[RBP + -0x44]
LEA RDX,[RBP + -0x48]
MOV R8,RCX
LEA RCX,[0x104008]
LEA RSI,[0x10400f]
MOV RDI,RAX
LAB_001024ad:
CALL 0x00102bfc
LEA RDX,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102c82
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00102578
JMP 0x00102573
LAB_001024dd:
MOV EAX,dword ptr [RBP + -0x48]
ADD EAX,0x1
MOV dword ptr [RBP + -0x48],EAX
LAB_001024e6:
MOV EAX,dword ptr [RBP + -0x48]
IMUL EAX,dword ptr [RBP + -0x5c]
CMP dword ptr [RBP + -0x64],EAX
JGE 0x00102460
MOV EDI,0x10
CALL 0x00102200
MOV RBX,RAX
LEA RAX,[0x104014]
MOV RSI,RAX
MOV RDI,RBX
LAB_00102510:
CALL 0x001021c0
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00102529
CALL 0x001022c0
LAB_00102529:
MOV RAX,qword ptr [0x00106fe0]
MOV RDX,RAX
LEA RAX,[0x106cd0]
MOV RSI,RAX
MOV RDI,RBX
LAB_00102540:
CALL 0x00102300
LAB_00102573:
CALL 0x001022c0
LAB_00102578:
MOV RAX,qword ptr [RBP + -0x58]
ADD RSP,0x60
POP RBX
POP R12
POP RBP
RET | /* func0[abi:cxx11](int, int, int) */
tuple<std::string,int,std::string,int> * func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
runtime_error *this;
int in_ECX;
int4 in_register_0000003c;
long in_FS_OFFSET;
int local_50;
int local_4c;
tuple local_48 [10];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
for (local_50 = 0; local_50 * param_2 <= in_ECX; local_50 = local_50 + 1) {
if ((in_ECX - local_50 * param_2) % param_3 == 0) {
local_4c = (in_ECX - local_50 * param_2) / param_3;
std::make_tuple<char_const(&)[5],int&,char_const(&)[7],int>
((char *)local_48,(int *)&DAT_0010400f,(char *)&local_50,(int *)", y = ");
std::tuple<std::string,int,std::string,int>::tuple<char_const*,int,char_const*,int,true,true>
((tuple<std::string,int,std::string,int> *)CONCAT44(in_register_0000003c,param_1),
local_48);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (tuple<std::string,int,std::string,int> *)CONCAT44(in_register_0000003c,param_1);
}
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00102510 to 00102514 has its CatchHandler @ 00102545 */
std::runtime_error::runtime_error(this,"No solution");
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
/* WARNING: Subroutine does not return */
__cxa_throw(this,std::runtime_error::typeinfo,PTR__runtime_error_00106fe0);
} |
637 | func0 |
#include <iostream>
#include <tuple>
#include <assert.h>
| std::tuple<std::string, int, std::string, int> func0(int a, int b, int n) {
int i = 0;
while (i * a <= n) {
if ((n - (i * a)) % b == 0) {
return std::make_tuple("x = ", i, ", y = ", (n - (i * a)) / b);
}
i++;
}
throw std::runtime_error("No solution");
}
| int main() {
try {
assert(func0(2, 3, 7) == std::make_tuple("x = ", 2, ", y = ", 1));
assert(func0(4, 2, 7) == std::make_tuple("x = ", 4, ", y = ", 1)); // Corrected wrong expected result
assert(func0(1, 13, 17) == std::make_tuple("x = ", 4, ", y = ", 1));
}
catch (std::runtime_error& e) {
assert(std::string(e.what()) == "No solution");
}
return 0;
}
| O1 | cpp | func0[abi:cxx11](int, int, int):
endbr64
push %r12
push %rbp
push %rbx
test %ecx,%ecx
js 13de <_Z5func0B5cxx11iii+0xb5>
mov %rdi,%rbp
mov %edx,%r10d
mov %ecx,%eax
cltd
idiv %r10d
mov %edx,%ebx
test %edx,%edx
je 13bd <_Z5func0B5cxx11iii+0x94>
mov %esi,%r11d
mov %ecx,%r9d
sub %esi,%r9d
mov %esi,%r8d
mov $0x0,%ebx
add $0x1,%ebx
cmp %r8d,%ecx
jl 13de <_Z5func0B5cxx11iii+0xb5>
mov %r9d,%edi
add %r11d,%r8d
sub %esi,%r9d
mov %edi,%eax
cltd
idiv %r10d
test %edx,%edx
jne 135c <_Z5func0B5cxx11iii+0x33>
mov %edi,%eax
cltd
idiv %r10d
mov %eax,0x0(%rbp)
lea 0x8(%rbp),%rdi
lea 0x18(%rbp),%r12
mov %r12,0x8(%rbp)
lea 0xca5(%rip),%rdx
lea -0x6(%rdx),%rsi
callq 1780 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag>
mov %ebx,0x28(%rbp)
lea 0x30(%rbp),%rdi
lea 0x40(%rbp),%rax
mov %rax,0x30(%rbp)
lea 0xc8b(%rip),%rdx
lea -0x4(%rdx),%rsi
callq 1780 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag>
jmp 1427 <_Z5func0B5cxx11iii+0xfe>
mov %ecx,%edi
jmp 1377 <_Z5func0B5cxx11iii+0x4e>
endbr64
mov %rax,%rbx
mov 0x8(%rbp),%rdi
cmp %r12,%rdi
je 13d6 <_Z5func0B5cxx11iii+0xad>
callq 11d0 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1220 <_Unwind_Resume@plt>
mov $0x10,%edi
callq 1170 <__cxa_allocate_exception@plt>
mov %rax,%rbx
lea 0xc4c(%rip),%rsi
mov %rax,%rdi
callq 1150 <_ZNSt13runtime_errorC1EPKc@plt>
mov 0x2bc7(%rip),%rdx
lea 0x28f8(%rip),%rsi
mov %rbx,%rdi
callq 1210 <__cxa_throw@plt>
endbr64
mov %rax,%rbp
mov %rbx,%rdi
callq 11a0 <__cxa_free_exception@plt>
mov %rbp,%rdi
callq 1220 <_Unwind_Resume@plt>
mov %rbp,%rax
pop %rbx
pop %rbp
pop %r12
retq
| _Z5func0B5cxx11iii:
endbr64
push r12
push rbp
push rbx
test ecx, ecx
js loc_13B9
mov rbp, rdi
mov r10d, esi
mov r9d, edx
mov eax, ecx
cdq
idiv r9d
mov ebx, edx
test edx, edx
jz short loc_139E
mov r8d, ecx
sub r8d, esi
mov edi, esi
mov ebx, 0
loc_133B:
add ebx, 1
cmp ecx, edi
jl short loc_13B9
mov esi, r8d
add edi, r10d
sub r8d, r10d
mov eax, esi
cdq
idiv r9d
test edx, edx
jnz short loc_133B
loc_1355:
mov eax, esi
cdq
idiv r9d
mov [rbp+0], eax
lea r12, [rbp+8]
lea rax, [rbp+18h]
mov [rbp+8], rax
lea rdx, aY+6; ""
lea rsi, [rdx-6]
mov rdi, r12
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 [rbp+28h], ebx
lea rdi, [rbp+30h]
lea rax, [rbp+40h]
mov [rbp+30h], rax
lea rdx, asc_200B+4; ""
lea rsi, [rdx-4]
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)
jmp short loc_1402
loc_139E:
mov esi, ecx
jmp short loc_1355
endbr64
mov rbx, rax
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_13B9:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aNoSolution; "No solution"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
lea rsi, _ZTISt13runtime_error@GLIBCXX_3_4; lptinfo
mov rdi, rbx; void *
call ___cxa_throw
endbr64
mov rbp, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, rbp; struct _Unwind_Exception *
call __Unwind_Resume
loc_1402:
mov rax, rbp
pop rbx
pop rbp
pop r12
retn | long long func0[abi:cxx11](long long a1, int a2, int a3, int a4)
{
int v6; // ebx
int v7; // r8d
int v8; // edi
int v9; // esi
std::runtime_error *exception; // rbx
if ( a4 < 0 )
goto LABEL_8;
v6 = a4 % a3;
if ( a4 % a3 )
{
v7 = a4 - a2;
v8 = a2;
v6 = 0;
while ( 1 )
{
++v6;
if ( a4 < v8 )
break;
v9 = v7;
v8 += a2;
v7 -= a2;
if ( !(v9 % a3) )
goto LABEL_6;
}
LABEL_8:
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "No solution");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v9 = a4;
LABEL_6:
*(_DWORD *)a1 = v9 / a3;
*(_QWORD *)(a1 + 8) = a1 + 24;
std::string::_M_construct<char const*>(a1 + 8, ", y = ");
*(_DWORD *)(a1 + 40) = v6;
*(_QWORD *)(a1 + 48) = a1 + 64;
std::string::_M_construct<char const*>(a1 + 48, "x = ");
return a1;
} | func0[abi:cxx11]:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
TEST ECX,ECX
JS 0x001013b9
MOV RBP,RDI
MOV R10D,ESI
MOV R9D,EDX
MOV EAX,ECX
CDQ
IDIV R9D
MOV EBX,EDX
TEST EDX,EDX
JZ 0x0010139e
MOV R8D,ECX
SUB R8D,ESI
MOV EDI,ESI
MOV EBX,0x0
LAB_0010133b:
ADD EBX,0x1
CMP ECX,EDI
JL 0x001013b9
MOV ESI,R8D
ADD EDI,R10D
SUB R8D,R10D
MOV EAX,ESI
CDQ
IDIV R9D
TEST EDX,EDX
JNZ 0x0010133b
LAB_00101355:
MOV EAX,ESI
CDQ
IDIV R9D
MOV dword ptr [RBP],EAX
LEA R12,[RBP + 0x8]
LEA RAX,[RBP + 0x18]
MOV qword ptr [RBP + 0x8],RAX
LEA RDX,[0x10200a]
LEA RSI,[RDX + -0x6]
MOV RDI,R12
LAB_00101378:
CALL 0x001016d8
MOV dword ptr [RBP + 0x28],EBX
LEA RDI,[RBP + 0x30]
LEA RAX,[RBP + 0x40]
MOV qword ptr [RBP + 0x30],RAX
LEA RDX,[0x10200f]
LEA RSI,[RDX + -0x4]
LAB_00101397:
CALL 0x001016d8
JMP 0x00101402
LAB_0010139e:
MOV ESI,ECX
JMP 0x00101355
LAB_001013b9:
MOV EDI,0x10
CALL 0x00101170
MOV RBX,RAX
LEA RSI,[0x102010]
MOV RDI,RAX
LAB_001013d0:
CALL 0x00101130
MOV RDX,qword ptr [0x00103fe0]
LEA RSI,[0x103d18]
MOV RDI,RBX
LAB_001013e6:
CALL 0x001011f0
LAB_00101402:
MOV RAX,RBP
POP RBX
POP RBP
POP R12
RET | /* func0[abi:cxx11](int, int, int) */
int * func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
int iVar1;
runtime_error *this;
int in_ECX;
int iVar2;
int iVar3;
int iVar4;
int4 in_register_0000003c;
int *piVar5;
piVar5 = (int *)CONCAT44(in_register_0000003c,param_1);
if (-1 < in_ECX) {
if (in_ECX % param_3 == 0) {
iVar2 = 0;
iVar3 = in_ECX;
}
else {
iVar2 = 0;
iVar1 = in_ECX - param_2;
iVar4 = param_2;
do {
iVar3 = iVar1;
iVar2 = iVar2 + 1;
if (in_ECX < iVar4) goto LAB_001013b9;
iVar4 = iVar4 + param_2;
iVar1 = iVar3 - param_2;
} while (iVar3 % param_3 != 0);
}
*piVar5 = iVar3 / param_3;
*(int **)(piVar5 + 2) = piVar5 + 6;
std::string::_M_construct<char_const*>((char *)(piVar5 + 2),", y = ",0x10200a);
piVar5[10] = iVar2;
*(int **)(piVar5 + 0xc) = piVar5 + 0x10;
/* try { // try from 00101397 to 0010139b has its CatchHandler @ 001013a2 */
std::string::_M_construct<char_const*>((char *)(piVar5 + 0xc),"x = ",0x10200f);
return piVar5;
}
LAB_001013b9:
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001013d0 to 001013d4 has its CatchHandler @ 001013eb */
std::runtime_error::runtime_error(this,"No solution");
/* WARNING: Subroutine does not return */
__cxa_throw(this,std::runtime_error::typeinfo,PTR__runtime_error_00103fe0);
} |
638 | func0 |
#include <iostream>
#include <tuple>
#include <assert.h>
| std::tuple<std::string, int, std::string, int> func0(int a, int b, int n) {
int i = 0;
while (i * a <= n) {
if ((n - (i * a)) % b == 0) {
return std::make_tuple("x = ", i, ", y = ", (n - (i * a)) / b);
}
i++;
}
throw std::runtime_error("No solution");
}
| int main() {
try {
assert(func0(2, 3, 7) == std::make_tuple("x = ", 2, ", y = ", 1));
assert(func0(4, 2, 7) == std::make_tuple("x = ", 4, ", y = ", 1)); // Corrected wrong expected result
assert(func0(1, 13, 17) == std::make_tuple("x = ", 4, ", y = ", 1));
}
catch (std::runtime_error& e) {
assert(std::string(e.what()) == "No solution");
}
return 0;
}
| O2 | cpp | func0[abi:cxx11](int, int, int):
endbr64
push %r12
push %rbp
push %rbx
test %ecx,%ecx
js 1260 <_Z5func0B5cxx11iii.cold>
mov %ecx,%eax
mov %edx,%r11d
mov %rdi,%r12
cltd
idiv %r11d
mov %edx,%ebx
test %edx,%edx
je 16f0 <_Z5func0B5cxx11iii+0xc0>
mov %ecx,%r10d
mov %esi,%r9d
xor %ebx,%ebx
sub %esi,%r10d
nopl 0x0(%rax)
add $0x1,%ebx
cmp %r9d,%ecx
jl 1260 <_Z5func0B5cxx11iii.cold>
mov %r10d,%r8d
add %esi,%r9d
sub %esi,%r10d
mov %r8d,%eax
cltd
idiv %r11d
test %edx,%edx
jne 1668 <_Z5func0B5cxx11iii+0x38>
mov %r8d,%eax
movb $0x0,0x1e(%r12)
cltd
mov %ebx,0x28(%r12)
idiv %r11d
movb $0x0,0x44(%r12)
movl $0x2079202c,0x18(%r12)
movq $0x6,0x10(%r12)
movl $0x203d2078,0x40(%r12)
movq $0x4,0x38(%r12)
mov %eax,(%r12)
lea 0x18(%r12),%rax
mov %rax,0x8(%r12)
mov $0x203d,%eax
mov %ax,0x1c(%r12)
lea 0x40(%r12),%rax
mov %rax,0x30(%r12)
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
mov %ecx,%r8d
jmp 1688 <_Z5func0B5cxx11iii+0x58>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0B5cxx11iii:
endbr64
push r12
push rbp
push rbx
test ecx, ecx
js _Z5func0B5cxx11iii_cold; func0(int,int,int) [clone]
mov eax, ecx
mov r9d, edx
mov rbx, rdi
cdq
idiv r9d
mov ebp, edx
test edx, edx
jz short loc_17E0
mov r8d, ecx
mov r10d, esi
mov edi, esi
xor ebp, ebp
sub r8d, esi
nop
loc_1770:
add ebp, 1
cmp ecx, edi
jl _Z5func0B5cxx11iii_cold; func0(int,int,int) [clone]
mov esi, r8d
add edi, r10d
sub r8d, r10d
mov eax, esi
cdq
idiv r9d
test edx, edx
jnz short loc_1770
loc_178E:
mov eax, esi
lea r12, [rbx+8]
cdq
mov rdi, r12
idiv r9d
lea rdx, aY+6; ""
lea rsi, [rdx-6]
mov [rbx], eax
lea rax, [rbx+18h]
mov [rbx+8], 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, [rbx+40h]
mov [rbx+28h], ebp
lea rdi, [rbx+30h]
mov [rbx+30h], rax
lea rdx, asc_200B+4; ""
lea rsi, [rdx-4]
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 rax, rbx
pop rbx
pop rbp
pop r12
retn
loc_17E0:
mov esi, ecx
jmp short loc_178E
endbr64
mov rbx, rax
jmp loc_1252 | long long func0[abi:cxx11](long long a1, int a2, int a3, int a4)
{
int v5; // ebp
int v7; // edi
int v8; // r8d
int v9; // esi
if ( a4 < 0 )
goto LABEL_8;
v5 = a4 % a3;
if ( a4 % a3 )
{
v7 = a2;
v5 = 0;
v8 = a4 - a2;
while ( 1 )
{
++v5;
if ( a4 < v7 )
break;
v9 = v8;
v7 += a2;
v8 -= a2;
if ( !(v9 % a3) )
goto LABEL_6;
}
LABEL_8:
func0[abi:cxx11]();
}
v9 = a4;
LABEL_6:
*(_DWORD *)a1 = v9 / a3;
*(_QWORD *)(a1 + 8) = a1 + 24;
std::string::_M_construct<char const*>(a1 + 8, ", y = ");
*(_DWORD *)(a1 + 40) = v5;
*(_QWORD *)(a1 + 48) = a1 + 64;
std::string::_M_construct<char const*>(a1 + 48, "x = ");
return a1;
} | func0[abi:cxx11]:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
TEST ECX,ECX
JS 0x00101220
MOV EAX,ECX
MOV R9D,EDX
MOV RBX,RDI
CDQ
IDIV R9D
MOV EBP,EDX
TEST EDX,EDX
JZ 0x001017e0
MOV R8D,ECX
MOV R10D,ESI
MOV EDI,ESI
XOR EBP,EBP
SUB R8D,ESI
NOP
LAB_00101770:
ADD EBP,0x1
CMP ECX,EDI
JL 0x00101220
MOV ESI,R8D
ADD EDI,R10D
SUB R8D,R10D
MOV EAX,ESI
CDQ
IDIV R9D
TEST EDX,EDX
JNZ 0x00101770
LAB_0010178e:
MOV EAX,ESI
LEA R12,[RBX + 0x8]
CDQ
MOV RDI,R12
IDIV R9D
LEA RDX,[0x10200a]
LEA RSI,[RDX + -0x6]
MOV dword ptr [RBX],EAX
LEA RAX,[RBX + 0x18]
MOV qword ptr [RBX + 0x8],RAX
LAB_001017b0:
CALL 0x00101690
LEA RAX,[RBX + 0x40]
MOV dword ptr [RBX + 0x28],EBP
LEA RDI,[RBX + 0x30]
MOV qword ptr [RBX + 0x30],RAX
LEA RDX,[0x10200f]
LEA RSI,[RDX + -0x4]
LAB_001017cf:
CALL 0x00101690
MOV RAX,RBX
POP RBX
POP RBP
POP R12
RET
LAB_001017e0:
MOV ESI,ECX
JMP 0x0010178e | /* func0[abi:cxx11](int, int, int) */
int * func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
int iVar1;
runtime_error *this;
int in_ECX;
int iVar2;
int iVar3;
int iVar4;
int4 in_register_0000003c;
int *piVar5;
piVar5 = (int *)CONCAT44(in_register_0000003c,param_1);
if (-1 < in_ECX) {
if (in_ECX % param_3 == 0) {
iVar2 = 0;
iVar3 = in_ECX;
}
else {
iVar2 = 0;
iVar4 = param_2;
iVar1 = in_ECX - param_2;
do {
iVar3 = iVar1;
iVar2 = iVar2 + 1;
if (in_ECX < iVar4) goto func0_abi_cxx11_;
iVar4 = iVar4 + param_2;
iVar1 = iVar3 - param_2;
} while (iVar3 % param_3 != 0);
}
*piVar5 = iVar3 / param_3;
*(int **)(piVar5 + 2) = piVar5 + 6;
std::string::_M_construct<char_const*>((char *)(piVar5 + 2),", y = ",0x10200a);
piVar5[10] = iVar2;
*(int **)(piVar5 + 0xc) = piVar5 + 0x10;
/* try { // try from 001017cf to 001017d3 has its CatchHandler @ 001017e4 */
std::string::_M_construct<char_const*>((char *)(piVar5 + 0xc),"x = ",0x10200f);
return piVar5;
}
func0_abi_cxx11_:
this = (runtime_error *)__cxa_allocate_exception(0x10);
std::runtime_error::runtime_error(this,"No solution");
/* WARNING: Subroutine does not return */
__cxa_throw(this,std::runtime_error::typeinfo,PTR__runtime_error_00103fe0);
} |
639 | func0 |
#include <iostream>
#include <tuple>
#include <assert.h>
| std::tuple<std::string, int, std::string, int> func0(int a, int b, int n) {
int i = 0;
while (i * a <= n) {
if ((n - (i * a)) % b == 0) {
return std::make_tuple("x = ", i, ", y = ", (n - (i * a)) / b);
}
i++;
}
throw std::runtime_error("No solution");
}
| int main() {
try {
assert(func0(2, 3, 7) == std::make_tuple("x = ", 2, ", y = ", 1));
assert(func0(4, 2, 7) == std::make_tuple("x = ", 4, ", y = ", 1)); // Corrected wrong expected result
assert(func0(1, 13, 17) == std::make_tuple("x = ", 4, ", y = ", 1));
}
catch (std::runtime_error& e) {
assert(std::string(e.what()) == "No solution");
}
return 0;
}
| O3 | cpp | func0[abi:cxx11](int, int, int):
endbr64
push %r12
push %rbp
push %rbx
test %ecx,%ecx
js 1260 <_Z5func0B5cxx11iii.cold>
mov %ecx,%eax
mov %edx,%r11d
mov %rdi,%r12
cltd
idiv %r11d
mov %edx,%ebx
test %edx,%edx
je 16f0 <_Z5func0B5cxx11iii+0xc0>
mov %ecx,%r10d
mov %esi,%r9d
xor %ebx,%ebx
sub %esi,%r10d
nopl 0x0(%rax)
add $0x1,%ebx
cmp %r9d,%ecx
jl 1260 <_Z5func0B5cxx11iii.cold>
mov %r10d,%r8d
add %esi,%r9d
sub %esi,%r10d
mov %r8d,%eax
cltd
idiv %r11d
test %edx,%edx
jne 1668 <_Z5func0B5cxx11iii+0x38>
mov %r8d,%eax
movb $0x0,0x1e(%r12)
cltd
mov %ebx,0x28(%r12)
idiv %r11d
movb $0x0,0x44(%r12)
movl $0x2079202c,0x18(%r12)
movq $0x6,0x10(%r12)
movl $0x203d2078,0x40(%r12)
movq $0x4,0x38(%r12)
mov %eax,(%r12)
lea 0x18(%r12),%rax
mov %rax,0x8(%r12)
mov $0x203d,%eax
mov %ax,0x1c(%r12)
lea 0x40(%r12),%rax
mov %rax,0x30(%r12)
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
mov %ecx,%r8d
jmp 1688 <_Z5func0B5cxx11iii+0x58>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0B5cxx11iii:
endbr64
push rbp
push rbx
sub rsp, 8
test ecx, ecx
js _Z5func0B5cxx11iii_cold; func0(int,int,int) [clone]
mov eax, ecx
mov r9d, edx
mov rbx, rdi
cdq
idiv r9d
mov r11d, edx
test edx, edx
jz loc_1738
mov r8d, ecx
mov r10d, esi
mov edi, esi
xor r11d, r11d
sub r8d, esi
nop word ptr [rax+rax+00000000h]
loc_16C0:
add r11d, 1
cmp ecx, edi
jl _Z5func0B5cxx11iii_cold; func0(int,int,int) [clone]
mov esi, r8d
add edi, r10d
sub r8d, r10d
mov eax, esi
cdq
idiv r9d
test edx, edx
jnz short loc_16C0
loc_16DF:
mov eax, esi
mov dword ptr [rbx+18h], 2079202Ch
cdq
mov qword ptr [rbx+10h], 6
idiv r9d
mov byte ptr [rbx+1Eh], 0
mov [rbx+28h], r11d
mov dword ptr [rbx+40h], 203D2078h
mov qword ptr [rbx+38h], 4
mov byte ptr [rbx+44h], 0
mov [rbx], eax
lea rax, [rbx+18h]
mov [rbx+8], rax
mov eax, 203Dh
mov [rbx+1Ch], ax
lea rax, [rbx+40h]
mov [rbx+30h], rax
add rsp, 8
mov rax, rbx
pop rbx
pop rbp
retn
loc_1738:
mov esi, ecx
jmp short loc_16DF | long long func0[abi:cxx11](long long a1, int a2, int a3, int a4)
{
int v5; // r11d
int v7; // edi
int v8; // r8d
int v9; // esi
if ( a4 < 0 )
goto LABEL_8;
v5 = a4 % a3;
if ( a4 % a3 )
{
v7 = a2;
v5 = 0;
v8 = a4 - a2;
while ( 1 )
{
++v5;
if ( a4 < v7 )
break;
v9 = v8;
v7 += a2;
v8 -= a2;
if ( !(v9 % a3) )
goto LABEL_6;
}
LABEL_8:
func0[abi:cxx11]();
}
v9 = a4;
LABEL_6:
strcpy((char *)(a1 + 24), ", y = ");
*(_QWORD *)(a1 + 16) = 6LL;
*(_DWORD *)(a1 + 40) = v5;
strcpy((char *)(a1 + 64), "x = ");
*(_QWORD *)(a1 + 56) = 4LL;
*(_DWORD *)a1 = v9 / a3;
*(_QWORD *)(a1 + 8) = a1 + 24;
*(_QWORD *)(a1 + 48) = a1 + 64;
return a1;
} | func0[abi:cxx11]:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
TEST ECX,ECX
JS 0x00101220
MOV EAX,ECX
MOV R9D,EDX
MOV RBX,RDI
CDQ
IDIV R9D
MOV R11D,EDX
TEST EDX,EDX
JZ 0x00101738
MOV R8D,ECX
MOV R10D,ESI
MOV EDI,ESI
XOR R11D,R11D
SUB R8D,ESI
NOP word ptr [RAX + RAX*0x1]
LAB_001016c0:
ADD R11D,0x1
CMP ECX,EDI
JL 0x00101220
MOV ESI,R8D
ADD EDI,R10D
SUB R8D,R10D
MOV EAX,ESI
CDQ
IDIV R9D
TEST EDX,EDX
JNZ 0x001016c0
LAB_001016df:
MOV EAX,ESI
MOV dword ptr [RBX + 0x18],0x2079202c
CDQ
MOV qword ptr [RBX + 0x10],0x6
IDIV R9D
MOV byte ptr [RBX + 0x1e],0x0
MOV dword ptr [RBX + 0x28],R11D
MOV dword ptr [RBX + 0x40],0x203d2078
MOV qword ptr [RBX + 0x38],0x4
MOV byte ptr [RBX + 0x44],0x0
MOV dword ptr [RBX],EAX
LEA RAX,[RBX + 0x18]
MOV qword ptr [RBX + 0x8],RAX
MOV EAX,0x203d
MOV word ptr [RBX + 0x1c],AX
LEA RAX,[RBX + 0x40]
MOV qword ptr [RBX + 0x30],RAX
ADD RSP,0x8
MOV RAX,RBX
POP RBX
POP RBP
RET
LAB_00101738:
MOV ESI,ECX
JMP 0x001016df | /* func0[abi:cxx11](int, int, int) */
int [16] func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
int iVar1;
runtime_error *this;
int in_ECX;
int iVar2;
int iVar3;
int4 in_register_0000003c;
int *piVar4;
int iVar5;
int auVar6 [16];
piVar4 = (int *)CONCAT44(in_register_0000003c,param_1);
if (-1 < in_ECX) {
if (in_ECX % param_3 == 0) {
iVar5 = 0;
iVar2 = in_ECX;
}
else {
iVar5 = 0;
iVar3 = param_2;
iVar1 = in_ECX - param_2;
do {
iVar2 = iVar1;
iVar5 = iVar5 + 1;
if (in_ECX < iVar3) goto func0_abi_cxx11_;
iVar3 = iVar3 + param_2;
iVar1 = iVar2 - param_2;
} while (iVar2 % param_3 != 0);
}
piVar4[6] = 0x2079202c;
piVar4[4] = 6;
piVar4[5] = 0;
auVar6._8_8_ = (long)iVar2 % (long)param_3 & 0xffffffff;
*(int *)((long)piVar4 + 0x1e) = 0;
piVar4[10] = iVar5;
piVar4[0x10] = 0x203d2078;
piVar4[0xe] = 4;
piVar4[0xf] = 0;
*(int *)(piVar4 + 0x11) = 0;
*piVar4 = iVar2 / param_3;
*(int **)(piVar4 + 2) = piVar4 + 6;
*(int2 *)(piVar4 + 7) = 0x203d;
*(int **)(piVar4 + 0xc) = piVar4 + 0x10;
auVar6._0_8_ = piVar4;
return auVar6;
}
func0_abi_cxx11_:
this = (runtime_error *)__cxa_allocate_exception(0x10);
std::runtime_error::runtime_error(this,"No solution");
/* WARNING: Subroutine does not return */
__cxa_throw(this,std::runtime_error::typeinfo,PTR__runtime_error_00103fe0);
} |
640 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> list1, std::vector<int> list2) {
std::vector<int> result;
for (int x : list1) {
bool found = false;
for (int y : list2) {
if (x == y) {
found = true;
break;
}
}
if (!found) {
result.push_back(x);
}
}
return result;
}
| int main() {
assert((func0({1,2,3,4,5,6,7,8,9,10}, {2,4,6,8}) == std::vector<int>{1, 3, 5, 7, 9, 10}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 3, 5, 7}) == std::vector<int>{2, 4, 6, 8, 9, 10}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {5,7}) == std::vector<int>{1, 2, 3, 4, 6, 8, 9, 10}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %rdx,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x68(%rbp),%rax
mov %rax,%rdi
callq 1d4c <_ZNSt6vectorIiSaIiEEC1Ev>
mov -0x70(%rbp),%rax
mov %rax,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1e52 <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x48(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1e9e <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,-0x40(%rbp)
lea -0x40(%rbp),%rdx
lea -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1eee <_ZN9__gnu_cxxneIPiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESA_>
test %al,%al
je 138e <_Z5func0St6vectorIiSaIiEES1_+0x145>
lea -0x48(%rbp),%rax
mov %rax,%rdi
callq 1f52 <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%eax
mov %eax,-0x50(%rbp)
movb $0x0,-0x51(%rbp)
mov -0x78(%rbp),%rax
mov %rax,-0x20(%rbp)
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1e52 <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x38(%rbp)
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1e9e <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,-0x30(%rbp)
lea -0x30(%rbp),%rdx
lea -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1eee <_ZN9__gnu_cxxneIPiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESA_>
test %al,%al
je 1341 <_Z5func0St6vectorIiSaIiEES1_+0xf8>
lea -0x38(%rbp),%rax
mov %rax,%rdi
callq 1f52 <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%eax
mov %eax,-0x4c(%rbp)
mov -0x50(%rbp),%eax
cmp %eax,-0x4c(%rbp)
jne 1333 <_Z5func0St6vectorIiSaIiEES1_+0xea>
movb $0x1,-0x51(%rbp)
jmp 1341 <_Z5func0St6vectorIiSaIiEES1_+0xf8>
lea -0x38(%rbp),%rax
mov %rax,%rdi
callq 1f2e <_ZN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEppEv>
jmp 12fd <_Z5func0St6vectorIiSaIiEES1_+0xb4>
movzbl -0x51(%rbp),%eax
xor $0x1,%eax
test %al,%al
je 135f <_Z5func0St6vectorIiSaIiEES1_+0x116>
lea -0x50(%rbp),%rdx
mov -0x68(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1f68 <_ZNSt6vectorIiSaIiEE9push_backERKi>
lea -0x48(%rbp),%rax
mov %rax,%rdi
callq 1f2e <_ZN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEppEv>
jmpq 12a5 <_Z5func0St6vectorIiSaIiEES1_+0x5c>
endbr64
mov %rax,%rbx
mov -0x68(%rbp),%rax
mov %rax,%rdi
callq 1e0a <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1150 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 13a3 <_Z5func0St6vectorIiSaIiEES1_+0x15a>
callq 1130 <__stack_chk_fail@plt>
mov -0x68(%rbp),%rax
add $0x78,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0St6vectorIiSaIiEES1_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_78], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_68]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rax, [rbp+var_70]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rbp+var_40], rax
jmp loc_1375
loc_12CA:
lea rax, [rbp+var_48]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(void)
mov eax, [rax]
mov [rbp+var_50], eax
mov [rbp+var_51], 0
mov rax, [rbp+var_78]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rbp+var_30], rax
jmp short loc_1334
loc_1309:
lea rax, [rbp+var_38]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(void)
mov eax, [rax]
mov [rbp+var_4C], eax
mov eax, [rbp+var_50]
cmp [rbp+var_4C], eax
jnz short loc_1328
mov [rbp+var_51], 1
jmp short loc_134B
loc_1328:
lea rax, [rbp+var_38]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEppEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(void)
loc_1334:
lea rdx, [rbp+var_30]
lea rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESA_; __gnu_cxx::operator!=<int *,std::vector<int>>(__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&,__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&)
test al, al
jnz short loc_1309
loc_134B:
movzx eax, [rbp+var_51]
xor eax, 1
test al, al
jz short loc_1369
lea rdx, [rbp+var_50]
mov rax, [rbp+var_68]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
loc_1369:
lea rax, [rbp+var_48]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEppEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(void)
loc_1375:
lea rdx, [rbp+var_40]
lea rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESA_; __gnu_cxx::operator!=<int *,std::vector<int>>(__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&,__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&)
test al, al
jnz loc_12CA
jmp short loc_13C4
endbr64
mov rbx, rax
mov rax, [rbp+var_68]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_13BC
call ___stack_chk_fail
loc_13BC:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_13C4:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_13D8
call ___stack_chk_fail
loc_13D8:
mov rax, [rbp+var_68]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, long long a3)
{
char v5; // [rsp+2Fh] [rbp-51h]
int v6; // [rsp+30h] [rbp-50h] BYREF
int v7; // [rsp+34h] [rbp-4Ch]
long long v8; // [rsp+38h] [rbp-48h] BYREF
long long v9; // [rsp+40h] [rbp-40h] BYREF
long long v10; // [rsp+48h] [rbp-38h] BYREF
_QWORD v11[2]; // [rsp+50h] [rbp-30h] BYREF
long long v12; // [rsp+60h] [rbp-20h]
unsigned long long v13; // [rsp+68h] [rbp-18h]
v13 = __readfsqword(0x28u);
std::vector<int>::vector(a1);
v11[1] = a2;
v8 = std::vector<int>::begin(a2);
v9 = std::vector<int>::end(a2);
while ( (unsigned __int8)__gnu_cxx::operator!=<int *,std::vector<int>>(&v8, &v9) )
{
v6 = *(_DWORD *)__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(&v8);
v5 = 0;
v12 = a3;
v10 = std::vector<int>::begin(a3);
v11[0] = std::vector<int>::end(v12);
while ( (unsigned __int8)__gnu_cxx::operator!=<int *,std::vector<int>>(&v10, v11) )
{
v7 = *(_DWORD *)__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(&v10);
if ( v7 == v6 )
{
v5 = 1;
break;
}
__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(&v10);
}
if ( v5 != 1 )
std::vector<int>::push_back(a1, &v6);
__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(&v8);
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x78],RDX
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 0x00101dea
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101ee8
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101f34
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00101375
LAB_001012ca:
LEA RAX,[RBP + -0x48]
MOV RDI,RAX
CALL 0x00101fe8
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x50],EAX
MOV byte ptr [RBP + -0x51],0x0
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101ee8
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101f34
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00101334
LAB_00101309:
LEA RAX,[RBP + -0x38]
MOV RDI,RAX
CALL 0x00101fe8
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4c],EAX
MOV EAX,dword ptr [RBP + -0x50]
CMP dword ptr [RBP + -0x4c],EAX
JNZ 0x00101328
MOV byte ptr [RBP + -0x51],0x1
JMP 0x0010134b
LAB_00101328:
LEA RAX,[RBP + -0x38]
MOV RDI,RAX
CALL 0x00101fc4
LAB_00101334:
LEA RDX,[RBP + -0x30]
LEA RAX,[RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101f84
TEST AL,AL
JNZ 0x00101309
LAB_0010134b:
MOVZX EAX,byte ptr [RBP + -0x51]
XOR EAX,0x1
TEST AL,AL
JZ 0x00101369
LEA RDX,[RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x68]
MOV RSI,RDX
MOV RDI,RAX
LAB_00101364:
CALL 0x00101ffe
LAB_00101369:
LEA RAX,[RBP + -0x48]
MOV RDI,RAX
CALL 0x00101fc4
LAB_00101375:
LEA RDX,[RBP + -0x40]
LEA RAX,[RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101f84
TEST AL,AL
JNZ 0x001012ca
JMP 0x001013c4
LAB_001013c4:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001013d8
CALL 0x00101150
LAB_001013d8:
MOV RAX,qword ptr [RBP + -0x68]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1,vector param_2)
{
bool bVar1;
bool bVar2;
int *piVar3;
vector<int,std::allocator<int>> *in_RDX;
int4 in_register_00000034;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_58;
int local_54;
int8 local_50;
int8 local_48;
int8 local_40;
int8 local_38;
vector<int,std::allocator<int>> *local_30;
vector<int,std::allocator<int>> *local_28;
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);
local_30 = (vector<int,std::allocator<int>> *)CONCAT44(in_register_00000034,param_2);
local_50 = std::vector<int,std::allocator<int>>::begin
((vector<int,std::allocator<int>> *)CONCAT44(in_register_00000034,param_2));
local_48 = std::vector<int,std::allocator<int>>::end(local_30);
do {
bVar2 = operator!=((__normal_iterator *)&local_50,(__normal_iterator *)&local_48);
if (!bVar2) {
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return this;
}
piVar3 = (int *)__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)
&local_50);
local_58 = *piVar3;
bVar2 = false;
local_28 = in_RDX;
local_40 = std::vector<int,std::allocator<int>>::begin(in_RDX);
local_38 = std::vector<int,std::allocator<int>>::end(local_28);
while( true ) {
bVar1 = operator!=((__normal_iterator *)&local_40,(__normal_iterator *)&local_38);
if (!bVar1) break;
piVar3 = (int *)__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)
&local_40);
local_54 = *piVar3;
if (local_54 == local_58) {
bVar2 = true;
break;
}
__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator++
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)&local_40);
}
if (!bVar2) {
/* try { // try from 00101364 to 00101368 has its CatchHandler @ 00101392 */
std::vector<int,std::allocator<int>>::push_back(this,&local_58);
}
__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator++
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)&local_50);
} while( true );
} |
641 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> list1, std::vector<int> list2) {
std::vector<int> result;
for (int x : list1) {
bool found = false;
for (int y : list2) {
if (x == y) {
found = true;
break;
}
}
if (!found) {
result.push_back(x);
}
}
return result;
}
| int main() {
assert((func0({1,2,3,4,5,6,7,8,9,10}, {2,4,6,8}) == std::vector<int>{1, 3, 5, 7, 9, 10}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 3, 5, 7}) == std::vector<int>{2, 4, 6, 8, 9, 10}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {5,7}) == std::vector<int>{1, 2, 3, 4, 6, 8, 9, 10}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%r12
mov %fs:0x28,%rax
mov %rax,0x8(%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 1300 <_Z5func0St6vectorIiSaIiEES1_+0xb7>
mov %rdx,%rbp
lea 0x4(%rsp),%r14
jmp 12aa <_Z5func0St6vectorIiSaIiEES1_+0x61>
mov %edx,(%rsi)
addq $0x4,0x8(%r12)
add $0x4,%rbx
cmp %rbx,%r13
je 1300 <_Z5func0St6vectorIiSaIiEES1_+0xb7>
mov (%rbx),%edx
mov %edx,0x4(%rsp)
mov 0x0(%rbp),%rax
mov 0x8(%rbp),%rcx
cmp %rax,%rcx
je 12ca <_Z5func0St6vectorIiSaIiEES1_+0x81>
cmp (%rax),%edx
je 12a1 <_Z5func0St6vectorIiSaIiEES1_+0x58>
add $0x4,%rax
cmp %rax,%rcx
jne 12bd <_Z5func0St6vectorIiSaIiEES1_+0x74>
mov 0x8(%r12),%rsi
cmp 0x10(%r12),%rsi
jne 1299 <_Z5func0St6vectorIiSaIiEES1_+0x50>
mov %r14,%rdx
mov %r12,%rdi
callq 1a78 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmp 12a1 <_Z5func0St6vectorIiSaIiEES1_+0x58>
endbr64
mov %rax,%rbx
mov (%r12),%rdi
test %rdi,%rdi
je 12f8 <_Z5func0St6vectorIiSaIiEES1_+0xaf>
callq 1110 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1150 <_Unwind_Resume@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1320 <_Z5func0St6vectorIiSaIiEES1_+0xd7>
mov %r12,%rax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
| _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r12, rdi
mov rbp, 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 rbx, [rsi]
mov r13, [rsi+8]
cmp r13, rbx
jnz short loc_12C8
loc_1290:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz loc_132A
mov rax, r12
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_12B2:
lea rdx, [rsp+38h+var_34]
mov rdi, r12
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_12BF:
add rbx, 4
cmp r13, rbx
jz short loc_1290
loc_12C8:
mov edx, [rbx]
mov [rsp+38h+var_34], edx
mov rax, [rbp+0]
mov rcx, [rbp+8]
cmp rax, rcx
jz short loc_12E8
loc_12DB:
cmp edx, [rax]
jz short loc_12BF
add rax, 4
cmp rcx, rax
jnz short loc_12DB
loc_12E8:
mov rsi, [r12+8]
cmp rsi, [r12+10h]
jz short loc_12B2
mov [rsi], edx
add qword ptr [r12+8], 4
jmp short loc_12BF
endbr64
mov rbx, rax
mov rdi, r12
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+arg_0]
sub rax, fs:28h
jz short loc_1322
call ___stack_chk_fail
loc_1322:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_132A:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, int **a2, long long a3)
{
int *v4; // rbx
int *v5; // r13
int v7; // edx
_DWORD *v8; // rax
_DWORD *v9; // rcx
_DWORD *v10; // rsi
int v11; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v12; // [rsp+8h] [rbp-30h]
v12 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v4 = *a2;
v5 = a2[1];
if ( v5 != *a2 )
{
do
{
v7 = *v4;
v11 = *v4;
v8 = *(_DWORD **)a3;
v9 = *(_DWORD **)(a3 + 8);
if ( *(_DWORD **)a3 == v9 )
{
LABEL_8:
v10 = (_DWORD *)a1[1];
if ( v10 == (_DWORD *)a1[2] )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v10, &v11);
}
else
{
*v10 = v7;
a1[1] += 4LL;
}
}
else
{
while ( v7 != *v8 )
{
if ( v9 == ++v8 )
goto LABEL_8;
}
}
++v4;
}
while ( v5 != v4 );
}
return a1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV RBP,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 RBX,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
CMP R13,RBX
JNZ 0x001012c8
LAB_00101290:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010132a
MOV RAX,R12
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001012b2:
LEA RDX,[RSP + 0x4]
MOV RDI,R12
LAB_001012ba:
CALL 0x00101aa0
LAB_001012bf:
ADD RBX,0x4
CMP R13,RBX
JZ 0x00101290
LAB_001012c8:
MOV EDX,dword ptr [RBX]
MOV dword ptr [RSP + 0x4],EDX
MOV RAX,qword ptr [RBP]
MOV RCX,qword ptr [RBP + 0x8]
CMP RAX,RCX
JZ 0x001012e8
LAB_001012db:
CMP EDX,dword ptr [RAX]
JZ 0x001012bf
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x001012db
LAB_001012e8:
MOV RSI,qword ptr [R12 + 0x8]
CMP RSI,qword ptr [R12 + 0x10]
JZ 0x001012b2
MOV dword ptr [RSI],EDX
ADD qword ptr [R12 + 0x8],0x4
JMP 0x001012bf
LAB_0010132a:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1,vector param_2)
{
int *piVar1;
int *piVar2;
int8 *in_RDX;
int *piVar3;
int4 in_register_00000034;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
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;
piVar3 = *(int **)CONCAT44(in_register_00000034,param_2);
piVar1 = (int *)((int8 *)CONCAT44(in_register_00000034,param_2))[1];
do {
if (piVar1 == piVar3) {
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return this;
}
local_34 = *piVar3;
for (piVar2 = (int *)*in_RDX; piVar2 != (int *)in_RDX[1]; piVar2 = piVar2 + 1) {
if (local_34 == *piVar2) goto LAB_001012bf;
}
piVar2 = *(int **)(this + 8);
if (piVar2 == *(int **)(this + 0x10)) {
/* try { // try from 001012ba to 001012be has its CatchHandler @ 001012fe */
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;
}
LAB_001012bf:
piVar3 = piVar3 + 1;
} while( true );
} |
642 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> list1, std::vector<int> list2) {
std::vector<int> result;
for (int x : list1) {
bool found = false;
for (int y : list2) {
if (x == y) {
found = true;
break;
}
}
if (!found) {
result.push_back(x);
}
}
return result;
}
| int main() {
assert((func0({1,2,3,4,5,6,7,8,9,10}, {2,4,6,8}) == std::vector<int>{1, 3, 5, 7, 9, 10}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 3, 5, 7}) == std::vector<int>{2, 4, 6, 8, 9, 10}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {5,7}) == std::vector<int>{1, 2, 3, 4, 6, 8, 9, 10}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %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),%rbx
mov 0x8(%rsi),%r13
cmp %r13,%rbx
je 18be <_Z5func0St6vectorIiSaIiEES1_+0x7e>
mov %rdx,%rbp
lea 0x4(%rsp),%r14
xchg %ax,%ax
mov (%rbx),%edx
mov 0x0(%rbp),%rax
mov 0x8(%rbp),%rcx
mov %edx,0x4(%rsp)
cmp %rax,%rcx
jne 18b1 <_Z5func0St6vectorIiSaIiEES1_+0x71>
jmp 18e0 <_Z5func0St6vectorIiSaIiEES1_+0xa0>
nopl (%rax)
add $0x4,%rax
cmp %rax,%rcx
je 18e0 <_Z5func0St6vectorIiSaIiEES1_+0xa0>
cmp (%rax),%edx
jne 18a8 <_Z5func0St6vectorIiSaIiEES1_+0x68>
add $0x4,%rbx
cmp %rbx,%r13
jne 1890 <_Z5func0St6vectorIiSaIiEES1_+0x50>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 191c <_Z5func0St6vectorIiSaIiEES1_+0xdc>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xchg %ax,%ax
mov 0x8(%r12),%rsi
cmp 0x10(%r12),%rsi
je 1902 <_Z5func0St6vectorIiSaIiEES1_+0xc2>
mov %edx,(%rsi)
add $0x4,%rbx
add $0x4,%rsi
mov %rsi,0x8(%r12)
cmp %rbx,%r13
jne 1890 <_Z5func0St6vectorIiSaIiEES1_+0x50>
jmp 18be <_Z5func0St6vectorIiSaIiEES1_+0x7e>
mov %r14,%rdx
mov %r12,%rdi
callq 1a40 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
add $0x4,%rbx
cmp %rbx,%r13
jne 1890 <_Z5func0St6vectorIiSaIiEES1_+0x50>
jmp 18be <_Z5func0St6vectorIiSaIiEES1_+0x7e>
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1160 <_Z5func0St6vectorIiSaIiEES1_.cold>
nopl (%rax)
| _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r13
pxor xmm0, xmm0
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov r13, [rsi+8]
cmp r13, rbx
jz short loc_17CE
mov rbp, rdx
nop
loc_17A0:
mov edx, [rbx]
mov rax, [rbp+0]
mov rcx, [rbp+8]
mov [rsp+38h+var_34], edx
cmp rax, rcx
jnz short loc_17C1
jmp short loc_17F0
loc_17B8:
add rax, 4
cmp rcx, rax
jz short loc_17F0
loc_17C1:
cmp edx, [rax]
jnz short loc_17B8
add rbx, 4
cmp r13, rbx
jnz short loc_17A0
loc_17CE:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_182E
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn
loc_17F0:
mov rsi, [r12+8]
cmp rsi, [r12+10h]
jz short loc_1812
mov [rsi], edx
add rbx, 4
add rsi, 4
mov [r12+8], rsi
cmp r13, rbx
jnz short loc_17A0
jmp short loc_17CE
loc_1812:
lea rdx, [rsp+38h+var_34]
mov rdi, r12
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 rbx, 4
cmp r13, rbx
jnz loc_17A0
jmp short loc_17CE
loc_182E:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0St6vectorIiSaIiEES1__cold; func0(std::vector<int>,std::vector<int>) [clone] | long long func0(long long a1, int **a2, long long a3)
{
int *v3; // rbx
int *v4; // r13
int v6; // edx
_DWORD *v7; // rax
_DWORD *v8; // rcx
_DWORD *v10; // rsi
int v11; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v12; // [rsp+4h] [rbp-30h]
v12 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v3 = *a2;
v4 = a2[1];
if ( v4 != *a2 )
{
do
{
while ( 1 )
{
v6 = *v3;
v7 = *(_DWORD **)a3;
v8 = *(_DWORD **)(a3 + 8);
v11 = *v3;
if ( v7 != v8 )
break;
LABEL_8:
v10 = *(_DWORD **)(a1 + 8);
if ( v10 == *(_DWORD **)(a1 + 16) )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v10, &v11);
if ( v4 == ++v3 )
return a1;
}
else
{
*v10 = v6;
++v3;
*(_QWORD *)(a1 + 8) = v10 + 1;
if ( v4 == v3 )
return a1;
}
}
while ( v6 != *v7 )
{
if ( v8 == ++v7 )
goto LABEL_8;
}
++v3;
}
while ( v4 != v3 );
}
return a1;
} | func0:
MOV RDI,R12
CALL 0x00101840
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101180
MOV RDI,RBX
LAB_0010117b:
CALL 0x00101150
LAB_00101180:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) [clone
.cold] */
void func0(vector param_1,vector param_2,int param_3,int param_4,int param_5,
int param_6,long param_7)
{
vector<int,std::allocator<int>> *unaff_R12;
long in_FS_OFFSET;
std::vector<int,std::allocator<int>>::~vector(unaff_R12);
if (param_7 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume();
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
643 | func0 |
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> list1, std::vector<int> list2) {
std::vector<int> result;
for (int x : list1) {
bool found = false;
for (int y : list2) {
if (x == y) {
found = true;
break;
}
}
if (!found) {
result.push_back(x);
}
}
return result;
}
| int main() {
assert((func0({1,2,3,4,5,6,7,8,9,10}, {2,4,6,8}) == std::vector<int>{1, 3, 5, 7, 9, 10}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 3, 5, 7}) == std::vector<int>{2, 4, 6, 8, 9, 10}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {5,7}) == std::vector<int>{1, 2, 3, 4, 6, 8, 9, 10}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r14
pxor %xmm0,%xmm0
push %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),%rbx
mov 0x8(%rsi),%r13
cmp %r13,%rbx
je 182e <_Z5func0St6vectorIiSaIiEES1_+0x7e>
mov %rdx,%rbp
lea 0x4(%rsp),%r14
nopw %cs:0x0(%rax,%rax,1)
mov (%rbx),%edx
mov 0x0(%rbp),%rax
mov 0x8(%rbp),%rcx
mov %edx,0x4(%rsp)
cmp %rax,%rcx
jne 1821 <_Z5func0St6vectorIiSaIiEES1_+0x71>
jmp 1850 <_Z5func0St6vectorIiSaIiEES1_+0xa0>
nopl (%rax)
add $0x4,%rax
cmp %rax,%rcx
je 1850 <_Z5func0St6vectorIiSaIiEES1_+0xa0>
cmp (%rax),%edx
jne 1818 <_Z5func0St6vectorIiSaIiEES1_+0x68>
add $0x4,%rbx
cmp %rbx,%r13
jne 1800 <_Z5func0St6vectorIiSaIiEES1_+0x50>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 188c <_Z5func0St6vectorIiSaIiEES1_+0xdc>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
xchg %ax,%ax
mov 0x8(%r12),%rsi
cmp 0x10(%r12),%rsi
je 1872 <_Z5func0St6vectorIiSaIiEES1_+0xc2>
mov %edx,(%rsi)
add $0x4,%rbx
add $0x4,%rsi
mov %rsi,0x8(%r12)
cmp %rbx,%r13
jne 1800 <_Z5func0St6vectorIiSaIiEES1_+0x50>
jmp 182e <_Z5func0St6vectorIiSaIiEES1_+0x7e>
mov %r14,%rdx
mov %r12,%rdi
callq 18f0 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
add $0x4,%rbx
cmp %rbx,%r13
jne 1800 <_Z5func0St6vectorIiSaIiEES1_+0x50>
jmp 182e <_Z5func0St6vectorIiSaIiEES1_+0x7e>
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1175 <_Z5func0St6vectorIiSaIiEES1_.cold>
nopl (%rax)
| _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r13
pxor xmm0, xmm0
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov r13, [rsi+8]
cmp r13, rbx
jz short loc_17CE
mov rbp, rdx
nop
loc_17A0:
mov edx, [rbx]
mov rax, [rbp+0]
mov rcx, [rbp+8]
mov [rsp+38h+var_34], edx
cmp rax, rcx
jnz short loc_17C1
jmp short loc_17F0
loc_17B8:
add rax, 4
cmp rcx, rax
jz short loc_17F0
loc_17C1:
cmp edx, [rax]
jnz short loc_17B8
add rbx, 4
cmp r13, rbx
jnz short loc_17A0
loc_17CE:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_182E
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn
loc_17F0:
mov rsi, [r12+8]
cmp rsi, [r12+10h]
jz short loc_1812
mov [rsi], edx
add rbx, 4
add rsi, 4
mov [r12+8], rsi
cmp r13, rbx
jnz short loc_17A0
jmp short loc_17CE
loc_1812:
lea rdx, [rsp+38h+var_34]
mov rdi, r12
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 rbx, 4
cmp r13, rbx
jnz loc_17A0
jmp short loc_17CE
loc_182E:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0St6vectorIiSaIiEES1__cold; func0(std::vector<int>,std::vector<int>) [clone] | long long func0(long long a1, int **a2, long long a3)
{
int *v3; // rbx
int *v4; // r13
int v6; // edx
_DWORD *v7; // rax
_DWORD *v8; // rcx
_DWORD *v10; // rsi
int v11; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v12; // [rsp+4h] [rbp-30h]
v12 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v3 = *a2;
v4 = a2[1];
if ( v4 != *a2 )
{
do
{
while ( 1 )
{
v6 = *v3;
v7 = *(_DWORD **)a3;
v8 = *(_DWORD **)(a3 + 8);
v11 = *v3;
if ( v7 != v8 )
break;
LABEL_8:
v10 = *(_DWORD **)(a1 + 8);
if ( v10 == *(_DWORD **)(a1 + 16) )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v10, &v11);
if ( v4 == ++v3 )
return a1;
}
else
{
*v10 = v6;
++v3;
*(_QWORD *)(a1 + 8) = v10 + 1;
if ( v4 == v3 )
return a1;
}
}
while ( v6 != *v7 )
{
if ( v8 == ++v7 )
goto LABEL_8;
}
++v3;
}
while ( v4 != v3 );
}
return a1;
} | func0:
MOV RDI,R12
CALL 0x00101840
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101180
MOV RDI,RBX
LAB_0010117b:
CALL 0x00101150
LAB_00101180:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) [clone
.cold] */
void func0(vector param_1,vector param_2,int param_3,int param_4,int param_5,
int param_6,long param_7)
{
vector<int,std::allocator<int>> *unaff_R12;
long in_FS_OFFSET;
std::vector<int,std::allocator<int>>::~vector(unaff_R12);
if (param_7 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume();
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
644 | func0 |
#include <assert.h>
| int func0(int n) {
if (n < 1) {
return 0;
} else {
return n + func0(n - 2);
}
}
| int main() {
assert(func0(6) == 12);
assert(func0(10) == 30);
assert(func0(9) == 25);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jg 1165 <_Z5func0i+0x1c>
mov $0x0,%eax
jmp 1177 <_Z5func0i+0x2e>
mov -0x4(%rbp),%eax
sub $0x2,%eax
mov %eax,%edi
callq 1149 <_Z5func0i>
mov -0x4(%rbp),%edx
add %edx,%eax
leaveq
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
cmp [rbp+var_4], 0
jg short loc_1165
mov eax, 0
jmp short locret_1177
loc_1165:
mov eax, [rbp+var_4]
sub eax, 2
mov edi, eax; int
call _Z5func0i; func0(int)
mov edx, [rbp+var_4]
add eax, edx
locret_1177:
leave
retn | long long func0(int a1)
{
if ( a1 > 0 )
return a1 + (unsigned int)func0(a1 - 2);
else
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x0
JG 0x00101165
MOV EAX,0x0
JMP 0x00101177
LAB_00101165:
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x2
MOV EDI,EAX
CALL 0x00101149
MOV EDX,dword ptr [RBP + -0x4]
ADD EAX,EDX
LAB_00101177:
LEAVE
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
if (param_1 < 1) {
iVar1 = 0;
}
else {
iVar1 = func0(param_1 + -2);
iVar1 = iVar1 + param_1;
}
return iVar1;
} |
645 | func0 |
#include <assert.h>
| int func0(int n) {
if (n < 1) {
return 0;
} else {
return n + func0(n - 2);
}
}
| int main() {
assert(func0(6) == 12);
assert(func0(10) == 30);
assert(func0(9) == 25);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov $0x0,%eax
test %edi,%edi
jle 1165 <_Z5func0i+0x1c>
push %rbx
mov %edi,%ebx
lea -0x2(%rdi),%edi
callq 1149 <_Z5func0i>
add %ebx,%eax
pop %rbx
retq
retq
| _Z5func0i:
endbr64
mov eax, 0
test edi, edi
jle short locret_1165
push rbx
mov ebx, edi
lea edi, [rdi-2]; int
call _Z5func0i; func0(int)
add eax, ebx
pop rbx
retn
locret_1165:
retn | long long func0(int a1)
{
long long result; // rax
result = 0LL;
if ( a1 > 0 )
return a1 + (unsigned int)func0(a1 - 2);
return result;
} | func0:
ENDBR64
MOV EAX,0x0
TEST EDI,EDI
JLE 0x00101165
PUSH RBX
MOV EBX,EDI
LEA EDI,[RDI + -0x2]
CALL 0x00101149
ADD EAX,EBX
POP RBX
RET
LAB_00101165:
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
if (0 < param_1) {
iVar1 = func0(param_1 + -2);
return iVar1 + param_1;
}
return 0;
} |
646 | func0 |
#include <assert.h>
| int func0(int n) {
if (n < 1) {
return 0;
} else {
return n + func0(n - 2);
}
}
| int main() {
assert(func0(6) == 12);
assert(func0(10) == 30);
assert(func0(9) == 25);
return 0;
}
| O2 | cpp | func0(int):
endbr64
xor %r8d,%r8d
test %edi,%edi
jle 116e <_Z5func0i+0x2e>
lea -0x2(%rdi),%eax
lea -0x1(%rdi),%edx
xor %r8d,%r8d
and $0xfffffffe,%edx
mov %eax,%ecx
sub %edx,%ecx
jmp 1163 <_Z5func0i+0x23>
nopl (%rax)
sub $0x2,%eax
mov %edi,%edx
mov %eax,%edi
add %edx,%r8d
cmp %ecx,%eax
jne 1160 <_Z5func0i+0x20>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0i:
endbr64
xor edx, edx
test edi, edi
jle short loc_116D
lea eax, [rdi-2]
lea edx, [rdi-1]
and edx, 0FFFFFFFEh
mov esi, eax
sub esi, edx
xor edx, edx
jmp short loc_1163
loc_1160:
sub eax, 2
loc_1163:
mov ecx, edi
mov edi, eax
add edx, ecx
cmp eax, esi
jnz short loc_1160
loc_116D:
mov eax, edx
retn | long long func0(int a1)
{
unsigned int v1; // edx
int v2; // eax
unsigned int v3; // esi
int v4; // ecx
v1 = 0;
if ( a1 > 0 )
{
v2 = a1 - 2;
v3 = a1 - 2 - ((a1 - 1) & 0xFFFFFFFE);
v1 = 0;
while ( 1 )
{
v4 = a1;
a1 = v2;
v1 += v4;
if ( v2 == v3 )
break;
v2 -= 2;
}
}
return v1;
} | func0:
ENDBR64
XOR EDX,EDX
TEST EDI,EDI
JLE 0x0010116d
LEA EAX,[RDI + -0x2]
LEA EDX,[RDI + -0x1]
AND EDX,0xfffffffe
MOV ESI,EAX
SUB ESI,EDX
XOR EDX,EDX
JMP 0x00101163
LAB_00101160:
SUB EAX,0x2
LAB_00101163:
MOV ECX,EDI
MOV EDI,EAX
ADD EDX,ECX
CMP EAX,ESI
JNZ 0x00101160
LAB_0010116d:
MOV EAX,EDX
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar3 = 0;
if (0 < param_1) {
iVar3 = 0;
iVar1 = param_1 + -2;
iVar4 = param_1;
while (iVar2 = iVar1, iVar3 = iVar3 + iVar4,
iVar2 != (param_1 + -2) - (param_1 - 1U & 0xfffffffe)) {
iVar4 = iVar2;
iVar1 = iVar2 + -2;
}
}
return iVar3;
} |
647 | func0 |
#include <assert.h>
| int func0(int n) {
if (n < 1) {
return 0;
} else {
return n + func0(n - 2);
}
}
| int main() {
assert(func0(6) == 12);
assert(func0(10) == 30);
assert(func0(9) == 25);
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
jle 11e8 <_Z5func0i+0xa8>
lea -0x1(%rdi),%eax
mov %eax,%ecx
shr %ecx
add $0x1,%ecx
cmp $0x23,%eax
jbe 11eb <_Z5func0i+0xab>
movd %edi,%xmm4
mov %ecx,%edx
movdqa 0xeb3(%rip),%xmm3
xor %eax,%eax
pshufd $0x0,%xmm4,%xmm1
paddd 0xe94(%rip),%xmm1
shr $0x2,%edx
pxor %xmm0,%xmm0
nopl 0x0(%rax,%rax,1)
movdqa %xmm1,%xmm2
add $0x1,%eax
paddd %xmm3,%xmm1
paddd %xmm2,%xmm0
cmp %edx,%eax
jne 1188 <_Z5func0i+0x48>
movdqa %xmm0,%xmm1
mov %ecx,%edx
psrldq $0x8,%xmm1
and $0xfffffffc,%edx
paddd %xmm1,%xmm0
mov %edx,%esi
movdqa %xmm0,%xmm1
neg %esi
psrldq $0x4,%xmm1
lea (%rdi,%rsi,2),%edi
paddd %xmm1,%xmm0
movd %xmm0,%eax
cmp %edx,%ecx
je 11e0 <_Z5func0i+0xa0>
nopl 0x0(%rax)
mov %edi,%edx
sub $0x2,%edi
add %edx,%eax
test %edi,%edi
jg 11d0 <_Z5func0i+0x90>
retq
nopl 0x0(%rax)
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
xor %eax,%eax
jmp 11d0 <_Z5func0i+0x90>
| _Z5func0i:
endbr64
mov edx, edi
test edi, edi
jle loc_1220
lea eax, [rdi-1]
mov ecx, eax
shr ecx, 1
add ecx, 1
cmp eax, 13h
jbe loc_1223
movd xmm4, edi
mov esi, ecx
movdqa xmm3, cs:xmmword_2020
xor eax, eax
pshufd xmm1, xmm4, 0
paddd xmm1, cs:xmmword_2010
shr esi, 2
pxor xmm0, xmm0
nop dword ptr [rax]
loc_1188:
movdqa xmm2, xmm1
add eax, 1
paddd xmm1, xmm3
paddd xmm0, xmm2
cmp eax, esi
jnz short loc_1188
movdqa xmm1, xmm0
psrldq xmm1, 8
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test cl, 3
jz short locret_121B
and ecx, 0FFFFFFFCh
neg ecx
lea edx, [rdx+rcx*2]
loc_11C6:
lea ecx, [rdx-2]
add eax, edx
test ecx, ecx
jle short locret_121B
lea esi, [rdx-4]
add eax, ecx
test esi, esi
jle short locret_121B
lea ecx, [rdx-6]
add eax, esi
test ecx, ecx
jle short locret_121B
lea esi, [rdx-8]
add eax, ecx
test esi, esi
jle short locret_121B
lea ecx, [rdx-0Ah]
add eax, esi
test ecx, ecx
jle short locret_121B
lea esi, [rdx-0Ch]
add eax, ecx
test esi, esi
jle short locret_121B
lea ecx, [rdx-0Eh]
add eax, esi
test ecx, ecx
jle short locret_121B
lea esi, [rdx-10h]
add eax, ecx
test esi, esi
jle short locret_121B
add eax, esi
sub edx, 12h
lea ecx, [rax+rdx]
test edx, edx
cmovg eax, ecx
locret_121B:
retn
loc_1220:
xor eax, eax
retn
loc_1223:
xor eax, eax
jmp short loc_11C6 | long long func0(signed int a1)
{
signed int v1; // edx
unsigned int v2; // ecx
__m128i si128; // xmm3
int v4; // eax
__m128i v5; // xmm1
__m128i v6; // xmm0
__m128i v7; // xmm2
__m128i v8; // xmm0
long long result; // rax
int v10; // edx
v1 = a1;
if ( a1 <= 0 )
return 0LL;
v2 = ((unsigned int)(a1 - 1) >> 1) + 1;
if ( (unsigned int)(a1 - 1) <= 0x13 )
{
LODWORD(result) = 0;
}
else
{
si128 = _mm_load_si128((const __m128i *)&xmmword_2020);
v4 = 0;
v5 = _mm_add_epi32(_mm_shuffle_epi32(_mm_cvtsi32_si128(a1), 0), (__m128i)xmmword_2010);
v6 = 0LL;
do
{
v7 = v5;
++v4;
v5 = _mm_add_epi32(v5, si128);
v6 = _mm_add_epi32(v6, v7);
}
while ( v4 != v2 >> 2 );
v8 = _mm_add_epi32(v6, _mm_srli_si128(v6, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v8, _mm_srli_si128(v8, 4)));
if ( (v2 & 3) == 0 )
return result;
v1 = a1 - 2 * (v2 & 0xFFFFFFFC);
}
result = (unsigned int)(v1 + result);
if ( v1 - 2 > 0 )
{
result = (unsigned int)(v1 - 2 + result);
if ( v1 - 4 > 0 )
{
result = (unsigned int)(v1 - 4 + result);
if ( v1 - 6 > 0 )
{
result = (unsigned int)(v1 - 6 + result);
if ( v1 - 8 > 0 )
{
result = (unsigned int)(v1 - 8 + result);
if ( v1 - 10 > 0 )
{
result = (unsigned int)(v1 - 10 + result);
if ( v1 - 12 > 0 )
{
result = (unsigned int)(v1 - 12 + result);
if ( v1 - 14 > 0 )
{
result = (unsigned int)(v1 - 14 + result);
if ( v1 - 16 > 0 )
{
result = (unsigned int)(v1 - 16 + result);
v10 = v1 - 18;
if ( v10 > 0 )
return (unsigned int)(result + v10);
}
}
}
}
}
}
}
}
return result;
} | func0:
ENDBR64
MOV EDX,EDI
TEST EDI,EDI
JLE 0x00101220
LEA EAX,[RDI + -0x1]
MOV ECX,EAX
SHR ECX,0x1
ADD ECX,0x1
CMP EAX,0x13
JBE 0x00101223
MOVD XMM4,EDI
MOV ESI,ECX
MOVDQA XMM3,xmmword ptr [0x00102020]
XOR EAX,EAX
PSHUFD XMM1,XMM4,0x0
PADDD XMM1,xmmword ptr [0x00102010]
SHR ESI,0x2
PXOR XMM0,XMM0
NOP dword ptr [RAX]
LAB_00101188:
MOVDQA XMM2,XMM1
ADD EAX,0x1
PADDD XMM1,XMM3
PADDD XMM0,XMM2
CMP EAX,ESI
JNZ 0x00101188
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST CL,0x3
JZ 0x0010121b
AND ECX,0xfffffffc
NEG ECX
LEA EDX,[RDX + RCX*0x2]
LAB_001011c6:
LEA ECX,[RDX + -0x2]
ADD EAX,EDX
TEST ECX,ECX
JLE 0x0010121b
LEA ESI,[RDX + -0x4]
ADD EAX,ECX
TEST ESI,ESI
JLE 0x0010121b
LEA ECX,[RDX + -0x6]
ADD EAX,ESI
TEST ECX,ECX
JLE 0x0010121b
LEA ESI,[RDX + -0x8]
ADD EAX,ECX
TEST ESI,ESI
JLE 0x0010121b
LEA ECX,[RDX + -0xa]
ADD EAX,ESI
TEST ECX,ECX
JLE 0x0010121b
LEA ESI,[RDX + -0xc]
ADD EAX,ECX
TEST ESI,ESI
JLE 0x0010121b
LEA ECX,[RDX + -0xe]
ADD EAX,ESI
TEST ECX,ECX
JLE 0x0010121b
LEA ESI,[RDX + -0x10]
ADD EAX,ECX
TEST ESI,ESI
JLE 0x0010121b
ADD EAX,ESI
SUB EDX,0x12
LEA ECX,[RAX + RDX*0x1]
TEST EDX,EDX
CMOVG EAX,ECX
LAB_0010121b:
RET
LAB_00101220:
XOR EAX,EAX
RET
LAB_00101223:
XOR EAX,EAX
JMP 0x001011c6 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
if (param_1 < 1) {
return 0;
}
uVar3 = (param_1 - 1U >> 1) + 1;
if (param_1 - 1U < 0x14) {
iVar5 = 0;
}
else {
uVar1 = 0;
iVar4 = 0;
iVar6 = 0;
iVar7 = 0;
iVar8 = 0;
iVar5 = param_1 + _DAT_00102010;
iVar2 = param_1 + _UNK_00102014;
iVar9 = param_1 + _UNK_00102018;
iVar10 = param_1 + _UNK_0010201c;
do {
uVar1 = uVar1 + 1;
iVar4 = iVar4 + iVar5;
iVar6 = iVar6 + iVar2;
iVar7 = iVar7 + iVar9;
iVar8 = iVar8 + iVar10;
iVar5 = iVar5 + _DAT_00102020;
iVar2 = iVar2 + _UNK_00102024;
iVar9 = iVar9 + _UNK_00102028;
iVar10 = iVar10 + _UNK_0010202c;
} while (uVar1 != uVar3 >> 2);
iVar5 = iVar4 + iVar7 + iVar6 + iVar8;
if ((uVar3 & 3) == 0) {
return iVar5;
}
param_1 = param_1 + (uVar3 & 0xfffffffc) * -2;
}
iVar2 = iVar5 + param_1;
if (0 < param_1 + -2) {
iVar2 = iVar5 + param_1 + param_1 + -2;
if (0 < param_1 + -4) {
iVar2 = iVar2 + param_1 + -4;
if (0 < param_1 + -6) {
iVar2 = iVar2 + param_1 + -6;
if (0 < param_1 + -8) {
iVar2 = iVar2 + param_1 + -8;
if (0 < param_1 + -10) {
iVar2 = iVar2 + param_1 + -10;
if (0 < param_1 + -0xc) {
iVar2 = iVar2 + param_1 + -0xc;
if (0 < param_1 + -0xe) {
iVar2 = iVar2 + param_1 + -0xe;
if (0 < param_1 + -0x10) {
iVar2 = iVar2 + param_1 + -0x10;
if (0 < param_1 + -0x12) {
iVar2 = iVar2 + param_1 + -0x12;
}
}
}
}
}
}
}
}
}
return iVar2;
} |
648 | func0 |
#include <cmath>
#include <cassert>
| double func0(int s, double l) {
double area = s * (l * l) / (4 * tan(M_PI / s));
return area;
}
| int main() {
assert(func0(4, 20) == 400.00000000000006);
assert(func0(10, 15) == 1731.1969896610804);
assert(func0(9, 7) == 302.90938549487214);
return 0;
}
| O0 | cpp | func0(int, double):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
movsd %xmm0,-0x20(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm1
movsd -0x20(%rbp),%xmm0
mulsd %xmm0,%xmm0
mulsd %xmm0,%xmm1
movsd %xmm1,-0x28(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm1
movsd 0xf37(%rip),%xmm0
divsd %xmm1,%xmm0
callq 1070 <tan@plt>
movsd 0xf2e(%rip),%xmm1
mulsd %xmm1,%xmm0
movsd -0x28(%rbp),%xmm1
divsd %xmm0,%xmm1
movapd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
leaveq
retq
| _Z5func0id:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_14], edi
movsd [rbp+var_20], xmm0
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_14]
movsd xmm0, [rbp+var_20]
mulsd xmm0, xmm0
mulsd xmm1, xmm0
movsd [rbp+var_28], xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_14]
movsd xmm0, cs:qword_20B8
movapd xmm2, xmm0
divsd xmm2, xmm1
movq rax, xmm2
movq xmm0, rax; x
call _tan
movsd xmm1, cs:qword_20C0
mulsd xmm1, xmm0
movsd xmm0, [rbp+var_28]
divsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
leave
retn | double func0(int a1, double a2)
{
return (double)a1 * (a2 * a2) / (4.0 * tan(3.141592653589793 / (double)a1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x14],EDI
MOVSD qword ptr [RBP + -0x20],XMM0
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x14]
MOVSD XMM0,qword ptr [RBP + -0x20]
MULSD XMM0,XMM0
MULSD XMM1,XMM0
MOVSD qword ptr [RBP + -0x28],XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x14]
MOVSD XMM0,qword ptr [0x001020b8]
MOVAPD XMM2,XMM0
DIVSD XMM2,XMM1
MOVQ RAX,XMM2
MOVQ XMM0,RAX
CALL 0x00101070
MOVSD XMM1,qword ptr [0x001020c0]
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0x28]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(int, double) */
double func0(int param_1,double param_2)
{
double dVar1;
dVar1 = tan(DAT_001020b8 / (double)param_1);
return ((double)param_1 * param_2 * param_2) / (DAT_001020c0 * dVar1);
} |
649 | func0 |
#include <cmath>
#include <cassert>
| double func0(int s, double l) {
double area = s * (l * l) / (4 * tan(M_PI / s));
return area;
}
| int main() {
assert(func0(4, 20) == 400.00000000000006);
assert(func0(10, 15) == 1731.1969896610804);
assert(func0(9, 7) == 302.90938549487214);
return 0;
}
| O1 | cpp | func0(int, double):
endbr64
sub $0x18,%rsp
movsd %xmm0,0x8(%rsp)
pxor %xmm2,%xmm2
cvtsi2sd %edi,%xmm2
movsd 0xea1(%rip),%xmm0
movsd %xmm2,(%rsp)
divsd %xmm2,%xmm0
callq 1050 <tan@plt>
movapd %xmm0,%xmm1
movsd 0x8(%rsp),%xmm0
mulsd %xmm0,%xmm0
mulsd (%rsp),%xmm0
mulsd 0xe80(%rip),%xmm1
divsd %xmm1,%xmm0
add $0x18,%rsp
retq
| _Z5func0id:
endbr64
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
pxor xmm2, xmm2
cvtsi2sd xmm2, edi
movsd xmm0, cs:qword_2008
movsd [rsp+18h+var_18], xmm2
divsd xmm0, xmm2; x
call _tan
movapd xmm1, xmm0
movsd xmm0, [rsp+18h+var_10]
mulsd xmm0, xmm0
mulsd xmm0, [rsp+18h+var_18]
mulsd xmm1, cs:qword_2010
divsd xmm0, xmm1
add rsp, 18h
retn | double func0(int a1, double a2)
{
return a2 * a2 * (double)a1 / (tan(3.141592653589793 / (double)a1) * 4.0);
} | func0:
ENDBR64
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
PXOR XMM2,XMM2
CVTSI2SD XMM2,EDI
MOVSD XMM0,qword ptr [0x00102008]
MOVSD qword ptr [RSP],XMM2
DIVSD XMM0,XMM2
CALL 0x00101050
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [RSP + 0x8]
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [RSP]
MULSD XMM1,qword ptr [0x00102010]
DIVSD XMM0,XMM1
ADD RSP,0x18
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, double) */
double func0(int param_1,double param_2)
{
double dVar1;
dVar1 = tan(DAT_00102008 / (double)param_1);
return (param_2 * param_2 * (double)param_1) / (dVar1 * _DAT_00102010);
} |
650 | func0 |
#include <cmath>
#include <cassert>
| double func0(int s, double l) {
double area = s * (l * l) / (4 * tan(M_PI / s));
return area;
}
| int main() {
assert(func0(4, 20) == 400.00000000000006);
assert(func0(10, 15) == 1731.1969896610804);
assert(func0(9, 7) == 302.90938549487214);
return 0;
}
| O2 | cpp | func0(int, double):
endbr64
pxor %xmm2,%xmm2
sub $0x18,%rsp
cvtsi2sd %edi,%xmm2
movsd %xmm0,0x8(%rsp)
movsd 0xe8a(%rip),%xmm0
divsd %xmm2,%xmm0
movsd %xmm2,(%rsp)
callq 1050 <tan@plt>
movsd 0x8(%rsp),%xmm1
movsd (%rsp),%xmm2
mulsd 0xe71(%rip),%xmm0
add $0x18,%rsp
mulsd %xmm1,%xmm1
mulsd %xmm2,%xmm1
divsd %xmm0,%xmm1
movapd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0id:
endbr64
pxor xmm2, xmm2
sub rsp, 18h
cvtsi2sd xmm2, edi
movsd [rsp+18h+var_10], xmm0
movsd xmm0, cs:qword_2008
divsd xmm0, xmm2; x
movsd [rsp+18h+var_18], xmm2
call _tan
movsd xmm1, [rsp+18h+var_10]
movsd xmm2, [rsp+18h+var_18]
mulsd xmm0, cs:qword_2010
add rsp, 18h
mulsd xmm1, xmm1
mulsd xmm1, xmm2
divsd xmm1, xmm0
movapd xmm0, xmm1
retn | __int128 __usercall func0@<xmm0>(int a1@<edi>, double a2@<xmm0>)
{
__int128 v2; // xmm1
v2 = *(unsigned long long *)&a2;
*(double *)&v2 = *(double *)&v2 * *(double *)&v2 * (double)a1 / (tan(3.141592653589793 / (double)a1) * 4.0);
return v2;
} | func0:
ENDBR64
PXOR XMM2,XMM2
SUB RSP,0x18
CVTSI2SD XMM2,EDI
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD XMM0,qword ptr [0x00102008]
DIVSD XMM0,XMM2
MOVSD qword ptr [RSP],XMM2
CALL 0x00101050
MOVSD XMM1,qword ptr [RSP + 0x8]
MOVSD XMM2,qword ptr [RSP]
MULSD XMM0,qword ptr [0x00102010]
ADD RSP,0x18
MULSD XMM1,XMM1
MULSD XMM1,XMM2
DIVSD XMM1,XMM0
MOVAPD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, double) */
double func0(int param_1,double param_2)
{
double dVar1;
dVar1 = tan(DAT_00102008 / (double)param_1);
return (param_2 * param_2 * (double)param_1) / (dVar1 * _DAT_00102010);
} |
651 | func0 |
#include <cmath>
#include <cassert>
| double func0(int s, double l) {
double area = s * (l * l) / (4 * tan(M_PI / s));
return area;
}
| int main() {
assert(func0(4, 20) == 400.00000000000006);
assert(func0(10, 15) == 1731.1969896610804);
assert(func0(9, 7) == 302.90938549487214);
return 0;
}
| O3 | cpp | func0(int, double):
endbr64
pxor %xmm2,%xmm2
sub $0x18,%rsp
cvtsi2sd %edi,%xmm2
movsd %xmm0,0x8(%rsp)
movsd 0xe8a(%rip),%xmm0
divsd %xmm2,%xmm0
movsd %xmm2,(%rsp)
callq 1050 <tan@plt>
movsd 0x8(%rsp),%xmm1
movsd (%rsp),%xmm2
mulsd 0xe71(%rip),%xmm0
add $0x18,%rsp
mulsd %xmm1,%xmm1
mulsd %xmm2,%xmm1
divsd %xmm0,%xmm1
movapd %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0id:
endbr64
pxor xmm2, xmm2
sub rsp, 18h
cvtsi2sd xmm2, edi
movsd [rsp+18h+var_10], xmm0
movsd xmm0, cs:qword_2008
divsd xmm0, xmm2; x
movsd [rsp+18h+var_18], xmm2
call _tan
movsd xmm1, [rsp+18h+var_10]
movsd xmm2, [rsp+18h+var_18]
mulsd xmm0, cs:qword_2010
add rsp, 18h
mulsd xmm1, xmm1
mulsd xmm1, xmm2
divsd xmm1, xmm0
movapd xmm0, xmm1
retn | __int128 __usercall func0@<xmm0>(int a1@<edi>, double a2@<xmm0>)
{
__int128 v2; // xmm1
v2 = *(unsigned long long *)&a2;
*(double *)&v2 = *(double *)&v2 * *(double *)&v2 * (double)a1 / (tan(3.141592653589793 / (double)a1) * 4.0);
return v2;
} | func0:
ENDBR64
PXOR XMM2,XMM2
SUB RSP,0x18
CVTSI2SD XMM2,EDI
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD XMM0,qword ptr [0x00102008]
DIVSD XMM0,XMM2
MOVSD qword ptr [RSP],XMM2
CALL 0x00101050
MOVSD XMM1,qword ptr [RSP + 0x8]
MOVSD XMM2,qword ptr [RSP]
MULSD XMM0,qword ptr [0x00102010]
ADD RSP,0x18
MULSD XMM1,XMM1
MULSD XMM1,XMM2
DIVSD XMM1,XMM0
MOVAPD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, double) */
double func0(int param_1,double param_2)
{
double dVar1;
dVar1 = tan(DAT_00102008 / (double)param_1);
return (param_2 * param_2 * (double)param_1) / (dVar1 * _DAT_00102010);
} |
652 | func0 |
#include <iostream>
#include <cassert>
| bool func0(long num1, long num2) {
long sum1 = 1;
long i1 = 2;
while (i1 * i1 <= num1) {
if (num1 % i1 == 0) {
sum1 += i1 + (num1 / i1);
}
i1++;
}
long sum2 = 1;
long i2 = 2;
while (i2 * i2 <= num2) {
if (num2 % i2 == 0) {
sum2 += i2 + (num2 / i2);
}
i2++;
}
return sum1 == sum2;
}
| int main() {
assert(func0(36, 57) == false);
assert(func0(2, 4) == false);
assert(func0(23, 47) == true);
return 0;
}
| O0 | cpp | func0(long, long):
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movq $0x1,-0x20(%rbp)
movq $0x2,-0x18(%rbp)
mov -0x18(%rbp),%rax
imul %rax,%rax
cmp %rax,-0x28(%rbp)
jl 11e8 <_Z5func0ll+0x5f>
mov -0x28(%rbp),%rax
cqto
idivq -0x18(%rbp)
mov %rdx,%rax
test %rax,%rax
jne 11e1 <_Z5func0ll+0x58>
mov -0x28(%rbp),%rax
cqto
idivq -0x18(%rbp)
mov %rax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
add %rax,-0x20(%rbp)
addq $0x1,-0x18(%rbp)
jmp 11a9 <_Z5func0ll+0x20>
movq $0x1,-0x10(%rbp)
movq $0x2,-0x8(%rbp)
mov -0x8(%rbp),%rax
imul %rax,%rax
cmp %rax,-0x30(%rbp)
jl 1237 <_Z5func0ll+0xae>
mov -0x30(%rbp),%rax
cqto
idivq -0x8(%rbp)
mov %rdx,%rax
test %rax,%rax
jne 1230 <_Z5func0ll+0xa7>
mov -0x30(%rbp),%rax
cqto
idivq -0x8(%rbp)
mov %rax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
add %rax,-0x10(%rbp)
addq $0x1,-0x8(%rbp)
jmp 11f8 <_Z5func0ll+0x6f>
mov -0x20(%rbp),%rax
cmp -0x10(%rbp),%rax
sete %al
pop %rbp
retq
| _Z5func0ll:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_20], 1
mov [rbp+var_18], 2
jmp short loc_119A
loc_116B:
mov rax, [rbp+var_28]
cqo
idiv [rbp+var_18]
mov rax, rdx
test rax, rax
jnz short loc_1195
mov rax, [rbp+var_28]
cqo
idiv [rbp+var_18]
mov rdx, rax
mov rax, [rbp+var_18]
add rax, rdx
add [rbp+var_20], rax
loc_1195:
add [rbp+var_18], 1
loc_119A:
mov rax, [rbp+var_18]
imul rax, rax
cmp [rbp+var_28], rax
jge short loc_116B
mov [rbp+var_10], 1
mov [rbp+var_8], 2
jmp short loc_11E9
loc_11BA:
mov rax, [rbp+var_30]
cqo
idiv [rbp+var_8]
mov rax, rdx
test rax, rax
jnz short loc_11E4
mov rax, [rbp+var_30]
cqo
idiv [rbp+var_8]
mov rdx, rax
mov rax, [rbp+var_8]
add rax, rdx
add [rbp+var_10], rax
loc_11E4:
add [rbp+var_8], 1
loc_11E9:
mov rax, [rbp+var_8]
imul rax, rax
cmp [rbp+var_30], rax
jge short loc_11BA
mov rax, [rbp+var_20]
cmp rax, [rbp+var_10]
setz al
pop rbp
retn | bool func0(long long a1, long long a2)
{
long long v3; // [rsp+10h] [rbp-20h]
long long i; // [rsp+18h] [rbp-18h]
long long v5; // [rsp+20h] [rbp-10h]
long long j; // [rsp+28h] [rbp-8h]
v3 = 1LL;
for ( i = 2LL; a1 >= i * i; ++i )
{
if ( !(a1 % i) )
v3 += a1 / i + i;
}
v5 = 1LL;
for ( j = 2LL; a2 >= j * j; ++j )
{
if ( !(a2 % j) )
v5 += a2 / j + j;
}
return v3 == v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x20],0x1
MOV qword ptr [RBP + -0x18],0x2
JMP 0x0010119a
LAB_0010116b:
MOV RAX,qword ptr [RBP + -0x28]
CQO
IDIV qword ptr [RBP + -0x18]
MOV RAX,RDX
TEST RAX,RAX
JNZ 0x00101195
MOV RAX,qword ptr [RBP + -0x28]
CQO
IDIV qword ptr [RBP + -0x18]
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
ADD qword ptr [RBP + -0x20],RAX
LAB_00101195:
ADD qword ptr [RBP + -0x18],0x1
LAB_0010119a:
MOV RAX,qword ptr [RBP + -0x18]
IMUL RAX,RAX
CMP qword ptr [RBP + -0x28],RAX
JGE 0x0010116b
MOV qword ptr [RBP + -0x10],0x1
MOV qword ptr [RBP + -0x8],0x2
JMP 0x001011e9
LAB_001011ba:
MOV RAX,qword ptr [RBP + -0x30]
CQO
IDIV qword ptr [RBP + -0x8]
MOV RAX,RDX
TEST RAX,RAX
JNZ 0x001011e4
MOV RAX,qword ptr [RBP + -0x30]
CQO
IDIV qword ptr [RBP + -0x8]
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
ADD qword ptr [RBP + -0x10],RAX
LAB_001011e4:
ADD qword ptr [RBP + -0x8],0x1
LAB_001011e9:
MOV RAX,qword ptr [RBP + -0x8]
IMUL RAX,RAX
CMP qword ptr [RBP + -0x30],RAX
JGE 0x001011ba
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x10]
SETZ AL
POP RBP
RET | /* func0(long, long) */
int8 func0(long param_1,long param_2)
{
int8 local_28;
int8 local_20;
int8 local_18;
int8 local_10;
local_28 = 1;
for (local_20 = 2; local_20 * local_20 <= param_1; local_20 = local_20 + 1) {
if (param_1 % local_20 == 0) {
local_28 = local_28 + local_20 + param_1 / local_20;
}
}
local_18 = 1;
for (local_10 = 2; local_10 * local_10 <= param_2; local_10 = local_10 + 1) {
if (param_2 % local_10 == 0) {
local_18 = local_18 + local_10 + param_2 / local_10;
}
}
return CONCAT71((int7)((ulong)local_28 >> 8),local_28 == local_18);
} |
653 | func0 |
#include <iostream>
#include <cassert>
| bool func0(long num1, long num2) {
long sum1 = 1;
long i1 = 2;
while (i1 * i1 <= num1) {
if (num1 % i1 == 0) {
sum1 += i1 + (num1 / i1);
}
i1++;
}
long sum2 = 1;
long i2 = 2;
while (i2 * i2 <= num2) {
if (num2 % i2 == 0) {
sum2 += i2 + (num2 / i2);
}
i2++;
}
return sum1 == sum2;
}
| int main() {
assert(func0(36, 57) == false);
assert(func0(2, 4) == false);
assert(func0(23, 47) == true);
return 0;
}
| O1 | cpp | func0(long, long):
endbr64
mov $0x2,%ecx
mov $0x1,%r8d
cmp $0x3,%rdi
jg 11c0 <_Z5func0ll+0x37>
cmp $0x3,%rsi
jle 120a <_Z5func0ll+0x81>
mov $0x2,%ecx
mov $0x1,%edi
jmp 11ed <_Z5func0ll+0x64>
add $0x1,%rcx
mov %rcx,%rax
imul %rcx,%rax
cmp %rdi,%rax
jg 119e <_Z5func0ll+0x15>
mov %rdi,%rax
cqto
idiv %rcx
test %rdx,%rdx
jne 11b0 <_Z5func0ll+0x27>
mov %rdi,%rax
cqto
idiv %rcx
add %rcx,%rax
add %rax,%r8
jmp 11b0 <_Z5func0ll+0x27>
add $0x1,%rcx
mov %rcx,%rax
imul %rcx,%rax
cmp %rsi,%rax
jg 120f <_Z5func0ll+0x86>
mov %rsi,%rax
cqto
idiv %rcx
test %rdx,%rdx
jne 11dd <_Z5func0ll+0x54>
mov %rsi,%rax
cqto
idiv %rcx
add %rcx,%rax
add %rax,%rdi
jmp 11dd <_Z5func0ll+0x54>
mov $0x1,%edi
cmp %rdi,%r8
sete %al
retq
| _Z5func0ll:
endbr64
cmp rdi, 3
jle short loc_118D
mov ecx, 2
mov r8d, 1
jmp short loc_1170
loc_1160:
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rax, rdi
jg short loc_1193
loc_1170:
mov rax, rdi
cqo
idiv rcx
test rdx, rdx
jnz short loc_1160
mov rax, rdi
cqo
idiv rcx
add rax, rcx
add r8, rax
jmp short loc_1160
loc_118D:
mov r8d, 1
loc_1193:
cmp rsi, 3
jle short loc_11D2
mov ecx, 2
mov edi, 1
jmp short loc_11B5
loc_11A5:
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rax, rsi
jg short loc_11D7
loc_11B5:
mov rax, rsi
cqo
idiv rcx
test rdx, rdx
jnz short loc_11A5
mov rax, rsi
cqo
idiv rcx
add rax, rcx
add rdi, rax
jmp short loc_11A5
loc_11D2:
mov edi, 1
loc_11D7:
cmp r8, rdi
setz al
retn | bool func0(long long a1, long long a2)
{
long long v2; // rcx
long long v3; // r8
long long v4; // rcx
long long v5; // rdi
if ( a1 <= 3 )
{
v3 = 1LL;
}
else
{
v2 = 2LL;
v3 = 1LL;
do
{
if ( !(a1 % v2) )
v3 += v2 + a1 / v2;
++v2;
}
while ( v2 * v2 <= a1 );
}
if ( a2 <= 3 )
{
v5 = 1LL;
}
else
{
v4 = 2LL;
v5 = 1LL;
do
{
if ( !(a2 % v4) )
v5 += v4 + a2 / v4;
++v4;
}
while ( v4 * v4 <= a2 );
}
return v3 == v5;
} | func0:
ENDBR64
CMP RDI,0x3
JLE 0x0010118d
MOV ECX,0x2
MOV R8D,0x1
JMP 0x00101170
LAB_00101160:
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RAX,RDI
JG 0x00101193
LAB_00101170:
MOV RAX,RDI
CQO
IDIV RCX
TEST RDX,RDX
JNZ 0x00101160
MOV RAX,RDI
CQO
IDIV RCX
ADD RAX,RCX
ADD R8,RAX
JMP 0x00101160
LAB_0010118d:
MOV R8D,0x1
LAB_00101193:
CMP RSI,0x3
JLE 0x001011d2
MOV ECX,0x2
MOV EDI,0x1
JMP 0x001011b5
LAB_001011a5:
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RAX,RSI
JG 0x001011d7
LAB_001011b5:
MOV RAX,RSI
CQO
IDIV RCX
TEST RDX,RDX
JNZ 0x001011a5
MOV RAX,RSI
CQO
IDIV RCX
ADD RAX,RCX
ADD RDI,RAX
JMP 0x001011a5
LAB_001011d2:
MOV EDI,0x1
LAB_001011d7:
CMP R8,RDI
SETZ AL
RET | /* func0(long, long) */
bool func0(long param_1,long param_2)
{
long lVar1;
long lVar2;
long lVar3;
if (param_1 < 4) {
lVar3 = 1;
}
else {
lVar1 = 2;
lVar3 = 1;
do {
if (param_1 % lVar1 == 0) {
lVar3 = lVar3 + param_1 / lVar1 + lVar1;
}
lVar1 = lVar1 + 1;
} while (lVar1 * lVar1 - param_1 == 0 || lVar1 * lVar1 < param_1);
}
if (param_2 < 4) {
lVar1 = 1;
}
else {
lVar2 = 2;
lVar1 = 1;
do {
if (param_2 % lVar2 == 0) {
lVar1 = lVar1 + param_2 / lVar2 + lVar2;
}
lVar2 = lVar2 + 1;
} while (lVar2 * lVar2 - param_2 == 0 || lVar2 * lVar2 < param_2);
}
return lVar3 == lVar1;
} |
654 | func0 |
#include <iostream>
#include <cassert>
| bool func0(long num1, long num2) {
long sum1 = 1;
long i1 = 2;
while (i1 * i1 <= num1) {
if (num1 % i1 == 0) {
sum1 += i1 + (num1 / i1);
}
i1++;
}
long sum2 = 1;
long i2 = 2;
while (i2 * i2 <= num2) {
if (num2 % i2 == 0) {
sum2 += i2 + (num2 / i2);
}
i2++;
}
return sum1 == sum2;
}
| int main() {
assert(func0(36, 57) == false);
assert(func0(2, 4) == false);
assert(func0(23, 47) == true);
return 0;
}
| O2 | cpp | func0(long, long):
endbr64
mov $0x2,%ecx
mov $0x1,%r8d
cmp $0x3,%rdi
jle 12bd <_Z5func0ll+0x3d>
nopl (%rax)
mov %rdi,%rax
cqto
idiv %rcx
add %rcx,%rax
add %r8,%rax
test %rdx,%rdx
cmove %rax,%r8
add $0x1,%rcx
mov %rcx,%rax
imul %rcx,%rax
cmp %rdi,%rax
jle 1298 <_Z5func0ll+0x18>
cmp $0x3,%rsi
jle 1300 <_Z5func0ll+0x80>
mov $0x2,%ecx
mov $0x1,%edi
nopl (%rax)
mov %rsi,%rax
cqto
idiv %rcx
add %rcx,%rax
add %rdi,%rax
test %rdx,%rdx
cmove %rax,%rdi
add $0x1,%rcx
mov %rcx,%rax
imul %rcx,%rax
cmp %rsi,%rax
jle 12d0 <_Z5func0ll+0x50>
cmp %rdi,%r8
sete %al
retq
nopl 0x0(%rax)
mov $0x1,%edi
cmp %rdi,%r8
sete %al
retq
nopl 0x0(%rax)
| _Z5func0ll:
endbr64
cmp rdi, 3
jle short loc_1280
mov ecx, 2
mov r8d, 1
nop dword ptr [rax]
loc_1218:
mov rax, rdi
cqo
idiv rcx
add rax, rcx
add rax, r8
test rdx, rdx
cmovz r8, rax
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rax, rdi
jle short loc_1218
cmp rsi, 3
jle short loc_128C
loc_1243:
mov ecx, 2
mov edi, 1
nop dword ptr [rax]
loc_1250:
mov rax, rsi
cqo
idiv rcx
add rax, rcx
add rax, rdi
test rdx, rdx
cmovz rdi, rax
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rax, rsi
jle short loc_1250
cmp r8, rdi
setz al
retn
loc_1280:
mov r8d, 1
cmp rsi, 3
jg short loc_1243
loc_128C:
mov edi, 1
cmp r8, rdi
setz al
retn | bool func0(long long a1, long long a2)
{
long long v2; // rcx
long long v3; // r8
long long v4; // rcx
long long v5; // rdi
if ( a1 > 3 )
{
v2 = 2LL;
v3 = 1LL;
do
{
if ( !(a1 % v2) )
v3 += v2 + a1 / v2;
++v2;
}
while ( v2 * v2 <= a1 );
if ( a2 > 3 )
goto LABEL_7;
return v3 == 1;
}
v3 = 1LL;
if ( a2 <= 3 )
return v3 == 1;
LABEL_7:
v4 = 2LL;
v5 = 1LL;
do
{
if ( !(a2 % v4) )
v5 += v4 + a2 / v4;
++v4;
}
while ( v4 * v4 <= a2 );
return v3 == v5;
} | func0:
ENDBR64
CMP RDI,0x3
JLE 0x00101280
MOV ECX,0x2
MOV R8D,0x1
NOP dword ptr [RAX]
LAB_00101218:
MOV RAX,RDI
CQO
IDIV RCX
ADD RAX,RCX
ADD RAX,R8
TEST RDX,RDX
CMOVZ R8,RAX
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RAX,RDI
JLE 0x00101218
CMP RSI,0x3
JLE 0x0010128c
LAB_00101243:
MOV ECX,0x2
MOV EDI,0x1
NOP dword ptr [RAX]
LAB_00101250:
MOV RAX,RSI
CQO
IDIV RCX
ADD RAX,RCX
ADD RAX,RDI
TEST RDX,RDX
CMOVZ RDI,RAX
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RAX,RSI
JLE 0x00101250
CMP R8,RDI
SETZ AL
RET
LAB_00101280:
MOV R8D,0x1
CMP RSI,0x3
JG 0x00101243
LAB_0010128c:
MOV EDI,0x1
CMP R8,RDI
SETZ AL
RET | /* func0(long, long) */
bool func0(long param_1,long param_2)
{
long lVar1;
long lVar2;
long lVar3;
if (param_1 < 4) {
lVar3 = 1;
}
else {
lVar1 = 2;
lVar3 = 1;
do {
if (param_1 % lVar1 == 0) {
lVar3 = param_1 / lVar1 + lVar1 + lVar3;
}
lVar1 = lVar1 + 1;
} while (lVar1 * lVar1 - param_1 == 0 || lVar1 * lVar1 < param_1);
}
if (param_2 < 4) {
return lVar3 == 1;
}
lVar2 = 2;
lVar1 = 1;
do {
if (param_2 % lVar2 == 0) {
lVar1 = param_2 / lVar2 + lVar2 + lVar1;
}
lVar2 = lVar2 + 1;
} while (lVar2 * lVar2 - param_2 == 0 || lVar2 * lVar2 < param_2);
return lVar3 == lVar1;
} |
655 | func0 |
#include <iostream>
#include <cassert>
| bool func0(long num1, long num2) {
long sum1 = 1;
long i1 = 2;
while (i1 * i1 <= num1) {
if (num1 % i1 == 0) {
sum1 += i1 + (num1 / i1);
}
i1++;
}
long sum2 = 1;
long i2 = 2;
while (i2 * i2 <= num2) {
if (num2 % i2 == 0) {
sum2 += i2 + (num2 / i2);
}
i2++;
}
return sum1 == sum2;
}
| int main() {
assert(func0(36, 57) == false);
assert(func0(2, 4) == false);
assert(func0(23, 47) == true);
return 0;
}
| O3 | cpp | func0(long, long):
endbr64
mov $0x2,%ecx
mov $0x1,%r8d
cmp $0x3,%rdi
jle 12bd <_Z5func0ll+0x3d>
nopl (%rax)
mov %rdi,%rax
cqto
idiv %rcx
add %rcx,%rax
add %r8,%rax
test %rdx,%rdx
cmove %rax,%r8
add $0x1,%rcx
mov %rcx,%rax
imul %rcx,%rax
cmp %rdi,%rax
jle 1298 <_Z5func0ll+0x18>
cmp $0x3,%rsi
jle 1300 <_Z5func0ll+0x80>
mov $0x2,%ecx
mov $0x1,%edi
nopl (%rax)
mov %rsi,%rax
cqto
idiv %rcx
add %rcx,%rax
add %rdi,%rax
test %rdx,%rdx
cmove %rax,%rdi
add $0x1,%rcx
mov %rcx,%rax
imul %rcx,%rax
cmp %rsi,%rax
jle 12d0 <_Z5func0ll+0x50>
cmp %rdi,%r8
sete %al
retq
nopl 0x0(%rax)
mov $0x1,%edi
cmp %rdi,%r8
sete %al
retq
nopl 0x0(%rax)
| _Z5func0ll:
endbr64
cmp rdi, 3
jle short loc_1280
mov ecx, 2
mov r8d, 1
nop dword ptr [rax]
loc_1218:
mov rax, rdi
cqo
idiv rcx
add rax, rcx
add rax, r8
test rdx, rdx
cmovz r8, rax
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rax, rdi
jle short loc_1218
cmp rsi, 3
jle short loc_128C
loc_1243:
mov ecx, 2
mov edi, 1
nop dword ptr [rax]
loc_1250:
mov rax, rsi
cqo
idiv rcx
add rax, rcx
add rax, rdi
test rdx, rdx
cmovz rdi, rax
add rcx, 1
mov rax, rcx
imul rax, rcx
cmp rax, rsi
jle short loc_1250
cmp r8, rdi
setz al
retn
loc_1280:
mov r8d, 1
cmp rsi, 3
jg short loc_1243
loc_128C:
mov edi, 1
cmp r8, rdi
setz al
retn | bool func0(long long a1, long long a2)
{
long long v2; // rcx
long long v3; // r8
long long v4; // rcx
long long v5; // rdi
if ( a1 > 3 )
{
v2 = 2LL;
v3 = 1LL;
do
{
if ( !(a1 % v2) )
v3 += v2 + a1 / v2;
++v2;
}
while ( v2 * v2 <= a1 );
if ( a2 > 3 )
goto LABEL_7;
return v3 == 1;
}
v3 = 1LL;
if ( a2 <= 3 )
return v3 == 1;
LABEL_7:
v4 = 2LL;
v5 = 1LL;
do
{
if ( !(a2 % v4) )
v5 += v4 + a2 / v4;
++v4;
}
while ( v4 * v4 <= a2 );
return v3 == v5;
} | func0:
ENDBR64
CMP RDI,0x3
JLE 0x00101280
MOV ECX,0x2
MOV R8D,0x1
NOP dword ptr [RAX]
LAB_00101218:
MOV RAX,RDI
CQO
IDIV RCX
ADD RAX,RCX
ADD RAX,R8
TEST RDX,RDX
CMOVZ R8,RAX
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RAX,RDI
JLE 0x00101218
CMP RSI,0x3
JLE 0x0010128c
LAB_00101243:
MOV ECX,0x2
MOV EDI,0x1
NOP dword ptr [RAX]
LAB_00101250:
MOV RAX,RSI
CQO
IDIV RCX
ADD RAX,RCX
ADD RAX,RDI
TEST RDX,RDX
CMOVZ RDI,RAX
ADD RCX,0x1
MOV RAX,RCX
IMUL RAX,RCX
CMP RAX,RSI
JLE 0x00101250
CMP R8,RDI
SETZ AL
RET
LAB_00101280:
MOV R8D,0x1
CMP RSI,0x3
JG 0x00101243
LAB_0010128c:
MOV EDI,0x1
CMP R8,RDI
SETZ AL
RET | /* func0(long, long) */
bool func0(long param_1,long param_2)
{
long lVar1;
long lVar2;
long lVar3;
if (param_1 < 4) {
lVar3 = 1;
}
else {
lVar1 = 2;
lVar3 = 1;
do {
if (param_1 % lVar1 == 0) {
lVar3 = param_1 / lVar1 + lVar1 + lVar3;
}
lVar1 = lVar1 + 1;
} while (lVar1 * lVar1 - param_1 == 0 || lVar1 * lVar1 < param_1);
}
if (param_2 < 4) {
return lVar3 == 1;
}
lVar2 = 2;
lVar1 = 1;
do {
if (param_2 % lVar2 == 0) {
lVar1 = param_2 / lVar2 + lVar2 + lVar1;
}
lVar2 = lVar2 + 1;
} while (lVar2 * lVar2 - param_2 == 0 || lVar2 * lVar2 < param_2);
return lVar3 == lVar1;
} |
656 | func0 |
#include <assert.h>
#include <string>
| int func0(std::string str1) {
int count_chars = 0;
for (int i = 0; i < str1.length(); i++) {
if ((i == (str1[i] - 'A')) ||
(i == (str1[i] - 'a'))) {
count_chars++;
}
}
return count_chars;
}
| int main() {
assert(func0("xbcefg") == 2);
assert(func0("ABcED") == 3);
assert(func0("AbgdeF") == 5);
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,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1290 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv@plt>
cmp %rax,%rbx
setb %al
test %al,%al
je 1484 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x9b>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 12f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
movzbl (%rax),%eax
movsbl %al,%eax
sub $0x41,%eax
cmp %eax,-0x14(%rbp)
je 146a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x81>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 12f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
movzbl (%rax),%eax
movsbl %al,%eax
sub $0x61,%eax
cmp %eax,-0x14(%rbp)
jne 1471 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x88>
mov $0x1,%eax
jmp 1476 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x8d>
mov $0x0,%eax
test %al,%al
je 147e <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x95>
addl $0x1,-0x18(%rbp)
addl $0x1,-0x14(%rbp)
jmp 1408 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f>
mov -0x18(%rbp),%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_18], 0
mov [rbp+var_14], 0
jmp short loc_13C8
loc_136A:
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]
movsx eax, al
sub eax, 41h ; 'A'
cmp [rbp+var_14], eax
jz short loc_13B0
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]
movsx eax, al
sub eax, 61h ; 'a'
cmp [rbp+var_14], eax
jnz short loc_13B7
loc_13B0:
mov eax, 1
jmp short loc_13BC
loc_13B7:
mov eax, 0
loc_13BC:
test al, al
jz short loc_13C4
add [rbp+var_18], 1
loc_13C4:
add [rbp+var_14], 1
loc_13C8:
mov eax, [rbp+var_14]
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 short loc_136A
mov eax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1)
{
unsigned int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v3 = 0;
for ( i = 0; i < (unsigned long long)std::string::length(a1); ++i )
{
if ( i == *(char *)std::string::operator[](a1, i) - 65 || i == *(char *)std::string::operator[](a1, i) - 97 )
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001013c8
LAB_0010136a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101250
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
SUB EAX,0x41
CMP dword ptr [RBP + -0x14],EAX
JZ 0x001013b0
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]
MOVSX EAX,AL
SUB EAX,0x61
CMP dword ptr [RBP + -0x14],EAX
JNZ 0x001013b7
LAB_001013b0:
MOV EAX,0x1
JMP 0x001013bc
LAB_001013b7:
MOV EAX,0x0
LAB_001013bc:
TEST AL,AL
JZ 0x001013c4
ADD dword ptr [RBP + -0x18],0x1
LAB_001013c4:
ADD dword ptr [RBP + -0x14],0x1
LAB_001013c8:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101210
CMP RBX,RAX
SETC AL
TEST AL,AL
JNZ 0x0010136a
MOV EAX,dword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::string) */
int func0(ulong param_1)
{
bool bVar1;
char *pcVar2;
ulong uVar3;
int4 local_20;
int4 local_1c;
local_20 = 0;
local_1c = 0;
do {
uVar3 = std::string::length();
if (uVar3 <= (ulong)(long)local_1c) {
return local_20;
}
pcVar2 = (char *)std::string::operator[](param_1);
if (local_1c == *pcVar2 + -0x41) {
LAB_001013b0:
bVar1 = true;
}
else {
pcVar2 = (char *)std::string::operator[](param_1);
if (local_1c == *pcVar2 + -0x61) goto LAB_001013b0;
bVar1 = false;
}
if (bVar1) {
local_20 = local_20 + 1;
}
local_1c = local_1c + 1;
} while( true );
} |
657 | func0 |
#include <assert.h>
#include <string>
| int func0(std::string str1) {
int count_chars = 0;
for (int i = 0; i < str1.length(); i++) {
if ((i == (str1[i] - 'A')) ||
(i == (str1[i] - 'a'))) {
count_chars++;
}
}
return count_chars;
}
| int main() {
assert(func0("xbcefg") == 2);
assert(func0("ABcED") == 3);
assert(func0("AbgdeF") == 5);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%r8
test %r8,%r8
je 1225 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3c>
mov (%rdi),%rdi
mov $0x0,%eax
mov $0x0,%esi
jmp 1211 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x28>
add $0x1,%esi
add $0x1,%rax
cmp %rax,%r8
je 122a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x41>
movsbl (%rdi,%rax,1),%edx
lea -0x41(%rdx),%ecx
cmp %eax,%ecx
je 1205 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1c>
sub $0x61,%edx
cmp %eax,%edx
jne 1208 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f>
jmp 1205 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1c>
mov $0x0,%esi
mov %esi,%eax
retq
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov r8, [rdi+8]
test r8, r8
jz short loc_1245
mov rdi, [rdi]
mov eax, 0
mov esi, 0
jmp short loc_1231
loc_1225:
add esi, 1
loc_1228:
add rax, 1
cmp r8, rax
jz short loc_124A
loc_1231:
movsx edx, byte ptr [rdi+rax]
lea ecx, [rdx-41h]
cmp ecx, eax
jz short loc_1225
sub edx, 61h ; 'a'
cmp edx, eax
jnz short loc_1228
jmp short loc_1225
loc_1245:
mov esi, 0
loc_124A:
mov eax, esi
retn | long long func0(long long *a1)
{
long long v1; // r8
long long v2; // rdi
long long v3; // rax
unsigned int v4; // esi
int v5; // edx
v1 = a1[1];
if ( v1 )
{
v2 = *a1;
v3 = 0LL;
v4 = 0;
do
{
v5 = *(char *)(v2 + v3);
if ( v5 - 65 == (_DWORD)v3 || v5 - 97 == (_DWORD)v3 )
++v4;
++v3;
}
while ( v1 != v3 );
}
else
{
return 0;
}
return v4;
} | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
TEST R8,R8
JZ 0x00101245
MOV RDI,qword ptr [RDI]
MOV EAX,0x0
MOV ESI,0x0
JMP 0x00101231
LAB_00101225:
ADD ESI,0x1
LAB_00101228:
ADD RAX,0x1
CMP R8,RAX
JZ 0x0010124a
LAB_00101231:
MOVSX EDX,byte ptr [RDI + RAX*0x1]
LEA ECX,[RDX + -0x41]
CMP ECX,EAX
JZ 0x00101225
SUB EDX,0x61
CMP EDX,EAX
JNZ 0x00101228
JMP 0x00101225
LAB_00101245:
MOV ESI,0x0
LAB_0010124a:
MOV EAX,ESI
RET | /* func0(std::string) */
int func0(long *param_1)
{
long lVar1;
int iVar2;
if (param_1[1] == 0) {
iVar2 = 0;
}
else {
lVar1 = 0;
iVar2 = 0;
do {
if ((*(char *)(*param_1 + lVar1) + -0x41 == (int)lVar1) ||
(*(char *)(*param_1 + lVar1) + -0x61 == (int)lVar1)) {
iVar2 = iVar2 + 1;
}
lVar1 = lVar1 + 1;
} while (param_1[1] != lVar1);
}
return iVar2;
} |
658 | func0 |
#include <assert.h>
#include <string>
| int func0(std::string str1) {
int count_chars = 0;
for (int i = 0; i < str1.length(); i++) {
if ((i == (str1[i] - 'A')) ||
(i == (str1[i] - 'a'))) {
count_chars++;
}
}
return count_chars;
}
| int main() {
assert(func0("xbcefg") == 2);
assert(func0("ABcED") == 3);
assert(func0("AbgdeF") == 5);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
test %rsi,%rsi
je 1450 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x50>
mov (%rdi),%rdi
xor %eax,%eax
xor %r8d,%r8d
jmp 1430 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x30>
nopw 0x0(%rax,%rax,1)
sub $0x61,%edx
cmp %eax,%edx
je 143b <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3b>
add $0x1,%rax
cmp %rsi,%rax
je 1448 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x48>
movsbl (%rdi,%rax,1),%edx
lea -0x41(%rdx),%ecx
cmp %eax,%ecx
jne 1420 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x20>
add $0x1,%rax
add $0x1,%r8d
cmp %rsi,%rax
jne 1430 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x30>
mov %r8d,%eax
retq
nopl 0x0(%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov r8, [rdi+8]
test r8, r8
jz short loc_1380
mov rdi, [rdi]
xor eax, eax
xor esi, esi
jmp short loc_1360
loc_1350:
sub edx, 61h ; 'a'
cmp eax, edx
jz short loc_136B
add rax, 1
cmp r8, rax
jz short loc_1377
loc_1360:
movsx edx, byte ptr [rdi+rax]
lea ecx, [rdx-41h]
cmp eax, ecx
jnz short loc_1350
loc_136B:
add rax, 1
add esi, 1
cmp r8, rax
jnz short loc_1360
loc_1377:
mov eax, esi
retn
loc_1380:
xor esi, esi
mov eax, esi
retn | long long func0(long long *a1)
{
long long v1; // r8
long long v2; // rdi
long long v3; // rax
unsigned int v4; // esi
int v5; // edx
v1 = a1[1];
if ( !v1 )
return 0LL;
v2 = *a1;
v3 = 0LL;
v4 = 0;
do
{
while ( 1 )
{
v5 = *(char *)(v2 + v3);
if ( (_DWORD)v3 == v5 - 65 || (_DWORD)v3 == v5 - 97 )
break;
if ( v1 == ++v3 )
return v4;
}
++v3;
++v4;
}
while ( v1 != v3 );
return v4;
} | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
TEST R8,R8
JZ 0x00101380
MOV RDI,qword ptr [RDI]
XOR EAX,EAX
XOR ESI,ESI
JMP 0x00101360
LAB_00101350:
SUB EDX,0x61
CMP EAX,EDX
JZ 0x0010136b
ADD RAX,0x1
CMP R8,RAX
JZ 0x00101377
LAB_00101360:
MOVSX EDX,byte ptr [RDI + RAX*0x1]
LEA ECX,[RDX + -0x41]
CMP EAX,ECX
JNZ 0x00101350
LAB_0010136b:
ADD RAX,0x1
ADD ESI,0x1
CMP R8,RAX
JNZ 0x00101360
LAB_00101377:
MOV EAX,ESI
RET
LAB_00101380:
XOR ESI,ESI
MOV EAX,ESI
RET | /* func0(std::string) */
int func0(long *param_1)
{
long lVar1;
long lVar2;
int iVar3;
lVar1 = param_1[1];
if (lVar1 == 0) {
return 0;
}
lVar2 = 0;
iVar3 = 0;
do {
while( true ) {
if (((int)lVar2 == *(char *)(*param_1 + lVar2) + -0x41) ||
((int)lVar2 == *(char *)(*param_1 + lVar2) + -0x61)) break;
lVar2 = lVar2 + 1;
if (lVar1 == lVar2) {
return iVar3;
}
}
lVar2 = lVar2 + 1;
iVar3 = iVar3 + 1;
} while (lVar1 != lVar2);
return iVar3;
} |
659 | func0 |
#include <assert.h>
#include <string>
| int func0(std::string str1) {
int count_chars = 0;
for (int i = 0; i < str1.length(); i++) {
if ((i == (str1[i] - 'A')) ||
(i == (str1[i] - 'a'))) {
count_chars++;
}
}
return count_chars;
}
| int main() {
assert(func0("xbcefg") == 2);
assert(func0("ABcED") == 3);
assert(func0("AbgdeF") == 5);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%r9
test %r9,%r9
je 1c58 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x228>
lea -0x1(%r9),%rax
mov (%rdi),%rdi
cmp $0xe,%rax
jbe 1c5f <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x22f>
movdqa 0x686(%rip),%xmm2
mov %r9,%rdx
mov %rdi,%rax
movdqa 0x6c7(%rip),%xmm11
movdqa 0x6ce(%rip),%xmm10
and $0xfffffffffffffff0,%rdx
movaps %xmm2,-0x18(%rsp)
pxor %xmm2,%xmm2
add %rdi,%rdx
movdqa %xmm2,%xmm9
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
pxor %xmm3,%xmm3
movdqa -0x18(%rsp),%xmm6
pxor %xmm12,%xmm12
movdqa %xmm11,%xmm15
movdqa %xmm11,%xmm14
movdqa %xmm11,%xmm13
movdqa 0x645(%rip),%xmm8
pcmpgtb %xmm0,%xmm3
movdqa %xmm0,%xmm1
movdqa %xmm6,%xmm5
add $0x10,%rax
paddd 0x61d(%rip),%xmm6
movdqa 0x635(%rip),%xmm7
paddd %xmm5,%xmm8
punpcklbw %xmm3,%xmm1
punpckhbw %xmm3,%xmm0
pxor %xmm3,%xmm3
movaps %xmm6,-0x18(%rsp)
pcmpgtw %xmm1,%xmm3
movdqa %xmm1,%xmm4
paddd %xmm5,%xmm7
movdqa 0x61b(%rip),%xmm6
pcmpgtw %xmm0,%xmm12
paddd %xmm5,%xmm6
punpcklwd %xmm3,%xmm4
punpckhwd %xmm3,%xmm1
movdqa %xmm0,%xmm3
paddd %xmm4,%xmm15
paddd %xmm10,%xmm4
punpcklwd %xmm12,%xmm3
paddd %xmm1,%xmm14
pcmpeqd %xmm5,%xmm4
paddd %xmm10,%xmm1
pcmpeqd %xmm15,%xmm5
punpckhwd %xmm12,%xmm0
paddd %xmm3,%xmm13
pcmpeqd %xmm8,%xmm1
movdqa %xmm11,%xmm12
paddd %xmm10,%xmm3
pcmpeqd %xmm14,%xmm8
pcmpeqd %xmm7,%xmm3
paddd %xmm0,%xmm12
pcmpeqd %xmm13,%xmm7
paddd %xmm10,%xmm0
movdqa %xmm5,%xmm15
pcmpeqd %xmm6,%xmm0
pcmpeqd %xmm12,%xmm6
movdqa %xmm8,%xmm14
pcmpeqd %xmm9,%xmm15
movdqa %xmm7,%xmm13
pcmpeqd %xmm9,%xmm14
movdqa %xmm6,%xmm12
pcmpeqd %xmm9,%xmm13
pcmpeqd %xmm9,%xmm12
pand %xmm15,%xmm4
por %xmm4,%xmm5
pand %xmm14,%xmm1
psubd %xmm5,%xmm2
por %xmm1,%xmm8
pand %xmm13,%xmm3
psubd %xmm8,%xmm2
por %xmm3,%xmm7
pand %xmm12,%xmm0
psubd %xmm7,%xmm2
por %xmm0,%xmm6
psubd %xmm6,%xmm2
cmp %rdx,%rax
jne 1a90 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x60>
movdqa %xmm2,%xmm0
mov %r9,%rax
psrldq $0x8,%xmm0
and $0xfffffffffffffff0,%rax
paddd %xmm0,%xmm2
mov %eax,%edx
movdqa %xmm2,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm2
movd %xmm2,%r8d
cmp %rax,%r9
je 1c4f <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x21f>
movslq %edx,%rcx
add $0x1,%rcx
jmp 1c31 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x201>
nopl 0x0(%rax,%rax,1)
sub $0x61,%eax
cmp %eax,%edx
je 1c3c <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x20c>
add $0x1,%edx
lea 0x1(%rcx),%rsi
mov %rcx,%rax
cmp %rcx,%r9
jbe 1c4f <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x21f>
mov %rsi,%rcx
movsbl (%rdi,%rax,1),%eax
lea -0x41(%rax),%esi
cmp %esi,%edx
jne 1c18 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1e8>
add $0x1,%r8d
add $0x1,%edx
lea 0x1(%rcx),%rsi
mov %rcx,%rax
cmp %rcx,%r9
ja 1c2e <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1fe>
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
xor %edx,%edx
xor %r8d,%r8d
xor %eax,%eax
jmp 1c0a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1da>
nopl 0x0(%rax,%rax,1)
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
test rsi, rsi
jz loc_2710
lea rax, [rsi-1]
mov rdi, [rdi]
cmp rax, 0Eh
jbe loc_2713
mov rcx, rsi
pxor xmm2, xmm2
pxor xmm15, xmm15
mov rax, rdi
and rcx, 0FFFFFFFFFFFFFFF0h
movdqa xmm5, xmm2
movdqa xmm11, cs:xmmword_30C0
movdqa xmm10, cs:xmmword_3110
movdqa xmm9, cs:xmmword_3120
lea rdx, [rdi+rcx]
movdqa xmm4, xmm2
movdqa xmm8, cs:xmmword_3130
nop dword ptr [rax]
loc_2288:
movdqu xmm0, xmmword ptr [rax]
pxor xmm2, xmm2
movdqa xmm14, xmm15
movdqa xmm3, cs:xmmword_30E0
movdqa xmm7, xmm11
add rax, 10h
movdqa xmm12, cs:xmmword_30F0
movdqa xmm13, cs:xmmword_3100
pcmpgtb xmm2, xmm0
movdqa xmm1, xmm0
paddd xmm3, xmm7
paddd xmm12, xmm7
paddd xmm13, xmm7
paddd xmm11, cs:xmmword_30D0
punpcklbw xmm1, xmm2
punpckhbw xmm0, xmm2
movdqa xmm2, xmm15
pcmpgtw xmm2, xmm1
pcmpgtw xmm14, xmm0
movdqa xmm6, xmm1
punpcklwd xmm6, xmm2
punpckhwd xmm1, xmm2
movdqa xmm2, xmm0
punpcklwd xmm2, xmm14
punpckhwd xmm0, xmm14
movdqa xmm14, xmm10
paddd xmm14, xmm1
paddd xmm1, xmm9
pcmpeqd xmm14, xmm3
pcmpeqd xmm3, xmm1
pcmpeqd xmm14, xmm5
pcmpeqd xmm3, xmm5
movdqa xmm1, xmm14
pand xmm1, xmm3
movdqa xmm3, xmm10
paddd xmm3, xmm2
paddd xmm2, xmm9
pandn xmm1, xmm8
pcmpeqd xmm3, xmm12
pcmpeqd xmm2, xmm12
movdqa xmm12, xmm10
paddd xmm12, xmm0
pcmpeqd xmm12, xmm13
pcmpeqd xmm2, xmm5
pcmpeqd xmm3, xmm5
pcmpeqd xmm12, xmm5
pand xmm3, xmm2
movdqa xmm2, xmm0
paddd xmm2, xmm9
pandn xmm3, xmm8
pcmpeqd xmm2, xmm13
movdqa xmm0, xmm12
pcmpeqd xmm2, xmm5
pand xmm0, xmm2
movdqa xmm2, xmm10
paddd xmm2, xmm6
paddd xmm6, xmm9
pandn xmm0, xmm8
pcmpeqd xmm2, xmm7
pcmpeqd xmm6, xmm7
pcmpeqd xmm2, xmm5
pcmpeqd xmm6, xmm5
pand xmm2, xmm6
pandn xmm2, xmm8
paddd xmm2, xmm4
movdqa xmm4, xmm0
paddd xmm1, xmm2
paddd xmm3, xmm1
paddd xmm4, xmm3
cmp rdx, rax
jnz loc_2288
movdqa xmm0, xmm4
movdqa xmm2, xmm4
movdqa xmm5, xmm4
mov edx, ecx
psrldq xmm0, 8
psrldq xmm2, 8
paddd xmm0, xmm4
paddd xmm5, xmm2
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
cmp rsi, rcx
jz locret_2722
loc_2411:
mov r8, rsi
sub r8, rcx
lea r9, [r8-1]
cmp r9, 6
jbe loc_25A3
movq xmm2, qword ptr [rdi+rcx]
pxor xmm1, xmm1
lea eax, [rdx+1]
movd xmm6, edx
movq xmm12, cs:qword_3140
movd xmm7, eax
movq xmm11, qword ptr cs:xmmword_30E0
pcmpgtb xmm1, xmm2
movdqa xmm0, xmm2
punpckldq xmm6, xmm7
movq xmm10, cs:qword_3148
paddd xmm12, xmm6
pxor xmm7, xmm7
paddd xmm11, xmm6
paddd xmm10, xmm6
punpcklbw xmm2, xmm1
punpcklbw xmm0, xmm1
pxor xmm1, xmm1
pshufd xmm2, xmm2, 4Eh ; 'N'
movdqa xmm3, xmm1
movdqa xmm8, xmm0
pcmpgtw xmm1, xmm2
pcmpgtw xmm3, xmm0
movdqa xmm4, xmm2
punpcklwd xmm4, xmm1
punpcklwd xmm2, xmm1
punpcklwd xmm8, xmm3
movq xmm1, qword ptr cs:xmmword_3110
punpcklwd xmm0, xmm3
pshufd xmm2, xmm2, 4Eh ; 'N'
movq xmm3, qword ptr cs:xmmword_3120
pshufd xmm0, xmm0, 4Eh ; 'N'
movdqa xmm9, xmm1
paddd xmm9, xmm0
paddd xmm0, xmm3
pcmpeqd xmm9, xmm12
pcmpeqd xmm0, xmm12
pcmpeqd xmm9, xmm7
pcmpeqd xmm0, xmm7
pand xmm9, xmm0
movdqa xmm0, xmm1
paddd xmm0, xmm4
paddd xmm4, xmm3
pcmpeqd xmm0, xmm11
pcmpeqd xmm4, xmm11
pcmpeqd xmm0, xmm7
pcmpeqd xmm4, xmm7
pand xmm4, xmm0
movdqa xmm0, xmm1
paddd xmm1, xmm8
paddd xmm0, xmm2
paddd xmm2, xmm3
paddd xmm3, xmm8
pcmpeqd xmm1, xmm6
pcmpeqd xmm0, xmm10
pcmpeqd xmm2, xmm10
pcmpeqd xmm3, xmm6
pcmpeqd xmm1, xmm7
pcmpeqd xmm2, xmm7
pcmpeqd xmm0, xmm7
pcmpeqd xmm3, xmm7
pand xmm0, xmm2
pand xmm1, xmm3
movq xmm3, qword ptr cs:xmmword_3130
pandn xmm1, xmm3
pandn xmm9, xmm3
pandn xmm4, xmm3
paddd xmm5, xmm1
movdqa xmm2, xmm4
pandn xmm0, xmm3
paddd xmm9, xmm5
paddd xmm2, xmm9
paddd xmm0, xmm2
movd r9d, xmm0
pshufd xmm7, xmm0, 0E5h
movd eax, xmm7
add eax, r9d
mov r9, r8
and r9, 0FFFFFFFFFFFFFFF8h
add rcx, r9
add edx, r9d
and r8d, 7
jz locret_26AD
loc_25A3:
movsx ecx, byte ptr [rdi+rcx]
lea r8d, [rcx-41h]
cmp r8d, edx
jz loc_26B0
sub ecx, 61h ; 'a'
cmp ecx, edx
jz loc_26B0
loc_25BF:
lea r8d, [rdx+1]
movsxd rcx, r8d
cmp rcx, rsi
jnb locret_26AD
movsx ecx, byte ptr [rdi+rcx]
lea r9d, [rcx-41h]
cmp r8d, r9d
jz loc_26D0
sub ecx, 61h ; 'a'
cmp r8d, ecx
jz loc_26D0
loc_25EC:
lea r8d, [rdx+2]
movsxd rcx, r8d
cmp rcx, rsi
jnb locret_26AD
movsx ecx, byte ptr [rdi+rcx]
lea r9d, [rcx-41h]
cmp r8d, r9d
jz loc_26E0
sub ecx, 61h ; 'a'
cmp r8d, ecx
jz loc_26E0
loc_2619:
lea r8d, [rdx+3]
movsxd rcx, r8d
cmp rcx, rsi
jnb locret_26AD
movsx ecx, byte ptr [rdi+rcx]
lea r9d, [rcx-41h]
cmp r9d, r8d
jz loc_26F0
sub ecx, 61h ; 'a'
cmp ecx, r8d
jz loc_26F0
loc_2646:
lea r8d, [rdx+4]
movsxd rcx, r8d
cmp rcx, rsi
jnb short locret_26AD
movsx ecx, byte ptr [rdi+rcx]
lea r9d, [rcx-41h]
cmp r8d, r9d
jz loc_2700
sub ecx, 61h ; 'a'
cmp r8d, ecx
jz loc_2700
loc_266F:
lea r8d, [rdx+5]
movsxd rcx, r8d
cmp rcx, rsi
jnb short locret_26AD
movsx ecx, byte ptr [rdi+rcx]
lea r9d, [rcx-41h]
cmp r8d, r9d
jz short loc_26C0
sub ecx, 61h ; 'a'
cmp r8d, ecx
jz short loc_26C0
loc_2690:
add edx, 6
movsxd rcx, edx
cmp rcx, rsi
jnb short locret_26AD
movsx ecx, byte ptr [rdi+rcx]
lea esi, [rcx-41h]
cmp esi, edx
jz short loc_26C8
sub ecx, 61h ; 'a'
cmp ecx, edx
jz short loc_26C8
locret_26AD:
retn
loc_26B0:
add eax, 1
jmp loc_25BF
loc_26C0:
add eax, 1
jmp short loc_2690
loc_26C8:
add eax, 1
retn
loc_26D0:
add eax, 1
jmp loc_25EC
loc_26E0:
add eax, 1
jmp loc_2619
loc_26F0:
add eax, 1
jmp loc_2646
loc_2700:
add eax, 1
jmp loc_266F
loc_2710:
xor eax, eax
retn
loc_2713:
pxor xmm5, xmm5
xor edx, edx
xor eax, eax
xor ecx, ecx
jmp loc_2411
locret_2722:
retn | long long func0(const __m128i **a1)
{
unsigned long long v1; // rsi
const __m128i *v2; // rdi
const __m128i *v3; // rax
unsigned long long v4; // rcx
__m128i si128; // xmm11
__m128i v6; // xmm10
__m128i v7; // xmm9
__m128i v8; // xmm4
__m128i v9; // xmm8
__m128i v10; // xmm0
__m128i v11; // xmm7
__m128i v12; // xmm2
__m128i v13; // xmm3
__m128i v14; // xmm12
__m128i v15; // xmm13
__m128i v16; // xmm1
__m128i v17; // xmm0
__m128i v18; // xmm2
__m128i v19; // xmm14
__m128i v20; // xmm6
__m128i v21; // xmm1
__m128i v22; // xmm2
__m128i v23; // xmm0
unsigned int v24; // edx
__m128i v25; // xmm0
__m128i v26; // xmm5
long long result; // rax
unsigned long long v28; // r8
__m128i v29; // xmm2
__m128i v30; // xmm6
__m128i v31; // xmm12
__m128i v32; // xmm11
__m128i v33; // xmm10
__m128i v34; // xmm0
__m128i v35; // xmm2
__m128i v36; // xmm4
__m128i v37; // xmm8
__m128i v38; // xmm1
__m128i v39; // xmm2
__m128i v40; // xmm3
__m128i v41; // xmm0
__m128i v42; // xmm9
__m128i v43; // xmm4
__m128i v44; // xmm0
__m128i v45; // xmm2
__m128i v46; // xmm1
__m128i v47; // xmm3
__m128i v48; // xmm0
int v49; // ecx
signed int v50; // r8d
int v51; // ecx
signed int v52; // r8d
int v53; // ecx
signed int v54; // r8d
int v55; // ecx
signed int v56; // r8d
int v57; // ecx
signed int v58; // r8d
int v59; // ecx
signed int v60; // edx
int v61; // ecx
v1 = (unsigned long long)a1[1];
if ( !v1 )
return 0LL;
v2 = *a1;
if ( v1 - 1 <= 0xE )
{
v26 = 0LL;
v24 = 0;
result = 0LL;
v4 = 0LL;
}
else
{
v3 = v2;
v4 = v1 & 0xFFFFFFFFFFFFFFF0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_30C0);
v6 = _mm_load_si128((const __m128i *)&xmmword_3110);
v7 = _mm_load_si128((const __m128i *)&xmmword_3120);
v8 = 0LL;
v9 = _mm_load_si128((const __m128i *)&xmmword_3130);
do
{
v10 = _mm_loadu_si128(v3);
v11 = si128;
++v3;
v12 = _mm_cmpgt_epi8((__m128i)0LL, v10);
v13 = _mm_add_epi32(_mm_load_si128((const __m128i *)&xmmword_30E0), si128);
v14 = _mm_add_epi32(_mm_load_si128((const __m128i *)&xmmword_30F0), si128);
v15 = _mm_add_epi32(_mm_load_si128((const __m128i *)&xmmword_3100), si128);
si128 = _mm_add_epi32(si128, (__m128i)xmmword_30D0);
v16 = _mm_unpacklo_epi8(v10, v12);
v17 = _mm_unpackhi_epi8(v10, v12);
v18 = _mm_cmpgt_epi16((__m128i)0LL, v16);
v19 = _mm_cmpgt_epi16((__m128i)0LL, v17);
v20 = _mm_unpacklo_epi16(v16, v18);
v21 = _mm_unpackhi_epi16(v16, v18);
v22 = _mm_unpacklo_epi16(v17, v19);
v23 = _mm_unpackhi_epi16(v17, v19);
v8 = _mm_add_epi32(
_mm_andnot_si128(
_mm_and_si128(
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v6, v23), v15), (__m128i)0LL),
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v23, v7), v15), (__m128i)0LL)),
v9),
_mm_add_epi32(
_mm_andnot_si128(
_mm_and_si128(
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v6, v22), v14), (__m128i)0LL),
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v22, v7), v14), (__m128i)0LL)),
v9),
_mm_add_epi32(
_mm_andnot_si128(
_mm_and_si128(
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v6, v21), v13), (__m128i)0LL),
_mm_cmpeq_epi32(_mm_cmpeq_epi32(v13, _mm_add_epi32(v21, v7)), (__m128i)0LL)),
v9),
_mm_add_epi32(
_mm_andnot_si128(
_mm_and_si128(
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v6, v20), v11), (__m128i)0LL),
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v20, v7), v11), (__m128i)0LL)),
v9),
v8))));
}
while ( &v2->m128i_i8[v1 & 0xFFFFFFFFFFFFFFF0LL] != (__int8 *)v3 );
v24 = v1 & 0xFFFFFFF0;
v25 = _mm_add_epi32(_mm_srli_si128(v8, 8), v8);
v26 = _mm_add_epi32(v8, _mm_srli_si128(v8, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v25, _mm_srli_si128(v25, 4)));
if ( v1 == v4 )
return result;
}
v28 = v1 - v4;
if ( v1 - v4 - 1 <= 6 )
goto LABEL_8;
v29 = _mm_loadl_epi64((const __m128i *)((char *)v2 + v4));
v30 = _mm_unpacklo_epi32(_mm_cvtsi32_si128(v24), _mm_cvtsi32_si128(v24 + 1));
v31 = _mm_add_epi32(_mm_loadl_epi64((const __m128i *)&qword_3140), v30);
v32 = _mm_add_epi32(_mm_loadl_epi64((const __m128i *)&xmmword_30E0), v30);
v33 = _mm_add_epi32(_mm_loadl_epi64((const __m128i *)&qword_3148), v30);
v34 = _mm_unpacklo_epi8(v29, _mm_cmpgt_epi8((__m128i)0LL, v29));
v35 = _mm_shuffle_epi32(v34, 78);
v36 = _mm_unpacklo_epi16(v35, _mm_cmpgt_epi16((__m128i)0LL, v35));
v37 = _mm_unpacklo_epi16(v34, _mm_cmpgt_epi16((__m128i)0LL, v34));
v38 = _mm_loadl_epi64((const __m128i *)&xmmword_3110);
v39 = _mm_shuffle_epi32(v36, 78);
v40 = _mm_loadl_epi64((const __m128i *)&xmmword_3120);
v41 = _mm_shuffle_epi32(v37, 78);
v42 = _mm_and_si128(
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v38, v41), v31), (__m128i)0LL),
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v41, v40), v31), (__m128i)0LL));
v43 = _mm_and_si128(
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v36, v40), v32), (__m128i)0LL),
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v38, v36), v32), (__m128i)0LL));
v44 = _mm_add_epi32(v38, v39);
v45 = _mm_add_epi32(v39, v40);
v46 = _mm_and_si128(
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v38, v37), v30), (__m128i)0LL),
_mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_add_epi32(v40, v37), v30), (__m128i)0LL));
v47 = _mm_loadl_epi64((const __m128i *)&xmmword_3130);
v48 = _mm_add_epi32(
_mm_andnot_si128(
_mm_and_si128(
_mm_cmpeq_epi32(_mm_cmpeq_epi32(v44, v33), (__m128i)0LL),
_mm_cmpeq_epi32(_mm_cmpeq_epi32(v45, v33), (__m128i)0LL)),
v47),
_mm_add_epi32(
_mm_andnot_si128(v43, v47),
_mm_add_epi32(_mm_andnot_si128(v42, v47), _mm_add_epi32(v26, _mm_andnot_si128(v46, v47)))));
result = (unsigned int)(_mm_cvtsi128_si32(v48) + _mm_cvtsi128_si32(_mm_shuffle_epi32(v48, 229)));
v4 += v28 & 0xFFFFFFFFFFFFFFF8LL;
v24 += v28 & 0xFFFFFFF8;
if ( (v28 & 7) != 0 )
{
LABEL_8:
v49 = v2->m128i_i8[v4];
if ( v49 - 65 == v24 || v49 - 97 == v24 )
result = (unsigned int)(result + 1);
v50 = v24 + 1;
if ( (int)(v24 + 1) < v1 )
{
v51 = v2->m128i_i8[v50];
if ( v50 == v51 - 65 || v50 == v51 - 97 )
result = (unsigned int)(result + 1);
v52 = v24 + 2;
if ( (int)(v24 + 2) < v1 )
{
v53 = v2->m128i_i8[v52];
if ( v52 == v53 - 65 || v52 == v53 - 97 )
result = (unsigned int)(result + 1);
v54 = v24 + 3;
if ( (int)(v24 + 3) < v1 )
{
v55 = v2->m128i_i8[v54];
if ( v55 - 65 == v54 || v55 - 97 == v54 )
result = (unsigned int)(result + 1);
v56 = v24 + 4;
if ( (int)(v24 + 4) < v1 )
{
v57 = v2->m128i_i8[v56];
if ( v56 == v57 - 65 || v56 == v57 - 97 )
result = (unsigned int)(result + 1);
v58 = v24 + 5;
if ( (int)(v24 + 5) < v1 )
{
v59 = v2->m128i_i8[v58];
if ( v58 == v59 - 65 || v58 == v59 - 97 )
result = (unsigned int)(result + 1);
v60 = v24 + 6;
if ( v60 < v1 )
{
v61 = v2->m128i_i8[v60];
if ( v61 - 65 == v60 || v61 - 97 == v60 )
return (unsigned int)(result + 1);
}
}
}
}
}
}
}
return result;
} | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x00102710
LEA RAX,[RSI + -0x1]
MOV RDI,qword ptr [RDI]
CMP RAX,0xe
JBE 0x00102713
MOV RCX,RSI
PXOR XMM2,XMM2
PXOR XMM15,XMM15
MOV RAX,RDI
AND RCX,-0x10
MOVDQA XMM5,XMM2
MOVDQA XMM11,xmmword ptr [0x001030c0]
MOVDQA XMM10,xmmword ptr [0x00103110]
MOVDQA XMM9,xmmword ptr [0x00103120]
LEA RDX,[RDI + RCX*0x1]
MOVDQA XMM4,XMM2
MOVDQA XMM8,xmmword ptr [0x00103130]
NOP dword ptr [RAX]
LAB_00102288:
MOVDQU XMM0,xmmword ptr [RAX]
PXOR XMM2,XMM2
MOVDQA XMM14,XMM15
MOVDQA XMM3,xmmword ptr [0x001030e0]
MOVDQA XMM7,XMM11
ADD RAX,0x10
MOVDQA XMM12,xmmword ptr [0x001030f0]
MOVDQA XMM13,xmmword ptr [0x00103100]
PCMPGTB XMM2,XMM0
MOVDQA XMM1,XMM0
PADDD XMM3,XMM7
PADDD XMM12,XMM7
PADDD XMM13,XMM7
PADDD XMM11,xmmword ptr [0x001030d0]
PUNPCKLBW XMM1,XMM2
PUNPCKHBW XMM0,XMM2
MOVDQA XMM2,XMM15
PCMPGTW XMM2,XMM1
PCMPGTW XMM14,XMM0
MOVDQA XMM6,XMM1
PUNPCKLWD XMM6,XMM2
PUNPCKHWD XMM1,XMM2
MOVDQA XMM2,XMM0
PUNPCKLWD XMM2,XMM14
PUNPCKHWD XMM0,XMM14
MOVDQA XMM14,XMM10
PADDD XMM14,XMM1
PADDD XMM1,XMM9
PCMPEQD XMM14,XMM3
PCMPEQD XMM3,XMM1
PCMPEQD XMM14,XMM5
PCMPEQD XMM3,XMM5
MOVDQA XMM1,XMM14
PAND XMM1,XMM3
MOVDQA XMM3,XMM10
PADDD XMM3,XMM2
PADDD XMM2,XMM9
PANDN XMM1,XMM8
PCMPEQD XMM3,XMM12
PCMPEQD XMM2,XMM12
MOVDQA XMM12,XMM10
PADDD XMM12,XMM0
PCMPEQD XMM12,XMM13
PCMPEQD XMM2,XMM5
PCMPEQD XMM3,XMM5
PCMPEQD XMM12,XMM5
PAND XMM3,XMM2
MOVDQA XMM2,XMM0
PADDD XMM2,XMM9
PANDN XMM3,XMM8
PCMPEQD XMM2,XMM13
MOVDQA XMM0,XMM12
PCMPEQD XMM2,XMM5
PAND XMM0,XMM2
MOVDQA XMM2,XMM10
PADDD XMM2,XMM6
PADDD XMM6,XMM9
PANDN XMM0,XMM8
PCMPEQD XMM2,XMM7
PCMPEQD XMM6,XMM7
PCMPEQD XMM2,XMM5
PCMPEQD XMM6,XMM5
PAND XMM2,XMM6
PANDN XMM2,XMM8
PADDD XMM2,XMM4
MOVDQA XMM4,XMM0
PADDD XMM1,XMM2
PADDD XMM3,XMM1
PADDD XMM4,XMM3
CMP RDX,RAX
JNZ 0x00102288
MOVDQA XMM0,XMM4
MOVDQA XMM2,XMM4
MOVDQA XMM5,XMM4
MOV EDX,ECX
PSRLDQ XMM0,0x8
PSRLDQ XMM2,0x8
PADDD XMM0,XMM4
PADDD XMM5,XMM2
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
CMP RSI,RCX
JZ 0x00102722
LAB_00102411:
MOV R8,RSI
SUB R8,RCX
LEA R9,[R8 + -0x1]
CMP R9,0x6
JBE 0x001025a3
MOVQ XMM2,qword ptr [RDI + RCX*0x1]
PXOR XMM1,XMM1
LEA EAX,[RDX + 0x1]
MOVD XMM6,EDX
MOVQ XMM12,qword ptr [0x00103140]
MOVD XMM7,EAX
MOVQ XMM11,qword ptr [0x001030e0]
PCMPGTB XMM1,XMM2
MOVDQA XMM0,XMM2
PUNPCKLDQ XMM6,XMM7
MOVQ XMM10,qword ptr [0x00103148]
PADDD XMM12,XMM6
PXOR XMM7,XMM7
PADDD XMM11,XMM6
PADDD XMM10,XMM6
PUNPCKLBW XMM2,XMM1
PUNPCKLBW XMM0,XMM1
PXOR XMM1,XMM1
PSHUFD XMM2,XMM2,0x4e
MOVDQA XMM3,XMM1
MOVDQA XMM8,XMM0
PCMPGTW XMM1,XMM2
PCMPGTW XMM3,XMM0
MOVDQA XMM4,XMM2
PUNPCKLWD XMM4,XMM1
PUNPCKLWD XMM2,XMM1
PUNPCKLWD XMM8,XMM3
MOVQ XMM1,qword ptr [0x00103110]
PUNPCKLWD XMM0,XMM3
PSHUFD XMM2,XMM2,0x4e
MOVQ XMM3,qword ptr [0x00103120]
PSHUFD XMM0,XMM0,0x4e
MOVDQA XMM9,XMM1
PADDD XMM9,XMM0
PADDD XMM0,XMM3
PCMPEQD XMM9,XMM12
PCMPEQD XMM0,XMM12
PCMPEQD XMM9,XMM7
PCMPEQD XMM0,XMM7
PAND XMM9,XMM0
MOVDQA XMM0,XMM1
PADDD XMM0,XMM4
PADDD XMM4,XMM3
PCMPEQD XMM0,XMM11
PCMPEQD XMM4,XMM11
PCMPEQD XMM0,XMM7
PCMPEQD XMM4,XMM7
PAND XMM4,XMM0
MOVDQA XMM0,XMM1
PADDD XMM1,XMM8
PADDD XMM0,XMM2
PADDD XMM2,XMM3
PADDD XMM3,XMM8
PCMPEQD XMM1,XMM6
PCMPEQD XMM0,XMM10
PCMPEQD XMM2,XMM10
PCMPEQD XMM3,XMM6
PCMPEQD XMM1,XMM7
PCMPEQD XMM2,XMM7
PCMPEQD XMM0,XMM7
PCMPEQD XMM3,XMM7
PAND XMM0,XMM2
PAND XMM1,XMM3
MOVQ XMM3,qword ptr [0x00103130]
PANDN XMM1,XMM3
PANDN XMM9,XMM3
PANDN XMM4,XMM3
PADDD XMM5,XMM1
MOVDQA XMM2,XMM4
PANDN XMM0,XMM3
PADDD XMM9,XMM5
PADDD XMM2,XMM9
PADDD XMM0,XMM2
MOVD R9D,XMM0
PSHUFD XMM7,XMM0,0xe5
MOVD EAX,XMM7
ADD EAX,R9D
MOV R9,R8
AND R9,-0x8
ADD RCX,R9
ADD EDX,R9D
AND R8D,0x7
JZ 0x001026ad
LAB_001025a3:
MOVSX ECX,byte ptr [RDI + RCX*0x1]
LEA R8D,[RCX + -0x41]
CMP R8D,EDX
JZ 0x001026b0
SUB ECX,0x61
CMP ECX,EDX
JZ 0x001026b0
LAB_001025bf:
LEA R8D,[RDX + 0x1]
MOVSXD RCX,R8D
CMP RCX,RSI
JNC 0x001026ad
MOVSX ECX,byte ptr [RDI + RCX*0x1]
LEA R9D,[RCX + -0x41]
CMP R8D,R9D
JZ 0x001026d0
SUB ECX,0x61
CMP R8D,ECX
JZ 0x001026d0
LAB_001025ec:
LEA R8D,[RDX + 0x2]
MOVSXD RCX,R8D
CMP RCX,RSI
JNC 0x001026ad
MOVSX ECX,byte ptr [RDI + RCX*0x1]
LEA R9D,[RCX + -0x41]
CMP R8D,R9D
JZ 0x001026e0
SUB ECX,0x61
CMP R8D,ECX
JZ 0x001026e0
LAB_00102619:
LEA R8D,[RDX + 0x3]
MOVSXD RCX,R8D
CMP RCX,RSI
JNC 0x001026ad
MOVSX ECX,byte ptr [RDI + RCX*0x1]
LEA R9D,[RCX + -0x41]
CMP R9D,R8D
JZ 0x001026f0
SUB ECX,0x61
CMP ECX,R8D
JZ 0x001026f0
LAB_00102646:
LEA R8D,[RDX + 0x4]
MOVSXD RCX,R8D
CMP RCX,RSI
JNC 0x001026ad
MOVSX ECX,byte ptr [RDI + RCX*0x1]
LEA R9D,[RCX + -0x41]
CMP R8D,R9D
JZ 0x00102700
SUB ECX,0x61
CMP R8D,ECX
JZ 0x00102700
LAB_0010266f:
LEA R8D,[RDX + 0x5]
MOVSXD RCX,R8D
CMP RCX,RSI
JNC 0x001026ad
MOVSX ECX,byte ptr [RDI + RCX*0x1]
LEA R9D,[RCX + -0x41]
CMP R8D,R9D
JZ 0x001026c0
SUB ECX,0x61
CMP R8D,ECX
JZ 0x001026c0
LAB_00102690:
ADD EDX,0x6
MOVSXD RCX,EDX
CMP RCX,RSI
JNC 0x001026ad
MOVSX ECX,byte ptr [RDI + RCX*0x1]
LEA ESI,[RCX + -0x41]
CMP ESI,EDX
JZ 0x001026c8
SUB ECX,0x61
CMP ECX,EDX
JZ 0x001026c8
LAB_001026ad:
RET
LAB_001026b0:
ADD EAX,0x1
JMP 0x001025bf
LAB_001026c0:
ADD EAX,0x1
JMP 0x00102690
LAB_001026c8:
ADD EAX,0x1
RET
LAB_001026d0:
ADD EAX,0x1
JMP 0x001025ec
LAB_001026e0:
ADD EAX,0x1
JMP 0x00102619
LAB_001026f0:
ADD EAX,0x1
JMP 0x00102646
LAB_00102700:
ADD EAX,0x1
JMP 0x0010266f
LAB_00102710:
XOR EAX,EAX
RET
LAB_00102713:
PXOR XMM5,XMM5
XOR EDX,EDX
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00102411
LAB_00102722:
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::string) */
int func0(int8 *param_1)
{
ulong uVar1;
ulong uVar2;
int (*pauVar3) [16];
int auVar4 [14];
int auVar5 [12];
unkbyte10 Var6;
int auVar7 [12];
int auVar8 [16];
int auVar9 [16];
int auVar10 [16];
int auVar11 [14];
int auVar12 [12];
int auVar13 [12];
int (*pauVar14) [16];
ulong uVar15;
uint uVar16;
ulong uVar17;
int2 uVar18;
int iVar20;
int iVar21;
short sVar40;
int iVar41;
char cVar43;
char cVar44;
char cVar45;
int auVar29 [16];
short sVar42;
int auVar37 [16];
char cVar46;
int iVar47;
char cVar58;
int iVar59;
int auVar49 [16];
int iVar60;
int auVar61 [12];
char cVar78;
short sVar79;
char cVar80;
char cVar81;
int uVar82;
int auVar67 [16];
int auVar75 [16];
int iVar84;
int iVar85;
int iVar90;
int iVar91;
int iVar92;
int iVar93;
int iVar94;
int iVar95;
int auVar99 [16];
int4 uVar19;
int6 uVar22;
int8 uVar23;
int auVar25 [12];
int auVar30 [16];
int auVar31 [16];
int auVar32 [16];
int auVar33 [16];
int auVar34 [16];
int auVar35 [16];
int auVar36 [16];
int auVar24 [12];
int auVar38 [16];
int auVar26 [14];
int auVar28 [16];
int auVar39 [16];
int auVar27 [16];
int auVar50 [16];
int auVar48 [12];
int auVar51 [16];
int auVar52 [16];
int auVar53 [16];
int auVar54 [16];
int auVar57 [16];
int auVar55 [16];
int auVar56 [16];
int auVar62 [16];
int auVar63 [16];
int auVar64 [16];
int auVar68 [16];
int auVar69 [16];
int auVar70 [16];
int auVar71 [16];
int auVar72 [16];
int auVar73 [16];
int auVar74 [16];
int auVar65 [16];
int auVar76 [16];
int auVar66 [16];
int auVar77 [16];
long lVar83;
int auVar86 [16];
int auVar87 [16];
int auVar88 [16];
int auVar89 [16];
int auVar96 [16];
int auVar97 [16];
int auVar98 [16];
int auVar100 [16];
int auVar101 [16];
uVar2 = param_1[1];
if (uVar2 == 0) {
return 0;
}
pauVar3 = (int (*) [16])*param_1;
if (uVar2 - 1 < 0xf) {
iVar93 = 0;
iVar94 = 0;
uVar16 = 0;
iVar21 = 0;
uVar15 = 0;
}
else {
uVar15 = uVar2 & 0xfffffffffffffff0;
iVar84 = 0;
iVar90 = 0;
iVar91 = 0;
iVar92 = 0;
pauVar14 = pauVar3;
iVar21 = _DAT_001030c0;
iVar93 = _UNK_001030c4;
iVar94 = _UNK_001030c8;
iVar85 = _UNK_001030cc;
do {
auVar28 = *pauVar14;
pauVar14 = pauVar14 + 1;
cVar46 = auVar28[0];
cVar58 = auVar28[8];
cVar43 = auVar28[9];
cVar44 = auVar28[10];
cVar45 = auVar28[0xb];
auVar56._0_14_ = auVar28._0_14_;
auVar56[0xe] = auVar28[7];
auVar56[0xf] = -(auVar28[7] < '\0');
auVar55._14_2_ = auVar56._14_2_;
auVar55._0_13_ = auVar28._0_13_;
auVar55[0xd] = -(auVar28[6] < '\0');
auVar54._13_3_ = auVar55._13_3_;
auVar54._0_12_ = auVar28._0_12_;
auVar54[0xc] = auVar28[6];
auVar53._12_4_ = auVar54._12_4_;
auVar53._0_11_ = auVar28._0_11_;
auVar53[0xb] = -(auVar28[5] < '\0');
auVar52._11_5_ = auVar53._11_5_;
auVar52._0_10_ = auVar28._0_10_;
auVar52[10] = auVar28[5];
auVar51._10_6_ = auVar52._10_6_;
auVar51._0_9_ = auVar28._0_9_;
auVar51[9] = -(auVar28[4] < '\0');
auVar50._9_7_ = auVar51._9_7_;
auVar50._0_8_ = auVar28._0_8_;
auVar50[8] = auVar28[4];
Var6 = CONCAT91(CONCAT81(auVar50._8_8_,-(auVar28[3] < '\0')),auVar28[3]);
auVar5._2_10_ = Var6;
auVar5[1] = -(auVar28[2] < '\0');
auVar5[0] = auVar28[2];
auVar4._2_12_ = auVar5;
auVar4[1] = -(auVar28[1] < '\0');
auVar4[0] = auVar28[1];
auVar49._0_2_ = CONCAT11(-(cVar46 < '\0'),cVar46);
auVar49._2_14_ = auVar4;
uVar18 = CONCAT11(-(cVar58 < '\0'),cVar58);
uVar19 = CONCAT13(-(cVar43 < '\0'),CONCAT12(cVar43,uVar18));
uVar22 = CONCAT15(-(cVar44 < '\0'),CONCAT14(cVar44,uVar19));
uVar23 = CONCAT17(-(cVar45 < '\0'),CONCAT16(cVar45,uVar22));
auVar24._0_10_ = CONCAT19(-(auVar28[0xc] < '\0'),CONCAT18(auVar28[0xc],uVar23));
auVar24[10] = auVar28[0xd];
auVar24[0xb] = -(auVar28[0xd] < '\0');
auVar26[0xc] = auVar28[0xe];
auVar26._0_12_ = auVar24;
auVar26[0xd] = -(auVar28[0xe] < '\0');
auVar27[0xe] = auVar28[0xf];
auVar27._0_14_ = auVar26;
auVar27[0xf] = -(auVar28[0xf] < '\0');
sVar42 = (short)Var6;
sVar40 = (short)((unkuint10)auVar24._0_10_ >> 0x40);
auVar98._0_12_ = auVar49._0_12_;
auVar98._12_2_ = sVar42;
auVar98._14_2_ = -(ushort)(sVar42 < 0);
auVar97._12_4_ = auVar98._12_4_;
auVar97._0_10_ = auVar49._0_10_;
auVar97._10_2_ = -(ushort)(auVar5._0_2_ < 0);
auVar96._10_6_ = auVar97._10_6_;
auVar96._0_8_ = auVar49._0_8_;
auVar96._8_2_ = auVar5._0_2_;
auVar7._4_8_ = auVar96._8_8_;
auVar7._2_2_ = -(ushort)(auVar4._0_2_ < 0);
auVar7._0_2_ = auVar4._0_2_;
iVar95 = CONCAT22(-(ushort)(cVar46 < '\0'),auVar49._0_2_);
iVar47 = CONCAT22(-(ushort)(auVar50._8_2_ < 0),auVar50._8_2_);
auVar48._0_8_ = CONCAT26(-(ushort)(auVar52._10_2_ < 0),CONCAT24(auVar52._10_2_,iVar47));
auVar48._8_2_ = auVar54._12_2_;
auVar48._10_2_ = -(ushort)(auVar54._12_2_ < 0);
auVar57._12_2_ = auVar55._14_2_;
auVar57._0_12_ = auVar48;
auVar57._14_2_ = -(ushort)(auVar50._8_8_ < 0);
auVar66._12_2_ = (short)((ulong)uVar23 >> 0x30);
auVar66._0_12_ = auVar24;
auVar66._14_2_ = -(ushort)(cVar45 < '\0');
auVar65._12_4_ = auVar66._12_4_;
auVar65._10_2_ = -(ushort)(cVar44 < '\0');
auVar65._0_10_ = auVar24._0_10_;
auVar64._10_6_ = auVar65._10_6_;
auVar64._8_2_ = (short)((uint6)uVar22 >> 0x20);
auVar64._0_8_ = uVar23;
auVar63._8_8_ = auVar64._8_8_;
auVar63._6_2_ = -(ushort)(cVar43 < '\0');
auVar63._0_6_ = uVar22;
auVar62._6_10_ = auVar63._6_10_;
auVar62._4_2_ = (short)((uint)uVar19 >> 0x10);
auVar62._0_4_ = uVar19;
iVar60 = CONCAT22(-(ushort)(cVar58 < '\0'),uVar18);
iVar20 = CONCAT22(-(ushort)(sVar40 < 0),sVar40);
auVar25._0_8_ = CONCAT26(-(ushort)(auVar24._10_2_ < 0),CONCAT24(auVar24._10_2_,iVar20));
auVar25._8_2_ = auVar26._12_2_;
auVar25._10_2_ = -(ushort)(auVar26._12_2_ < 0);
auVar28._12_2_ = auVar27._14_2_;
auVar28._0_12_ = auVar25;
auVar28._14_2_ = -(ushort)(auVar27._14_2_ < 0);
iVar59 = (int)((ulong)auVar48._0_8_ >> 0x20);
iVar41 = (int)((ulong)auVar25._0_8_ >> 0x20);
iVar84 = (~-(uint)((int)DAT_00103110 + iVar20 != _DAT_00103100 + iVar21 &&
iVar20 + (int)DAT_00103120 != _DAT_00103100 + iVar21) & (uint)DAT_00103130)
+ (~-(uint)((int)DAT_00103110 + iVar60 != _DAT_001030f0 + iVar21 &&
iVar60 + (int)DAT_00103120 != _DAT_001030f0 + iVar21) & (uint)DAT_00103130
) + (~-(uint)((int)DAT_00103110 + iVar47 != (int)DAT_001030e0 + iVar21 &&
(int)DAT_001030e0 + iVar21 != iVar47 + (int)DAT_00103120) &
(uint)DAT_00103130) +
(~-(uint)((int)DAT_00103110 + iVar95 != iVar21 &&
iVar95 + (int)DAT_00103120 != iVar21) & (uint)DAT_00103130) + iVar84;
iVar90 = (~-(uint)(DAT_00103110._4_4_ + iVar41 != _UNK_00103104 + iVar93 &&
iVar41 + DAT_00103120._4_4_ != _UNK_00103104 + iVar93) & DAT_00103130._4_4_)
+ (~-(uint)(DAT_00103110._4_4_ + auVar62._4_4_ != _UNK_001030f4 + iVar93 &&
auVar62._4_4_ + DAT_00103120._4_4_ != _UNK_001030f4 + iVar93) &
DAT_00103130._4_4_) +
(~-(uint)(DAT_00103110._4_4_ + iVar59 != DAT_001030e0._4_4_ + iVar93 &&
DAT_001030e0._4_4_ + iVar93 != iVar59 + DAT_00103120._4_4_) &
DAT_00103130._4_4_) +
(~-(uint)(DAT_00103110._4_4_ + auVar7._0_4_ != iVar93 &&
auVar7._0_4_ + DAT_00103120._4_4_ != iVar93) & DAT_00103130._4_4_) +
iVar90;
iVar91 = (~-(uint)(_UNK_00103118 + auVar25._8_4_ != _UNK_00103108 + iVar94 &&
auVar25._8_4_ + _UNK_00103128 != _UNK_00103108 + iVar94) & _UNK_00103138) +
(~-(uint)(_UNK_00103118 + auVar64._8_4_ != _UNK_001030f8 + iVar94 &&
auVar64._8_4_ + _UNK_00103128 != _UNK_001030f8 + iVar94) & _UNK_00103138) +
(~-(uint)(_UNK_00103118 + auVar48._8_4_ != _UNK_001030e8 + iVar94 &&
_UNK_001030e8 + iVar94 != auVar48._8_4_ + _UNK_00103128) & _UNK_00103138) +
(~-(uint)(_UNK_00103118 + auVar96._8_4_ != iVar94 &&
auVar96._8_4_ + _UNK_00103128 != iVar94) & _UNK_00103138) + iVar91;
iVar92 = (~-(uint)(_UNK_0010311c + auVar28._12_4_ != _UNK_0010310c + iVar85 &&
auVar28._12_4_ + _UNK_0010312c != _UNK_0010310c + iVar85) & _UNK_0010313c) +
(~-(uint)(_UNK_0010311c + auVar65._12_4_ != _UNK_001030fc + iVar85 &&
auVar65._12_4_ + _UNK_0010312c != _UNK_001030fc + iVar85) & _UNK_0010313c) +
(~-(uint)(_UNK_0010311c + auVar57._12_4_ != _UNK_001030ec + iVar85 &&
_UNK_001030ec + iVar85 != auVar57._12_4_ + _UNK_0010312c) & _UNK_0010313c) +
(~-(uint)(_UNK_0010311c + auVar97._12_4_ != iVar85 &&
auVar97._12_4_ + _UNK_0010312c != iVar85) & _UNK_0010313c) + iVar92;
iVar21 = iVar21 + _DAT_001030d0;
iVar93 = iVar93 + _UNK_001030d4;
iVar94 = iVar94 + _UNK_001030d8;
iVar85 = iVar85 + _UNK_001030dc;
} while ((int (*) [16])(*pauVar3 + uVar15) != pauVar14);
uVar16 = (uint)uVar2 & 0xfffffff0;
iVar93 = iVar84 + iVar91;
iVar94 = iVar90 + iVar92;
iVar21 = iVar91 + iVar84 + iVar92 + iVar90;
if (uVar2 == uVar15) {
return iVar21;
}
}
uVar17 = uVar2 - uVar15;
if (6 < uVar17 - 1) {
uVar1 = *(ulong *)(*pauVar3 + uVar15);
iVar21 = uVar16 + 1;
auVar67[0] = (char)uVar1;
cVar46 = -(auVar67[0] < '\0');
cVar43 = (char)(uVar1 >> 8);
cVar44 = (char)(uVar1 >> 0x10);
cVar45 = (char)(uVar1 >> 0x18);
cVar58 = -(cVar45 < '\0');
cVar78 = (char)(uVar1 >> 0x20);
cVar80 = (char)(uVar1 >> 0x28);
cVar81 = (char)(uVar1 >> 0x30);
uVar82 = (int)(uVar1 >> 0x38);
auVar74._8_6_ = 0;
auVar74._0_8_ = uVar1;
auVar74[0xe] = uVar82;
auVar74[0xf] = -((long)uVar1 < 0);
auVar73._14_2_ = auVar74._14_2_;
auVar73._8_5_ = 0;
auVar73._0_8_ = uVar1;
auVar73[0xd] = -(cVar81 < '\0');
auVar72._13_3_ = auVar73._13_3_;
auVar72._8_4_ = 0;
auVar72._0_8_ = uVar1;
auVar72[0xc] = cVar81;
auVar71._12_4_ = auVar72._12_4_;
auVar71._8_3_ = 0;
auVar71._0_8_ = uVar1;
auVar71[0xb] = -(cVar80 < '\0');
auVar70._11_5_ = auVar71._11_5_;
auVar70._8_2_ = 0;
auVar70._0_8_ = uVar1;
auVar70[10] = cVar80;
auVar69._10_6_ = auVar70._10_6_;
auVar69[8] = 0;
auVar69._0_8_ = uVar1;
auVar69[9] = -(cVar78 < '\0');
auVar68._9_7_ = auVar69._9_7_;
auVar68[8] = cVar78;
auVar68._0_8_ = uVar1;
lVar83 = auVar68._8_8_;
auVar10._1_8_ = lVar83;
auVar10[0] = cVar58;
auVar10._9_7_ = 0;
auVar9._10_6_ = 0;
auVar9._0_10_ = SUB1610(auVar10 << 0x38,6);
auVar8._11_5_ = 0;
auVar8._0_11_ = SUB1611(auVar9 << 0x30,5);
auVar67._4_12_ = SUB1612(auVar8 << 0x28,4);
auVar67[3] = -(cVar43 < '\0');
auVar67[2] = cVar43;
auVar67[1] = cVar46;
auVar36._8_6_ = 0;
auVar36._0_8_ = uVar1;
auVar36[0xe] = uVar82;
auVar36[0xf] = -((long)uVar1 < 0);
auVar35._14_2_ = auVar36._14_2_;
auVar35._8_5_ = 0;
auVar35._0_8_ = uVar1;
auVar35[0xd] = -(cVar81 < '\0');
auVar34._13_3_ = auVar35._13_3_;
auVar34._8_4_ = 0;
auVar34._0_8_ = uVar1;
auVar34[0xc] = cVar81;
auVar33._12_4_ = auVar34._12_4_;
auVar33._8_3_ = 0;
auVar33._0_8_ = uVar1;
auVar33[0xb] = -(cVar80 < '\0');
auVar32._11_5_ = auVar33._11_5_;
auVar32._8_2_ = 0;
auVar32._0_8_ = uVar1;
auVar32[10] = cVar80;
auVar31._10_6_ = auVar32._10_6_;
auVar31[8] = 0;
auVar31._0_8_ = uVar1;
auVar31[9] = -(cVar78 < '\0');
auVar30._9_7_ = auVar31._9_7_;
auVar30[8] = cVar78;
auVar30._0_8_ = uVar1;
Var6 = CONCAT91(CONCAT81(auVar30._8_8_,cVar58),cVar45);
auVar12._2_10_ = Var6;
auVar12[1] = -(cVar44 < '\0');
auVar12[0] = cVar44;
auVar11._2_12_ = auVar12;
auVar11[1] = -(cVar43 < '\0');
auVar11[0] = cVar43;
auVar29._0_2_ = CONCAT11(cVar46,auVar67[0]);
auVar29._2_14_ = auVar11;
auVar61._8_4_ = auVar67._0_4_;
auVar61._0_8_ = lVar83;
sVar79 = auVar72._12_2_;
sVar40 = auVar12._0_2_;
sVar42 = (short)Var6;
auVar89._12_2_ = auVar73._14_2_;
auVar89._0_12_ = auVar61;
auVar89._14_2_ = -(ushort)(lVar83 < 0);
auVar88._12_4_ = auVar89._12_4_;
auVar88._0_10_ = auVar61._0_10_;
auVar88._10_2_ = -(ushort)(sVar79 < 0);
auVar87._10_6_ = auVar88._10_6_;
auVar87._8_2_ = sVar79;
auVar87._0_8_ = lVar83;
auVar86._8_8_ = auVar87._8_8_;
auVar86._6_2_ = -(ushort)(auVar68._8_4_ < 0);
auVar86._4_2_ = auVar70._10_2_;
auVar86._0_4_ = auVar68._8_4_;
iVar85 = CONCAT22(-(ushort)(auVar68._8_2_ < 0),auVar68._8_2_);
auVar77._12_2_ = auVar73._14_2_;
auVar77._0_12_ = auVar61;
auVar77._14_2_ = -(ushort)(lVar83 < 0);
auVar76._12_4_ = auVar77._12_4_;
auVar76._10_2_ = -(ushort)(sVar79 < 0);
auVar76._0_10_ = auVar88._0_10_;
auVar75._10_6_ = auVar76._10_6_;
auVar75._8_2_ = sVar79;
auVar75._0_8_ = lVar83;
auVar101._0_12_ = auVar29._0_12_;
auVar101._12_2_ = sVar42;
auVar101._14_2_ = -(ushort)(sVar42 < 0);
auVar100._12_4_ = auVar101._12_4_;
auVar100._0_10_ = auVar29._0_10_;
auVar100._10_2_ = -(ushort)(sVar40 < 0);
auVar99._10_6_ = auVar100._10_6_;
auVar99._0_8_ = auVar29._0_8_;
auVar99._8_2_ = sVar40;
auVar13._4_8_ = auVar99._8_8_;
auVar13._2_2_ = -(ushort)(auVar11._0_2_ < 0);
auVar13._0_2_ = auVar11._0_2_;
iVar84 = CONCAT22(-(ushort)(auVar67[0] < '\0'),auVar29._0_2_);
auVar39._12_2_ = sVar42;
auVar39._0_12_ = auVar101._0_12_;
auVar39._14_2_ = -(ushort)(sVar42 < 0);
auVar38._12_4_ = auVar39._12_4_;
auVar38._10_2_ = -(ushort)(sVar40 < 0);
auVar38._0_10_ = auVar100._0_10_;
auVar37._10_6_ = auVar38._10_6_;
auVar37._8_2_ = sVar40;
auVar37._0_8_ = auVar99._0_8_;
iVar21 = (~-(uint)(DAT_00103110._4_4_ + auVar76._12_4_ != DAT_00103148._4_4_ + iVar21 &&
auVar76._12_4_ + DAT_00103120._4_4_ != DAT_00103148._4_4_ + iVar21) &
DAT_00103130._4_4_) +
(~-(uint)(auVar86._4_4_ + DAT_00103120._4_4_ != DAT_001030e0._4_4_ + iVar21 &&
DAT_00103110._4_4_ + auVar86._4_4_ != DAT_001030e0._4_4_ + iVar21) &
DAT_00103130._4_4_) +
(~-(uint)(DAT_00103110._4_4_ + auVar38._12_4_ != DAT_00103140._4_4_ + iVar21 &&
auVar38._12_4_ + DAT_00103120._4_4_ != DAT_00103140._4_4_ + iVar21) &
DAT_00103130._4_4_) +
iVar94 + (~-(uint)(DAT_00103110._4_4_ + auVar13._0_4_ != iVar21 &&
DAT_00103120._4_4_ + auVar13._0_4_ != iVar21) & DAT_00103130._4_4_) +
(~-(uint)((int)DAT_00103110 + auVar75._8_4_ != (int)DAT_00103148 + uVar16 &&
auVar75._8_4_ + (int)DAT_00103120 != (int)DAT_00103148 + uVar16) &
(uint)DAT_00103130) +
(~-(uint)(iVar85 + (int)DAT_00103120 != (int)DAT_001030e0 + uVar16 &&
(int)DAT_00103110 + iVar85 != (int)DAT_001030e0 + uVar16) & (uint)DAT_00103130
) + (~-(uint)((int)DAT_00103110 + auVar37._8_4_ != (int)DAT_00103140 + uVar16 &&
auVar37._8_4_ + (int)DAT_00103120 != (int)DAT_00103140 + uVar16) &
(uint)DAT_00103130) +
iVar93 + (~-(uint)((int)DAT_00103110 + iVar84 != uVar16 &&
(int)DAT_00103120 + iVar84 != uVar16) & (uint)DAT_00103130);
uVar15 = uVar15 + (uVar17 & 0xfffffffffffffff8);
uVar16 = uVar16 + (int)(uVar17 & 0xfffffffffffffff8);
if ((uVar17 & 7) == 0) {
return iVar21;
}
}
if (((int)(char)(*pauVar3)[uVar15] - 0x41U == uVar16) ||
((int)(char)(*pauVar3)[uVar15] - 0x61U == uVar16)) {
iVar21 = iVar21 + 1;
}
iVar93 = uVar16 + 1;
if ((ulong)(long)iVar93 < uVar2) {
if ((iVar93 == (char)(*pauVar3)[iVar93] + -0x41) || (iVar93 == (char)(*pauVar3)[iVar93] + -0x61)
) {
iVar21 = iVar21 + 1;
}
iVar93 = uVar16 + 2;
if ((ulong)(long)iVar93 < uVar2) {
if ((iVar93 == (char)(*pauVar3)[iVar93] + -0x41) ||
(iVar93 == (char)(*pauVar3)[iVar93] + -0x61)) {
iVar21 = iVar21 + 1;
}
iVar93 = uVar16 + 3;
if ((ulong)(long)iVar93 < uVar2) {
if (((char)(*pauVar3)[iVar93] + -0x41 == iVar93) ||
((char)(*pauVar3)[iVar93] + -0x61 == iVar93)) {
iVar21 = iVar21 + 1;
}
iVar93 = uVar16 + 4;
if ((ulong)(long)iVar93 < uVar2) {
if ((iVar93 == (char)(*pauVar3)[iVar93] + -0x41) ||
(iVar93 == (char)(*pauVar3)[iVar93] + -0x61)) {
iVar21 = iVar21 + 1;
}
iVar93 = uVar16 + 5;
if ((ulong)(long)iVar93 < uVar2) {
if ((iVar93 == (char)(*pauVar3)[iVar93] + -0x41) ||
(iVar93 == (char)(*pauVar3)[iVar93] + -0x61)) {
iVar21 = iVar21 + 1;
}
iVar93 = uVar16 + 6;
if (((ulong)(long)iVar93 < uVar2) &&
(((char)(*pauVar3)[iVar93] + -0x41 == iVar93 ||
((char)(*pauVar3)[iVar93] + -0x61 == iVar93)))) {
return iVar21 + 1;
}
}
}
}
}
}
return iVar21;
} |
660 | func0 |
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& A, int N) {
int evenPair = 0;
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
if ((A[i] ^ A[j]) % 2 == 0) {
evenPair++;
}
}
}
return evenPair;
}
| int main() {
assert(func0({5,4,7,2,1}, 5) == 4);
assert(func0({7,2,8,1,0,5,11}, 7) == 9);
assert(func0({1,2,3}, 3) == 1);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jge 12b0 <_Z5func0RKSt6vectorIiSaIiEEi+0x87>
mov -0x18(%rbp),%eax
add $0x1,%eax
mov %eax,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jge 12aa <_Z5func0RKSt6vectorIiSaIiEEi+0x81>
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 15a2 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 15a2 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
xor %ebx,%eax
and $0x1,%eax
test %eax,%eax
sete %al
test %al,%al
je 12a4 <_Z5func0RKSt6vectorIiSaIiEEi+0x7b>
addl $0x1,-0x1c(%rbp)
addl $0x1,-0x14(%rbp)
jmp 125c <_Z5func0RKSt6vectorIiSaIiEEi+0x33>
addl $0x1,-0x18(%rbp)
jmp 124b <_Z5func0RKSt6vectorIiSaIiEEi+0x22>
mov -0x1c(%rbp),%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
jmp short loc_12C8
loc_126D:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_12BC
loc_1278:
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
xor eax, ebx
and eax, 1
test eax, eax
setz al
test al, al
jz short loc_12B8
add [rbp+var_1C], 1
loc_12B8:
add [rbp+var_14], 1
loc_12BC:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl short loc_1278
add [rbp+var_18], 1
loc_12C8:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl short loc_126D
mov eax, [rbp+var_1C]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2)
{
int v2; // ebx
unsigned int v4; // [rsp+14h] [rbp-1Ch]
int i; // [rsp+18h] [rbp-18h]
int j; // [rsp+1Ch] [rbp-14h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
v2 = *(_DWORD *)std::vector<int>::operator[](a1, i);
if ( (((unsigned __int8)v2 ^ (unsigned __int8)*(_DWORD *)std::vector<int>::operator[](a1, j)) & 1) == 0 )
++v4;
}
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001012c8
LAB_0010126d:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001012bc
LAB_00101278:
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101606
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101606
MOV EAX,dword ptr [RAX]
XOR EAX,EBX
AND EAX,0x1
TEST EAX,EAX
SETZ AL
TEST AL,AL
JZ 0x001012b8
ADD dword ptr [RBP + -0x1c],0x1
LAB_001012b8:
ADD dword ptr [RBP + -0x14],0x1
LAB_001012bc:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101278
ADD dword ptr [RBP + -0x18],0x1
LAB_001012c8:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x0010126d
MOV EAX,dword ptr [RBP + -0x1c]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
uint uVar1;
uint *puVar2;
int4 local_24;
int4 local_20;
int4 local_1c;
local_24 = 0;
for (local_20 = 0; local_1c = local_20, local_20 < param_2; local_20 = local_20 + 1) {
while (local_1c = local_1c + 1, local_1c < param_2) {
puVar2 = (uint *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_20);
uVar1 = *puVar2;
puVar2 = (uint *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_1c);
if (((*puVar2 ^ uVar1) & 1) == 0) {
local_24 = local_24 + 1;
}
}
}
return local_24;
} |
661 | func0 |
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& A, int N) {
int evenPair = 0;
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
if ((A[i] ^ A[j]) % 2 == 0) {
evenPair++;
}
}
}
return evenPair;
}
| int main() {
assert(func0({5,4,7,2,1}, 5) == 4);
assert(func0({7,2,8,1,0,5,11}, 7) == 9);
assert(func0({1,2,3}, 3) == 1);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
test %esi,%esi
jle 1252 <_Z5func0RKSt6vectorIiSaIiEEi+0x49>
lea -0x1(%rsi),%r11d
add $0x1,%r11
mov $0x1,%r10d
mov $0x0,%ecx
cmp %r11,%r10
je 1257 <_Z5func0RKSt6vectorIiSaIiEEi+0x4e>
mov (%rdi),%r8
mov -0x4(%r8,%r10,4),%r9d
mov %r10,%rax
mov %r9d,%edx
xor (%r8,%rax,4),%edx
and $0x1,%edx
cmp $0x1,%edx
adc $0x0,%ecx
add $0x1,%rax
cmp %eax,%esi
jg 1234 <_Z5func0RKSt6vectorIiSaIiEEi+0x2b>
add $0x1,%r10
jmp 1224 <_Z5func0RKSt6vectorIiSaIiEEi+0x1b>
mov $0x0,%ecx
mov %ecx,%eax
retq
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
test esi, esi
jle short loc_1267
push rbp
push rbx
mov ebx, esi
movsxd rbp, esi
mov r11d, 0
mov r10d, 1
mov ecx, 0
jmp short loc_122E
loc_122B:
mov r10, rax
loc_122E:
cmp r10, rbx
jz short loc_1262
mov r8, [rdi]
mov r9d, [r8+r11]
mov rax, r10
loc_123D:
mov edx, r9d
xor edx, [r8+rax*4]
and edx, 1
cmp edx, 1
adc ecx, 0
add rax, 1
cmp esi, eax
jg short loc_123D
lea rax, [r10+1]
add r11, 4
cmp r10, rbp
jnz short loc_122B
loc_1262:
mov eax, ecx
pop rbx
pop rbp
retn
loc_1267:
mov ecx, 0
mov eax, ecx
retn | long long func0(_QWORD *a1, int a2)
{
long long v2; // r11
long long v3; // r10
unsigned int v4; // ecx
long long v5; // rax
if ( a2 <= 0 )
return 0LL;
v2 = 0LL;
v3 = 1LL;
v4 = 0;
while ( v3 != a2 )
{
v5 = v3;
do
v4 += ((*(_DWORD *)(*a1 + 4 * v5++) ^ *(_DWORD *)(*a1 + v2)) & 1) == 0;
while ( a2 > (int)v5 );
v2 += 4LL;
if ( v3 == a2 )
break;
++v3;
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101267
PUSH RBP
PUSH RBX
MOV EBX,ESI
MOVSXD RBP,ESI
MOV R11D,0x0
MOV R10D,0x1
MOV ECX,0x0
JMP 0x0010122e
LAB_0010122b:
MOV R10,RAX
LAB_0010122e:
CMP R10,RBX
JZ 0x00101262
MOV R8,qword ptr [RDI]
MOV R9D,dword ptr [R8 + R11*0x1]
MOV RAX,R10
LAB_0010123d:
MOV EDX,R9D
XOR EDX,dword ptr [R8 + RAX*0x4]
AND EDX,0x1
CMP EDX,0x1
ADC ECX,0x0
ADD RAX,0x1
CMP ESI,EAX
JG 0x0010123d
LEA RAX,[R10 + 0x1]
ADD R11,0x4
CMP R10,RBP
JNZ 0x0010122b
LAB_00101262:
MOV EAX,ECX
POP RBX
POP RBP
RET
LAB_00101267:
MOV ECX,0x0
MOV EAX,ECX
RET | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
long lVar4;
bool bVar5;
if (param_2 < 1) {
return 0;
}
lVar4 = 0;
iVar2 = 0;
uVar3 = 1;
do {
if (uVar3 == (uint)param_2) {
return iVar2;
}
uVar1 = uVar3;
do {
iVar2 = iVar2 + (uint)(((*(uint *)(*(long *)param_1 + lVar4) ^
*(uint *)(*(long *)param_1 + uVar1 * 4)) & 1) == 0);
uVar1 = uVar1 + 1;
} while ((int)uVar1 < param_2);
lVar4 = lVar4 + 4;
bVar5 = uVar3 != (long)param_2;
uVar3 = uVar3 + 1;
} while (bVar5);
return iVar2;
} |
662 | func0 |
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& A, int N) {
int evenPair = 0;
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
if ((A[i] ^ A[j]) % 2 == 0) {
evenPair++;
}
}
}
return evenPair;
}
| int main() {
assert(func0({5,4,7,2,1}, 5) == 4);
assert(func0({7,2,8,1,0,5,11}, 7) == 9);
assert(func0({1,2,3}, 3) == 1);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
test %esi,%esi
jle 14d5 <_Z5func0RKSt6vectorIiSaIiEEi+0x55>
lea -0x1(%rsi),%r11d
mov $0x1,%r10d
xor %r8d,%r8d
add $0x1,%r11
cmp %r11,%r10
je 14d1 <_Z5func0RKSt6vectorIiSaIiEEi+0x51>
xchg %ax,%ax
mov (%rdi),%rcx
mov %r10,%rax
mov -0x4(%rcx,%r10,4),%r9d
nopl 0x0(%rax,%rax,1)
mov (%rcx,%rax,4),%edx
xor %r9d,%edx
and $0x1,%edx
cmp $0x1,%edx
adc $0x0,%r8d
add $0x1,%rax
cmp %eax,%esi
jg 14b0 <_Z5func0RKSt6vectorIiSaIiEEi+0x30>
add $0x1,%r10
cmp %r11,%r10
jne 14a0 <_Z5func0RKSt6vectorIiSaIiEEi+0x20>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
test esi, esi
jle short loc_13F7
cmp esi, 1
jz short loc_13F7
mov rdi, [rdi]
mov r11d, esi
mov r9d, 1
xor r10d, r10d
xor ecx, ecx
xchg ax, ax
loc_13C0:
mov r8d, [rdi+r10]
mov rax, r9
nop word ptr [rax+rax+00000000h]
loc_13D0:
mov edx, [rdi+rax*4]
xor edx, r8d
and edx, 1
cmp edx, 1
adc ecx, 0
add rax, 1
cmp esi, eax
jg short loc_13D0
add r9, 1
add r10, 4
cmp r9, r11
jnz short loc_13C0
mov eax, ecx
retn
loc_13F7:
xor ecx, ecx
mov eax, ecx
retn | long long func0(long long *a1, int a2)
{
long long v2; // rdi
long long v3; // r9
long long v4; // r10
unsigned int v5; // ecx
long long v6; // rax
if ( a2 < 2 )
return 0LL;
v2 = *a1;
v3 = 1LL;
v4 = 0LL;
v5 = 0;
do
{
v6 = v3;
do
v5 += (((unsigned __int8)*(_DWORD *)(v2 + v4) ^ (unsigned __int8)*(_DWORD *)(v2 + 4 * v6++)) & 1) == 0;
while ( a2 > (int)v6 );
++v3;
v4 += 4LL;
}
while ( v3 != a2 );
return v5;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013f7
CMP ESI,0x1
JZ 0x001013f7
MOV RDI,qword ptr [RDI]
MOV R11D,ESI
MOV R9D,0x1
XOR R10D,R10D
XOR ECX,ECX
NOP
LAB_001013c0:
MOV R8D,dword ptr [RDI + R10*0x1]
MOV RAX,R9
NOP word ptr [RAX + RAX*0x1]
LAB_001013d0:
MOV EDX,dword ptr [RDI + RAX*0x4]
XOR EDX,R8D
AND EDX,0x1
CMP EDX,0x1
ADC ECX,0x0
ADD RAX,0x1
CMP ESI,EAX
JG 0x001013d0
ADD R9,0x1
ADD R10,0x4
CMP R9,R11
JNZ 0x001013c0
MOV EAX,ECX
RET
LAB_001013f7:
XOR ECX,ECX
MOV EAX,ECX
RET | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
long lVar4;
if ((0 < param_2) && (param_2 != 1)) {
uVar3 = 1;
lVar4 = 0;
iVar2 = 0;
do {
uVar1 = uVar3;
do {
iVar2 = iVar2 + (uint)(((*(uint *)(*(long *)param_1 + uVar1 * 4) ^
*(uint *)(*(long *)param_1 + lVar4)) & 1) == 0);
uVar1 = uVar1 + 1;
} while ((int)uVar1 < param_2);
uVar3 = uVar3 + 1;
lVar4 = lVar4 + 4;
} while (uVar3 != (uint)param_2);
return iVar2;
}
return 0;
} |
663 | func0 |
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& A, int N) {
int evenPair = 0;
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
if ((A[i] ^ A[j]) % 2 == 0) {
evenPair++;
}
}
}
return evenPair;
}
| int main() {
assert(func0({5,4,7,2,1}, 5) == 4);
assert(func0({7,2,8,1,0,5,11}, 7) == 9);
assert(func0({1,2,3}, 3) == 1);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
test %esi,%esi
jle 15b2 <_Z5func0RKSt6vectorIiSaIiEEi+0x152>
cmp $0x1,%esi
je 15b2 <_Z5func0RKSt6vectorIiSaIiEEi+0x152>
push %r14
movdqa 0xc61(%rip),%xmm4
xor %r9d,%r9d
xor %r8d,%r8d
push %rbp
mov $0x1,%ecx
mov $0x1,%r11d
pxor %xmm3,%xmm3
push %rbx
mov (%rdi),%r10
lea -0x1(%rsi),%ebx
nopl 0x0(%rax)
mov %esi,%ebp
mov %ebx,%eax
mov (%r10,%r9,1),%edi
sub %ecx,%ebp
cmp %ecx,%esi
cmovle %r11d,%ebp
sub %ecx,%eax
cmp $0x3,%eax
jbe 15aa <_Z5func0RKSt6vectorIiSaIiEEi+0x14a>
cmp %ecx,%esi
jle 15aa <_Z5func0RKSt6vectorIiSaIiEEi+0x14a>
mov %ebp,%edx
movd %edi,%xmm5
pxor %xmm1,%xmm1
add $0x4,%r9
shr $0x2,%edx
lea (%r10,%r9,1),%rax
pshufd $0x0,%xmm5,%xmm2
shl $0x4,%rdx
add %rax,%rdx
nopl 0x0(%rax)
movdqu (%rax),%xmm0
add $0x10,%rax
pxor %xmm2,%xmm0
pand %xmm4,%xmm0
pcmpeqd %xmm3,%xmm0
psubd %xmm0,%xmm1
cmp %rdx,%rax
jne 14e8 <_Z5func0RKSt6vectorIiSaIiEEi+0x88>
movdqa %xmm1,%xmm0
mov %ebp,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
add %eax,%r8d
lea (%rdx,%rcx,1),%eax
cmp %edx,%ebp
je 1597 <_Z5func0RKSt6vectorIiSaIiEEi+0x137>
movslq %eax,%rdx
mov (%r10,%rdx,4),%r14d
lea 0x0(,%rdx,4),%rbp
xor %edi,%r14d
mov %r14d,%edx
and $0x1,%edx
cmp $0x1,%edx
lea 0x1(%rax),%edx
adc $0x0,%r8d
cmp %edx,%esi
jle 1597 <_Z5func0RKSt6vectorIiSaIiEEi+0x137>
mov 0x4(%r10,%rbp,1),%edx
xor %edi,%edx
and $0x1,%edx
cmp $0x1,%edx
lea 0x2(%rax),%edx
adc $0x0,%r8d
cmp %edx,%esi
jle 1597 <_Z5func0RKSt6vectorIiSaIiEEi+0x137>
mov 0x8(%r10,%rbp,1),%edx
xor %edi,%edx
and $0x1,%edx
cmp $0x1,%edx
adc $0x0,%r8d
add $0x3,%eax
cmp %eax,%esi
jle 1597 <_Z5func0RKSt6vectorIiSaIiEEi+0x137>
xor 0xc(%r10,%rbp,1),%edi
and $0x1,%edi
cmp $0x1,%edi
adc $0x0,%r8d
add $0x1,%ecx
cmp %ecx,%esi
jne 14a0 <_Z5func0RKSt6vectorIiSaIiEEi+0x40>
pop %rbx
mov %r8d,%eax
pop %rbp
pop %r14
retq
mov %ecx,%eax
add $0x4,%r9
jmp 1532 <_Z5func0RKSt6vectorIiSaIiEEi+0xd2>
xor %r8d,%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax)
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
test esi, esi
jle loc_16C2
mov r8d, esi
cmp esi, 1
jz loc_16C2
push r14
xor r9d, r9d
mov ecx, 1
pxor xmm3, xmm3
movdqa xmm4, cs:xmmword_20D0
push rbp
lea ebp, [rsi-1]
push rbx
mov ebx, 1
mov r11, [rdi]
xor edi, edi
nop dword ptr [rax]
loc_15C0:
mov r10d, r8d
mov eax, ebp
mov esi, [r11+r9]
sub r10d, ecx
cmp r8d, ecx
cmovle r10d, ebx
sub eax, ecx
cmp eax, 2
jbe loc_16BA
cmp r8d, ecx
jle loc_16BA
mov edx, r10d
movd xmm5, esi
pxor xmm1, xmm1
add r9, 4
shr edx, 2
lea rax, [r11+r9]
pshufd xmm2, xmm5, 0
shl rdx, 4
add rdx, rax
nop dword ptr [rax+00000000h]
loc_1610:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pxor xmm0, xmm2
pand xmm0, xmm4
pcmpeqd xmm0, xmm3
psubd xmm1, xmm0
cmp rax, rdx
jnz short loc_1610
movdqa xmm0, xmm1
psrldq xmm0, 8
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
add edi, eax
mov eax, r10d
and eax, 0FFFFFFFCh
add eax, ecx
and r10d, 3
jz short loc_16A7
loc_165B:
movsxd rdx, eax
mov r14d, [r11+rdx*4]
lea r10, ds:0[rdx*4]
xor r14d, esi
mov edx, r14d
and edx, 1
cmp edx, 1
lea edx, [rax+1]
adc edi, 0
cmp r8d, edx
jle short loc_16A7
mov edx, [r11+r10+4]
xor edx, esi
and edx, 1
cmp edx, 1
adc edi, 0
add eax, 2
cmp r8d, eax
jle short loc_16A7
xor esi, [r11+r10+8]
and esi, 1
cmp esi, 1
adc edi, 0
loc_16A7:
add ecx, 1
cmp r8d, ecx
jnz loc_15C0
pop rbx
mov eax, edi
pop rbp
pop r14
retn
loc_16BA:
mov eax, ecx
add r9, 4
jmp short loc_165B
loc_16C2:
xor edi, edi
mov eax, edi
retn | long long func0(long long *a1, int a2)
{
long long v3; // r9
int v4; // ecx
__m128i si128; // xmm4
int v6; // ebp
long long v7; // r11
unsigned int v8; // edi
unsigned int v9; // esi
unsigned int v10; // r10d
__m128i v11; // xmm1
const __m128i *v12; // rax
__m128i v13; // xmm2
__m128i v14; // xmm0
__m128i v15; // xmm1
int v16; // eax
long long v17; // r10
if ( a2 > 0 && a2 != 1 )
{
v3 = 0LL;
v4 = 1;
si128 = _mm_load_si128((const __m128i *)&xmmword_20D0);
v6 = a2 - 1;
v7 = *a1;
v8 = 0;
while ( 1 )
{
v9 = *(_DWORD *)(v7 + v3);
v10 = a2 - v4;
if ( a2 <= v4 )
v10 = 1;
if ( (unsigned int)(v6 - v4) <= 2 || a2 <= v4 )
break;
v11 = 0LL;
v3 += 4LL;
v12 = (const __m128i *)(v7 + v3);
v13 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v9), 0);
do
{
v14 = _mm_loadu_si128(v12++);
v11 = _mm_sub_epi32(v11, _mm_cmpeq_epi32(_mm_and_si128(_mm_xor_si128(v14, v13), si128), (__m128i)0LL));
}
while ( v12 != (const __m128i *)(v7 + v3 + 16LL * (v10 >> 2)) );
v15 = _mm_add_epi32(v11, _mm_srli_si128(v11, 8));
v8 += _mm_cvtsi128_si32(_mm_add_epi32(v15, _mm_srli_si128(v15, 4)));
v16 = v4 + (v10 & 0xFFFFFFFC);
if ( (v10 & 3) != 0 )
goto LABEL_11;
LABEL_14:
if ( a2 == ++v4 )
return v8;
}
v16 = v4;
v3 += 4LL;
LABEL_11:
v17 = 4LL * v16;
v8 += (((unsigned __int8)v9 ^ *(_BYTE *)(v7 + v17)) & 1) == 0;
if ( a2 > v16 + 1 )
{
v8 += (((unsigned __int8)v9 ^ (unsigned __int8)*(_DWORD *)(v7 + v17 + 4)) & 1) == 0;
if ( a2 > v16 + 2 )
v8 += ((*(_DWORD *)(v7 + v17 + 8) ^ v9) & 1) == 0;
}
goto LABEL_14;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001016c2
MOV R8D,ESI
CMP ESI,0x1
JZ 0x001016c2
PUSH R14
XOR R9D,R9D
MOV ECX,0x1
PXOR XMM3,XMM3
MOVDQA XMM4,xmmword ptr [0x001020d0]
PUSH RBP
LEA EBP,[RSI + -0x1]
PUSH RBX
MOV EBX,0x1
MOV R11,qword ptr [RDI]
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_001015c0:
MOV R10D,R8D
MOV EAX,EBP
MOV ESI,dword ptr [R11 + R9*0x1]
SUB R10D,ECX
CMP R8D,ECX
CMOVLE R10D,EBX
SUB EAX,ECX
CMP EAX,0x2
JBE 0x001016ba
CMP R8D,ECX
JLE 0x001016ba
MOV EDX,R10D
MOVD XMM5,ESI
PXOR XMM1,XMM1
ADD R9,0x4
SHR EDX,0x2
LEA RAX,[R11 + R9*0x1]
PSHUFD XMM2,XMM5,0x0
SHL RDX,0x4
ADD RDX,RAX
NOP dword ptr [RAX]
LAB_00101610:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PXOR XMM0,XMM2
PAND XMM0,XMM4
PCMPEQD XMM0,XMM3
PSUBD XMM1,XMM0
CMP RAX,RDX
JNZ 0x00101610
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x8
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
ADD EDI,EAX
MOV EAX,R10D
AND EAX,0xfffffffc
ADD EAX,ECX
AND R10D,0x3
JZ 0x001016a7
LAB_0010165b:
MOVSXD RDX,EAX
MOV R14D,dword ptr [R11 + RDX*0x4]
LEA R10,[RDX*0x4]
XOR R14D,ESI
MOV EDX,R14D
AND EDX,0x1
CMP EDX,0x1
LEA EDX,[RAX + 0x1]
ADC EDI,0x0
CMP R8D,EDX
JLE 0x001016a7
MOV EDX,dword ptr [R11 + R10*0x1 + 0x4]
XOR EDX,ESI
AND EDX,0x1
CMP EDX,0x1
ADC EDI,0x0
ADD EAX,0x2
CMP R8D,EAX
JLE 0x001016a7
XOR ESI,dword ptr [R11 + R10*0x1 + 0x8]
AND ESI,0x1
CMP ESI,0x1
ADC EDI,0x0
LAB_001016a7:
ADD ECX,0x1
CMP R8D,ECX
JNZ 0x001015c0
POP RBX
MOV EAX,EDI
POP RBP
POP R14
RET
LAB_001016ba:
MOV EAX,ECX
ADD R9,0x4
JMP 0x0010165b
LAB_001016c2:
XOR EDI,EDI
MOV EAX,EDI
RET | /* 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)
{
long lVar1;
uint uVar2;
long lVar3;
uint uVar4;
uint uVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
uint *puVar9;
int iVar10;
uint *puVar11;
int iVar12;
long lVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
if ((param_2 < 1) || (param_2 == 1)) {
return 0;
}
lVar13 = 0;
iVar10 = 1;
lVar3 = *(long *)param_1;
iVar12 = 0;
do {
uVar2 = *(uint *)(lVar3 + lVar13);
uVar4 = param_2 - iVar10;
if (param_2 <= iVar10) {
uVar4 = 1;
}
iVar14 = iVar10;
if (((uint)((param_2 + -1) - iVar10) < 3) || (param_2 <= iVar10)) {
LAB_0010165b:
lVar1 = (long)iVar14 * 4;
iVar12 = iVar12 + (uint)(((*(uint *)(lVar3 + (long)iVar14 * 4) ^ uVar2) & 1) == 0);
if ((iVar14 + 1 < param_2) &&
(iVar12 = iVar12 + (uint)(((*(uint *)(lVar3 + 4 + lVar1) ^ uVar2) & 1) == 0),
iVar14 + 2 < param_2)) {
iVar12 = iVar12 + (uint)(((uVar2 ^ *(uint *)(lVar3 + 8 + lVar1)) & 1) == 0);
}
}
else {
iVar14 = 0;
iVar15 = 0;
iVar16 = 0;
iVar17 = 0;
puVar9 = (uint *)(lVar3 + lVar13 + 4);
puVar11 = puVar9 + (ulong)(uVar4 >> 2) * 4;
do {
uVar5 = *puVar9;
puVar6 = puVar9 + 1;
puVar7 = puVar9 + 2;
puVar8 = puVar9 + 3;
puVar9 = puVar9 + 4;
iVar14 = iVar14 + (uint)(((uVar5 ^ uVar2) & _DAT_001020d0) == 0);
iVar15 = iVar15 + (uint)(((*puVar6 ^ uVar2) & _UNK_001020d4) == 0);
iVar16 = iVar16 + (uint)(((*puVar7 ^ uVar2) & _UNK_001020d8) == 0);
iVar17 = iVar17 + (uint)(((*puVar8 ^ uVar2) & _UNK_001020dc) == 0);
} while (puVar9 != puVar11);
iVar12 = iVar12 + iVar14 + iVar16 + iVar15 + iVar17;
iVar14 = (uVar4 & 0xfffffffc) + iVar10;
if ((uVar4 & 3) != 0) goto LAB_0010165b;
}
lVar13 = lVar13 + 4;
iVar10 = iVar10 + 1;
if (param_2 == iVar10) {
return iVar12;
}
} while( true );
} |
664 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
if (n && !(n & (n - 1))) {
return n;
}
while(n != 0) {
n >>= 1;
count += 1;
}
return 1 << count;
}
| int main() {
assert(func0(0) == 1);
assert(func0(5) == 8);
assert(func0(17) == 32);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x4(%rbp)
cmpl $0x0,-0x14(%rbp)
je 1173 <_Z5func0i+0x2a>
mov -0x14(%rbp),%eax
sub $0x1,%eax
and -0x14(%rbp),%eax
test %eax,%eax
jne 1173 <_Z5func0i+0x2a>
mov -0x14(%rbp),%eax
jmp 1190 <_Z5func0i+0x47>
cmpl $0x0,-0x14(%rbp)
je 1182 <_Z5func0i+0x39>
sarl -0x14(%rbp)
addl $0x1,-0x4(%rbp)
jmp 1173 <_Z5func0i+0x2a>
mov -0x4(%rbp),%eax
mov $0x1,%edx
mov %eax,%ecx
shl %cl,%edx
mov %edx,%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_4], 0
cmp [rbp+var_14], 0
jz short loc_117A
mov eax, [rbp+var_14]
sub eax, 1
and eax, [rbp+var_14]
test eax, eax
jnz short loc_117A
mov eax, [rbp+var_14]
jmp short loc_118E
loc_1173:
sar [rbp+var_14], 1
add [rbp+var_4], 1
loc_117A:
cmp [rbp+var_14], 0
jnz short loc_1173
mov eax, [rbp+var_4]
mov edx, 1
mov ecx, eax
shl edx, cl
mov eax, edx
loc_118E:
pop rbp
retn | long long func0(unsigned int a1)
{
int v2; // [rsp+0h] [rbp-14h]
char v3; // [rsp+10h] [rbp-4h]
v2 = a1;
v3 = 0;
if ( a1 && (a1 & (a1 - 1)) == 0 )
return a1;
while ( v2 )
{
v2 >>= 1;
++v3;
}
return (unsigned int)(1 << v3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x4],0x0
CMP dword ptr [RBP + -0x14],0x0
JZ 0x0010117a
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
AND EAX,dword ptr [RBP + -0x14]
TEST EAX,EAX
JNZ 0x0010117a
MOV EAX,dword ptr [RBP + -0x14]
JMP 0x0010118e
LAB_00101173:
SAR dword ptr [RBP + -0x14],0x1
ADD dword ptr [RBP + -0x4],0x1
LAB_0010117a:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00101173
MOV EAX,dword ptr [RBP + -0x4]
MOV EDX,0x1
MOV ECX,EAX
SHL EDX,CL
MOV EAX,EDX
LAB_0010118e:
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
byte bVar1;
int4 local_1c;
bVar1 = 0;
local_1c = param_1;
if ((param_1 == 0) || ((param_1 - 1U & param_1) != 0)) {
for (; local_1c != 0; local_1c = local_1c >> 1) {
bVar1 = bVar1 + 1;
}
param_1 = 1 << (bVar1 & 0x1f);
}
return param_1;
} |
665 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
if (n && !(n & (n - 1))) {
return n;
}
while(n != 0) {
n >>= 1;
count += 1;
}
return 1 << count;
}
| int main() {
assert(func0(0) == 1);
assert(func0(5) == 8);
assert(func0(17) == 32);
return 0;
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
je 1166 <_Z5func0i+0x1d>
lea -0x1(%rdi),%edx
mov %edi,%eax
test %edi,%edx
je 116f <_Z5func0i+0x26>
mov $0x0,%edi
add $0x1,%edi
sar %eax
jne 115f <_Z5func0i+0x16>
mov $0x1,%eax
mov %edi,%ecx
shl %cl,%eax
retq
| _Z5func0i:
endbr64
test edi, edi
jz short loc_1166
lea edx, [rdi-1]
mov eax, edi
test edx, edi
jz short locret_116F
mov edi, 0
loc_115F:
add edi, 1
sar eax, 1
jnz short loc_115F
loc_1166:
mov eax, 1
mov ecx, edi
shl eax, cl
locret_116F:
retn | long long func0(unsigned int a1)
{
long long result; // rax
if ( a1 )
{
result = a1;
if ( (a1 & (a1 - 1)) == 0 )
return result;
LOBYTE(a1) = 0;
do
{
LOBYTE(a1) = a1 + 1;
LODWORD(result) = (int)result >> 1;
}
while ( (_DWORD)result );
}
return (unsigned int)(1 << a1);
} | func0:
ENDBR64
TEST EDI,EDI
JZ 0x00101166
LEA EDX,[RDI + -0x1]
MOV EAX,EDI
TEST EDX,EDI
JZ 0x0010116f
MOV EDI,0x0
LAB_0010115f:
ADD EDI,0x1
SAR EAX,0x1
JNZ 0x0010115f
LAB_00101166:
MOV EAX,0x1
MOV ECX,EDI
SHL EAX,CL
LAB_0010116f:
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
iVar1 = param_1;
if (param_1 != 0) {
if ((param_1 - 1U & param_1) == 0) {
return param_1;
}
iVar1 = 0;
do {
iVar1 = iVar1 + 1;
param_1 = param_1 >> 1;
} while (param_1 != 0);
}
return 1 << ((byte)iVar1 & 0x1f);
} |
666 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
if (n && !(n & (n - 1))) {
return n;
}
while(n != 0) {
n >>= 1;
count += 1;
}
return 1 << count;
}
| int main() {
assert(func0(0) == 1);
assert(func0(5) == 8);
assert(func0(17) == 32);
return 0;
}
| O2 | cpp | func0(int):
endbr64
mov $0x1,%eax
test %edi,%edi
je 116e <_Z5func0i+0x2e>
lea -0x1(%rdi),%edx
mov %edi,%eax
test %edi,%edx
je 116e <_Z5func0i+0x2e>
xor %ecx,%ecx
nopl 0x0(%rax,%rax,1)
add $0x1,%ecx
sar %edi
jne 1160 <_Z5func0i+0x20>
mov $0x1,%eax
shl %cl,%eax
retq
| _Z5func0i:
endbr64
mov eax, 1
test edi, edi
jz short locret_116E
lea edx, [rdi-1]
mov eax, edi
test edx, edi
jz short locret_116E
xor ecx, ecx
nop dword ptr [rax+rax+00000000h]
loc_1160:
add ecx, 1
sar edi, 1
jnz short loc_1160
mov eax, 1
shl eax, cl
locret_116E:
retn | long long func0(int a1)
{
long long result; // rax
char v2; // cl
result = 1LL;
if ( a1 )
{
result = (unsigned int)a1;
if ( (a1 & (a1 - 1)) != 0 )
{
v2 = 0;
do
{
++v2;
a1 >>= 1;
}
while ( a1 );
return (unsigned int)(1 << v2);
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
TEST EDI,EDI
JZ 0x0010116e
LEA EDX,[RDI + -0x1]
MOV EAX,EDI
TEST EDX,EDI
JZ 0x0010116e
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101160:
ADD ECX,0x1
SAR EDI,0x1
JNZ 0x00101160
MOV EAX,0x1
SHL EAX,CL
LAB_0010116e:
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
byte bVar2;
iVar1 = 1;
if ((param_1 != 0) && (iVar1 = param_1, (param_1 - 1U & param_1) != 0)) {
bVar2 = 0;
do {
bVar2 = bVar2 + 1;
param_1 = param_1 >> 1;
} while (param_1 != 0);
iVar1 = 1 << (bVar2 & 0x1f);
}
return iVar1;
} |
667 | func0 |
#include <assert.h>
| int func0(int n) {
int count = 0;
if (n && !(n & (n - 1))) {
return n;
}
while(n != 0) {
n >>= 1;
count += 1;
}
return 1 << count;
}
| int main() {
assert(func0(0) == 1);
assert(func0(5) == 8);
assert(func0(17) == 32);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov $0x1,%eax
test %edi,%edi
je 116e <_Z5func0i+0x2e>
lea -0x1(%rdi),%edx
mov %edi,%eax
test %edi,%edx
je 116e <_Z5func0i+0x2e>
xor %ecx,%ecx
nopl 0x0(%rax,%rax,1)
add $0x1,%ecx
sar %edi
jne 1160 <_Z5func0i+0x20>
mov $0x1,%eax
shl %cl,%eax
retq
| _Z5func0i:
endbr64
mov eax, 1
test edi, edi
jz short locret_116E
lea edx, [rdi-1]
mov eax, edi
test edx, edi
jz short locret_116E
xor ecx, ecx
nop dword ptr [rax+rax+00000000h]
loc_1160:
add ecx, 1
sar edi, 1
jnz short loc_1160
mov eax, 1
shl eax, cl
locret_116E:
retn | long long func0(int a1)
{
long long result; // rax
char v2; // cl
result = 1LL;
if ( a1 )
{
result = (unsigned int)a1;
if ( (a1 & (a1 - 1)) != 0 )
{
v2 = 0;
do
{
++v2;
a1 >>= 1;
}
while ( a1 );
return (unsigned int)(1 << v2);
}
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
TEST EDI,EDI
JZ 0x0010116e
LEA EDX,[RDI + -0x1]
MOV EAX,EDI
TEST EDX,EDI
JZ 0x0010116e
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101160:
ADD ECX,0x1
SAR EDI,0x1
JNZ 0x00101160
MOV EAX,0x1
SHL EAX,CL
LAB_0010116e:
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
byte bVar2;
iVar1 = 1;
if ((param_1 != 0) && (iVar1 = param_1, (param_1 - 1U & param_1) != 0)) {
bVar2 = 0;
do {
bVar2 = bVar2 + 1;
param_1 = param_1 >> 1;
} while (param_1 != 0);
iVar1 = 1 << (bVar2 & 0x1f);
}
return iVar1;
} |
668 | func0 |
#include <iostream>
#include <cassert>
#include <vector>
| int func0(std::vector<int> a, int x) {
int count = 0;
for (int i : a) {
if (i == x) count += 1;
}
return count;
}
| int main() {
assert(func0({1,2,3}, 4) == 0);
assert(func0({1,2,2,3,3,3,4}, 3) == 3);
assert(func0({0,1,2,3,1,2}, 1) == 2);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, 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 $0x0,-0x28(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1668 <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x20(%rbp)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 16b4 <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,-0x18(%rbp)
lea -0x18(%rbp),%rdx
lea -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1704 <_ZN9__gnu_cxxneIPiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESA_>
test %al,%al
je 12fc <_Z5func0St6vectorIiSaIiEEi+0x93>
lea -0x20(%rbp),%rax
mov %rax,%rdi
callq 1768 <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%eax
mov %eax,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x3c(%rbp),%eax
jne 12ee <_Z5func0St6vectorIiSaIiEEi+0x85>
addl $0x1,-0x28(%rbp)
lea -0x20(%rbp),%rax
mov %rax,%rdi
callq 1744 <_ZN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEppEv>
jmp 12ba <_Z5func0St6vectorIiSaIiEEi+0x51>
mov -0x28(%rbp),%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1313 <_Z5func0St6vectorIiSaIiEEi+0xaa>
callq 1140 <__stack_chk_fail@plt>
leaveq
retq
| _Z5func0St6vectorIiSaIiEEi:
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_28], 0
mov rax, [rbp+var_38]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rbp+var_18], rax
jmp short loc_12C5
loc_129C:
lea rax, [rbp+var_20]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(void)
mov eax, [rax]
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
cmp eax, [rbp+var_3C]
jnz short loc_12B9
add [rbp+var_28], 1
loc_12B9:
lea rax, [rbp+var_20]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEppEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(void)
loc_12C5:
lea rdx, [rbp+var_18]
lea rax, [rbp+var_20]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESA_; __gnu_cxx::operator!=<int *,std::vector<int>>(__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&,__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&)
test al, al
jnz short loc_129C
mov eax, [rbp+var_28]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12F3
call ___stack_chk_fail
locret_12F3:
leave
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+18h] [rbp-28h]
long long v4; // [rsp+20h] [rbp-20h] BYREF
_QWORD v5[3]; // [rsp+28h] [rbp-18h] BYREF
v5[2] = __readfsqword(0x28u);
v3 = 0;
v5[1] = a1;
v4 = std::vector<int>::begin(a1);
v5[0] = std::vector<int>::end(a1);
while ( (unsigned __int8)__gnu_cxx::operator!=<int *,std::vector<int>>(&v4, v5) )
{
if ( *(_DWORD *)__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(&v4) == a2 )
++v3;
__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(&v4);
}
return v3;
} | 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 + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101628
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101674
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001012c5
LAB_0010129c:
LEA RAX,[RBP + -0x20]
MOV RDI,RAX
CALL 0x00101728
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x3c]
JNZ 0x001012b9
ADD dword ptr [RBP + -0x28],0x1
LAB_001012b9:
LEA RAX,[RBP + -0x20]
MOV RDI,RAX
CALL 0x00101704
LAB_001012c5:
LEA RDX,[RBP + -0x18]
LEA RAX,[RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001016c4
TEST AL,AL
JNZ 0x0010129c
MOV EAX,dword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012f3
CALL 0x00101130
LAB_001012f3:
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
bool bVar1;
int *piVar2;
int4 in_register_0000003c;
long in_FS_OFFSET;
int local_30;
int8 local_28;
int8 local_20;
vector<int,std::allocator<int>> *local_18;
long local_10;
local_18 = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = 0;
local_28 = std::vector<int,std::allocator<int>>::begin(local_18);
local_20 = std::vector<int,std::allocator<int>>::end(local_18);
while( true ) {
bVar1 = operator!=((__normal_iterator *)&local_28,(__normal_iterator *)&local_20);
if (!bVar1) break;
piVar2 = (int *)__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)
&local_28);
if (*piVar2 == param_2) {
local_30 = local_30 + 1;
}
__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator++
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)&local_28);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_30;
} |
669 | func0 |
#include <iostream>
#include <cassert>
#include <vector>
| int func0(std::vector<int> a, int x) {
int count = 0;
for (int i : a) {
if (i == x) count += 1;
}
return count;
}
| int main() {
assert(func0({1,2,3}, 4) == 0);
assert(func0({1,2,2,3,3,3,4}, 3) == 3);
assert(func0({0,1,2,3,1,2}, 1) == 2);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdi
cmp %rdi,%rax
je 1274 <_Z5func0St6vectorIiSaIiEEi+0x2b>
mov $0x0,%edx
cmp %esi,(%rax)
sete %cl
movzbl %cl,%ecx
add %ecx,%edx
add $0x4,%rax
cmp %rax,%rdi
jne 125e <_Z5func0St6vectorIiSaIiEEi+0x15>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1271 <_Z5func0St6vectorIiSaIiEEi+0x28>
| _Z5func0St6vectorIiSaIiEEi:
endbr64
mov rax, [rdi]
mov rdi, [rdi+8]
cmp rdi, rax
jz short loc_1234
mov edx, 0
loc_121E:
cmp [rax], esi
setz cl
movzx ecx, cl
add edx, ecx
add rax, 4
cmp rax, rdi
jnz short loc_121E
loc_1231:
mov eax, edx
retn
loc_1234:
mov edx, 0
jmp short loc_1231 | long long func0(long long a1, int a2)
{
_DWORD *v2; // rax
_DWORD *v3; // rdi
unsigned int v4; // edx
v2 = *(_DWORD **)a1;
v3 = *(_DWORD **)(a1 + 8);
if ( v3 == v2 )
{
return 0;
}
else
{
v4 = 0;
do
v4 += *v2++ == a2;
while ( v2 != v3 );
}
return v4;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RAX
JZ 0x00101234
MOV EDX,0x0
LAB_0010121e:
CMP dword ptr [RAX],ESI
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x0010121e
LAB_00101231:
MOV EAX,EDX
RET
LAB_00101234:
MOV EDX,0x0
JMP 0x00101231 | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
int4 in_register_0000003c;
piVar2 = *(int **)CONCAT44(in_register_0000003c,param_1);
piVar1 = (int *)((int8 *)CONCAT44(in_register_0000003c,param_1))[1];
if (piVar1 == piVar2) {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
iVar3 = iVar3 + (uint)(*piVar2 == param_2);
piVar2 = piVar2 + 1;
} while (piVar2 != piVar1);
}
return iVar3;
} |
670 | func0 |
#include <iostream>
#include <cassert>
#include <vector>
| int func0(std::vector<int> a, int x) {
int count = 0;
for (int i : a) {
if (i == x) count += 1;
}
return count;
}
| int main() {
assert(func0({1,2,3}, 4) == 0);
assert(func0({1,2,2,3,3,3,4}, 3) == 3);
assert(func0({0,1,2,3,1,2}, 1) == 2);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rcx
xor %r8d,%r8d
cmp %rcx,%rax
je 14cb <_Z5func0St6vectorIiSaIiEEi+0x2b>
nopl 0x0(%rax,%rax,1)
xor %edx,%edx
cmp %esi,(%rax)
sete %dl
add $0x4,%rax
add %edx,%r8d
cmp %rax,%rcx
jne 14b8 <_Z5func0St6vectorIiSaIiEEi+0x18>
mov %r8d,%eax
retq
| _Z5func0St6vectorIiSaIiEEi:
endbr64
mov rax, [rdi]
mov rdi, [rdi+8]
xor edx, edx
cmp rdi, rax
jz short loc_141A
nop word ptr [rax+rax+00h]
loc_1408:
xor ecx, ecx
cmp esi, [rax]
setz cl
add rax, 4
add edx, ecx
cmp rdi, rax
jnz short loc_1408
loc_141A:
mov eax, edx
retn | long long func0(long long a1, int a2)
{
_DWORD *v2; // rax
_DWORD *v3; // rdi
unsigned int i; // edx
int v5; // ecx
v2 = *(_DWORD **)a1;
v3 = *(_DWORD **)(a1 + 8);
for ( i = 0; v3 != v2; i += v5 )
v5 = a2 == *v2++;
return i;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
XOR EDX,EDX
CMP RDI,RAX
JZ 0x0010141a
NOP word ptr [RAX + RAX*0x1]
LAB_00101408:
XOR ECX,ECX
CMP ESI,dword ptr [RAX]
SETZ CL
ADD RAX,0x4
ADD EDX,ECX
CMP RDI,RAX
JNZ 0x00101408
LAB_0010141a:
MOV EAX,EDX
RET | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int *piVar1;
int iVar2;
int4 in_register_0000003c;
iVar2 = 0;
for (piVar1 = *(int **)CONCAT44(in_register_0000003c,param_1);
(int *)((int8 *)CONCAT44(in_register_0000003c,param_1))[1] != piVar1;
piVar1 = piVar1 + 1) {
iVar2 = iVar2 + (uint)(param_2 == *piVar1);
}
return iVar2;
} |
671 | func0 |
#include <iostream>
#include <cassert>
#include <vector>
| int func0(std::vector<int> a, int x) {
int count = 0;
for (int i : a) {
if (i == x) count += 1;
}
return count;
}
| int main() {
assert(func0({1,2,3}, 4) == 0);
assert(func0({1,2,2,3,3,3,4}, 3) == 3);
assert(func0({0,1,2,3,1,2}, 1) == 2);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rdi
cmp %rdi,%rdx
je 1810 <_Z5func0St6vectorIiSaIiEEi+0xe0>
lea -0x4(%rdi),%rcx
mov %rdx,%rax
movabs $0x3ffffffffffffffc,%r9
sub %rdx,%rcx
shr $0x2,%rcx
lea 0x1(%rcx),%r8
test %r9,%rcx
je 1819 <_Z5func0St6vectorIiSaIiEEi+0xe9>
mov %r8,%rcx
movd %esi,%xmm3
pxor %xmm0,%xmm0
shr $0x2,%rcx
pshufd $0x0,%xmm3,%xmm2
shl $0x4,%rcx
add %rdx,%rcx
nopl 0x0(%rax)
movdqu (%rax),%xmm1
add $0x10,%rax
pcmpeqd %xmm2,%xmm1
psubd %xmm1,%xmm0
cmp %rcx,%rax
jne 1788 <_Z5func0St6vectorIiSaIiEEi+0x58>
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 1818 <_Z5func0St6vectorIiSaIiEEi+0xe8>
xor %ecx,%ecx
cmp (%rdx),%esi
sete %cl
add %ecx,%eax
lea 0x4(%rdx),%rcx
cmp %rcx,%rdi
je 1812 <_Z5func0St6vectorIiSaIiEEi+0xe2>
xor %ecx,%ecx
cmp 0x4(%rdx),%esi
sete %cl
add %ecx,%eax
lea 0x8(%rdx),%rcx
cmp %rcx,%rdi
je 1812 <_Z5func0St6vectorIiSaIiEEi+0xe2>
xor %ecx,%ecx
cmp %esi,0x8(%rdx)
sete %cl
add %ecx,%eax
lea 0xc(%rdx),%rcx
cmp %rcx,%rdi
je 1812 <_Z5func0St6vectorIiSaIiEEi+0xe2>
cmp 0xc(%rdx),%esi
sete %dl
movzbl %dl,%edx
add %edx,%eax
retq
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %eax,%eax
jmp 17cb <_Z5func0St6vectorIiSaIiEEi+0x9b>
nopl (%rax)
| _Z5func0St6vectorIiSaIiEEi:
endbr64
mov rdx, [rdi]
mov r8, [rdi+8]
cmp r8, rdx
jz loc_1718
lea rcx, [r8-4]
mov rax, rdx
sub rcx, rdx
mov rdi, rcx
shr rdi, 2
add rdi, 1
cmp rcx, 8
jbe loc_171B
mov rcx, rdi
movd xmm3, esi
pxor xmm0, xmm0
shr rcx, 2
pshufd xmm2, xmm3, 0
shl rcx, 4
add rcx, rdx
xchg ax, ax
loc_1690:
movdqu xmm1, xmmword ptr [rax]
add rax, 10h
pcmpeqd xmm1, xmm2
psubd xmm0, xmm1
cmp rax, rcx
jnz short loc_1690
movdqa xmm1, xmm0
mov rcx, rdi
psrldq xmm1, 8
and rcx, 0FFFFFFFFFFFFFFFCh
and edi, 3
paddd xmm0, xmm1
lea rdx, [rdx+rcx*4]
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
jz short locret_1708
loc_16D3:
xor ecx, ecx
cmp esi, [rdx]
setz cl
add eax, ecx
lea rcx, [rdx+4]
cmp r8, rcx
jz short locret_16F8
cmp esi, [rdx+4]
jz short loc_1700
loc_16EA:
lea rcx, [rdx+8]
cmp r8, rcx
jz short locret_16F8
cmp esi, [rdx+8]
jz short loc_1710
locret_16F8:
retn
loc_1700:
add eax, 1
jmp short loc_16EA
locret_1708:
retn
loc_1710:
add eax, 1
retn
loc_1718:
xor eax, eax
retn
loc_171B:
xor eax, eax
jmp short loc_16D3 | long long func0(long long a1, unsigned int a2)
{
const __m128i *v2; // rdx
unsigned long long *v3; // r8
const __m128i *v4; // rax
unsigned long long v5; // rdi
__m128i v6; // xmm0
__m128i v7; // xmm2
__m128i v8; // xmm1
__m128i v9; // xmm0
long long result; // rax
v2 = *(const __m128i **)a1;
v3 = *(unsigned long long **)(a1 + 8);
if ( v3 == *(unsigned long long **)a1 )
return 0LL;
v4 = *(const __m128i **)a1;
v5 = ((unsigned long long)((char *)v3 - 4 - (char *)v2) >> 2) + 1;
if ( (unsigned long long)((char *)v3 - 4 - (char *)v2) <= 8 )
{
LODWORD(result) = 0;
}
else
{
v6 = 0LL;
v7 = _mm_shuffle_epi32(_mm_cvtsi32_si128(a2), 0);
do
{
v8 = _mm_loadu_si128(v4++);
v6 = _mm_sub_epi32(v6, _mm_cmpeq_epi32(v8, v7));
}
while ( v4 != &v2[v5 >> 2] );
v9 = _mm_add_epi32(v6, _mm_srli_si128(v6, 8));
v2 = (const __m128i *)((char *)v2 + 4 * (v5 & 0xFFFFFFFFFFFFFFFCLL));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v9, _mm_srli_si128(v9, 4)));
if ( (v5 & 3) == 0 )
return result;
}
result = (a2 == v2->m128i_i32[0]) + (unsigned int)result;
if ( v3 != (unsigned long long *)((char *)v2->m128i_i64 + 4) )
{
if ( a2 == v2->m128i_i32[1] )
result = (unsigned int)(result + 1);
if ( v3 != &v2->m128i_u64[1] && a2 == v2->m128i_i32[2] )
return (unsigned int)(result + 1);
}
return result;
} | func0:
ENDBR64
MOV RDX,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
CMP R8,RDX
JZ 0x00101718
LEA RCX,[R8 + -0x4]
MOV RAX,RDX
SUB RCX,RDX
MOV RDI,RCX
SHR RDI,0x2
ADD RDI,0x1
CMP RCX,0x8
JBE 0x0010171b
MOV RCX,RDI
MOVD XMM3,ESI
PXOR XMM0,XMM0
SHR RCX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RCX,0x4
ADD RCX,RDX
NOP
LAB_00101690:
MOVDQU XMM1,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM1,XMM2
PSUBD XMM0,XMM1
CMP RAX,RCX
JNZ 0x00101690
MOVDQA XMM1,XMM0
MOV RCX,RDI
PSRLDQ XMM1,0x8
AND RCX,-0x4
AND EDI,0x3
PADDD XMM0,XMM1
LEA RDX,[RDX + RCX*0x4]
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
JZ 0x00101708
LAB_001016d3:
XOR ECX,ECX
CMP ESI,dword ptr [RDX]
SETZ CL
ADD EAX,ECX
LEA RCX,[RDX + 0x4]
CMP R8,RCX
JZ 0x001016f8
CMP ESI,dword ptr [RDX + 0x4]
JZ 0x00101700
LAB_001016ea:
LEA RCX,[RDX + 0x8]
CMP R8,RCX
JZ 0x001016f8
CMP ESI,dword ptr [RDX + 0x8]
JZ 0x00101710
LAB_001016f8:
RET
LAB_00101700:
ADD EAX,0x1
JMP 0x001016ea
LAB_00101708:
RET
LAB_00101710:
ADD EAX,0x1
RET
LAB_00101718:
XOR EAX,EAX
RET
LAB_0010171b:
XOR EAX,EAX
JMP 0x001016d3 | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
ulong uVar7;
int *piVar8;
int4 in_register_0000003c;
ulong uVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
piVar8 = *(int **)CONCAT44(in_register_0000003c,param_1);
piVar1 = (int *)((int8 *)CONCAT44(in_register_0000003c,param_1))[1];
if (piVar1 == piVar8) {
return 0;
}
uVar7 = (long)piVar1 + (-4 - (long)piVar8);
uVar9 = (uVar7 >> 2) + 1;
if (uVar7 < 9) {
iVar10 = 0;
}
else {
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
iVar13 = 0;
piVar6 = piVar8;
do {
iVar2 = *piVar6;
piVar3 = piVar6 + 1;
piVar4 = piVar6 + 2;
piVar5 = piVar6 + 3;
piVar6 = piVar6 + 4;
iVar10 = iVar10 + (uint)(iVar2 == param_2);
iVar11 = iVar11 + (uint)(*piVar3 == param_2);
iVar12 = iVar12 + (uint)(*piVar4 == param_2);
iVar13 = iVar13 + (uint)(*piVar5 == param_2);
} while (piVar6 != piVar8 + (uVar9 & 0xfffffffffffffffc));
piVar8 = piVar8 + (uVar9 & 0xfffffffffffffffc);
iVar10 = iVar10 + iVar12 + iVar11 + iVar13;
if ((uVar9 & 3) == 0) {
return iVar10;
}
}
iVar10 = iVar10 + (uint)(param_2 == *piVar8);
if (piVar1 != piVar8 + 1) {
if (param_2 == piVar8[1]) {
iVar10 = iVar10 + 1;
}
if ((piVar1 != piVar8 + 2) && (param_2 == piVar8[2])) {
return iVar10 + 1;
}
}
return iVar10;
} |
672 | func0 |
#include <assert.h>
| int func0(int n) {
if (n <= 2) {
return n;
}
int a = 1;
int b = 2;
for (int i = 3; i <= n; ++i) {
int c = 2 * b + a;
a = b;
b = c;
}
return b;
}
| int main() {
assert(func0(4) == 12);
assert(func0(7) == 169);
assert(func0(8) == 408);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x2,-0x14(%rbp)
jg 115f <_Z5func0i+0x16>
mov -0x14(%rbp),%eax
jmp 119f <_Z5func0i+0x56>
movl $0x1,-0x10(%rbp)
movl $0x2,-0xc(%rbp)
movl $0x3,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jg 119c <_Z5func0i+0x53>
mov -0xc(%rbp),%eax
lea (%rax,%rax,1),%edx
mov -0x10(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0xc(%rbp),%eax
mov %eax,-0x10(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
jmp 1174 <_Z5func0i+0x2b>
mov -0xc(%rbp),%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 2
jg short loc_115F
mov eax, [rbp+var_14]
jmp short loc_119F
loc_115F:
mov [rbp+var_10], 1
mov [rbp+var_C], 2
mov [rbp+var_8], 3
jmp short loc_1194
loc_1176:
mov eax, [rbp+var_C]
lea edx, [rax+rax]
mov eax, [rbp+var_10]
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_C]
mov [rbp+var_10], eax
mov eax, [rbp+var_4]
mov [rbp+var_C], eax
add [rbp+var_8], 1
loc_1194:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_14]
jle short loc_1176
mov eax, [rbp+var_C]
loc_119F:
pop rbp
retn | long long func0(int a1)
{
int v2; // [rsp+4h] [rbp-10h]
unsigned int v3; // [rsp+8h] [rbp-Ch]
int i; // [rsp+Ch] [rbp-8h]
unsigned int v5; // [rsp+10h] [rbp-4h]
if ( a1 <= 2 )
return (unsigned int)a1;
v2 = 1;
v3 = 2;
for ( i = 3; i <= a1; ++i )
{
v5 = 2 * v3 + v2;
v2 = v3;
v3 = v5;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x2
JG 0x0010115f
MOV EAX,dword ptr [RBP + -0x14]
JMP 0x0010119f
LAB_0010115f:
MOV dword ptr [RBP + -0x10],0x1
MOV dword ptr [RBP + -0xc],0x2
MOV dword ptr [RBP + -0x8],0x3
JMP 0x00101194
LAB_00101176:
MOV EAX,dword ptr [RBP + -0xc]
LEA EDX,[RAX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0xc],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_00101194:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101176
MOV EAX,dword ptr [RBP + -0xc]
LAB_0010119f:
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int4 local_18;
int4 local_14;
int4 local_10;
local_14 = param_1;
if (2 < param_1) {
local_18 = 1;
local_14 = 2;
for (local_10 = 3; local_10 <= param_1; local_10 = local_10 + 1) {
iVar1 = local_18 + local_14 * 2;
local_18 = local_14;
local_14 = iVar1;
}
}
return local_14;
} |
673 | func0 |
#include <assert.h>
| int func0(int n) {
if (n <= 2) {
return n;
}
int a = 1;
int b = 2;
for (int i = 3; i <= n; ++i) {
int c = 2 * b + a;
a = b;
b = c;
}
return b;
}
| int main() {
assert(func0(4) == 12);
assert(func0(7) == 169);
assert(func0(8) == 408);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov %edi,%eax
cmp $0x2,%edi
jle 1174 <_Z5func0i+0x2b>
add $0x1,%edi
mov $0x3,%edx
mov $0x2,%eax
mov $0x1,%ecx
mov %eax,%esi
lea (%rcx,%rax,2),%eax
add $0x1,%edx
mov %esi,%ecx
cmp %edi,%edx
jne 1166 <_Z5func0i+0x1d>
retq
| _Z5func0i:
endbr64
mov eax, edi
cmp edi, 2
jle short locret_1174
add edi, 1
mov edx, 3
mov eax, 2
mov ecx, 1
loc_1166:
mov esi, eax
lea eax, [rcx+rax*2]
add edx, 1
mov ecx, esi
cmp edx, edi
jnz short loc_1166
locret_1174:
retn | long long func0(int a1)
{
long long result; // rax
int v2; // edi
int v3; // edx
int v4; // ecx
int v5; // esi
result = (unsigned int)a1;
if ( a1 > 2 )
{
v2 = a1 + 1;
v3 = 3;
LODWORD(result) = 2;
v4 = 1;
do
{
v5 = result;
result = (unsigned int)(v4 + 2 * result);
++v3;
v4 = v5;
}
while ( v3 != v2 );
}
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,0x2
JLE 0x00101174
ADD EDI,0x1
MOV EDX,0x3
MOV EAX,0x2
MOV ECX,0x1
LAB_00101166:
MOV ESI,EAX
LEA EAX,[RCX + RAX*0x2]
ADD EDX,0x1
MOV ECX,ESI
CMP EDX,EDI
JNZ 0x00101166
LAB_00101174:
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (2 < param_1) {
iVar4 = param_1 + 1;
iVar3 = 3;
iVar2 = 1;
iVar1 = 2;
do {
param_1 = iVar2 + iVar1 * 2;
iVar3 = iVar3 + 1;
iVar2 = iVar1;
iVar1 = param_1;
} while (iVar3 != iVar4);
}
return param_1;
} |
674 | func0 |
#include <assert.h>
| int func0(int n) {
if (n <= 2) {
return n;
}
int a = 1;
int b = 2;
for (int i = 3; i <= n; ++i) {
int c = 2 * b + a;
a = b;
b = c;
}
return b;
}
| int main() {
assert(func0(4) == 12);
assert(func0(7) == 169);
assert(func0(8) == 408);
return 0;
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%r8d
cmp $0x2,%edi
jle 11d0 <_Z5func0i+0x30>
add $0x1,%edi
mov $0x1,%ecx
mov $0x2,%edx
mov $0x3,%eax
jmp 11c3 <_Z5func0i+0x23>
mov %r8d,%edx
add $0x1,%eax
lea (%rcx,%rdx,2),%r8d
mov %edx,%ecx
cmp %eax,%edi
jne 11c0 <_Z5func0i+0x20>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0i:
endbr64
mov ecx, edi
cmp edi, 2
jle short loc_122E
add edi, 1
mov eax, 3
mov esi, 1
mov edx, 2
jmp short loc_1222
loc_1220:
mov edx, ecx
loc_1222:
add eax, 1
lea ecx, [rsi+rdx*2]
mov esi, edx
cmp edi, eax
jnz short loc_1220
loc_122E:
mov eax, ecx
retn | long long func0(int a1)
{
unsigned int v1; // ecx
int v2; // edi
int v3; // eax
int v4; // esi
int i; // edx
v1 = a1;
if ( a1 > 2 )
{
v2 = a1 + 1;
v3 = 3;
v4 = 1;
for ( i = 2; ; i = v1 )
{
++v3;
v1 = v4 + 2 * i;
v4 = i;
if ( v2 == v3 )
break;
}
}
return v1;
} | func0:
ENDBR64
MOV ECX,EDI
CMP EDI,0x2
JLE 0x0010122e
ADD EDI,0x1
MOV EAX,0x3
MOV ESI,0x1
MOV EDX,0x2
JMP 0x00101222
LAB_00101220:
MOV EDX,ECX
LAB_00101222:
ADD EAX,0x1
LEA ECX,[RSI + RDX*0x2]
MOV ESI,EDX
CMP EDI,EAX
JNZ 0x00101220
LAB_0010122e:
MOV EAX,ECX
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (2 < param_1) {
iVar4 = param_1 + 1;
iVar1 = 3;
iVar3 = 1;
iVar2 = 2;
do {
iVar1 = iVar1 + 1;
param_1 = iVar3 + iVar2 * 2;
iVar3 = iVar2;
iVar2 = param_1;
} while (iVar4 != iVar1);
}
return param_1;
} |
675 | func0 |
#include <assert.h>
| int func0(int n) {
if (n <= 2) {
return n;
}
int a = 1;
int b = 2;
for (int i = 3; i <= n; ++i) {
int c = 2 * b + a;
a = b;
b = c;
}
return b;
}
| int main() {
assert(func0(4) == 12);
assert(func0(7) == 169);
assert(func0(8) == 408);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%r8d
cmp $0x2,%edi
jle 1170 <_Z5func0i+0x30>
add $0x1,%edi
mov $0x1,%ecx
mov $0x2,%edx
mov $0x3,%eax
jmp 1163 <_Z5func0i+0x23>
mov %r8d,%edx
add $0x1,%eax
lea (%rcx,%rdx,2),%r8d
mov %edx,%ecx
cmp %edi,%eax
jne 1160 <_Z5func0i+0x20>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0i:
endbr64
mov ecx, edi
cmp edi, 2
jle short loc_116E
add edi, 1
mov eax, 3
mov esi, 1
mov edx, 2
jmp short loc_1162
loc_1160:
mov edx, ecx
loc_1162:
add eax, 1
lea ecx, [rsi+rdx*2]
mov esi, edx
cmp edi, eax
jnz short loc_1160
loc_116E:
mov eax, ecx
retn | long long func0(int a1)
{
unsigned int v1; // ecx
int v2; // edi
int v3; // eax
int v4; // esi
int i; // edx
v1 = a1;
if ( a1 > 2 )
{
v2 = a1 + 1;
v3 = 3;
v4 = 1;
for ( i = 2; ; i = v1 )
{
++v3;
v1 = v4 + 2 * i;
v4 = i;
if ( v2 == v3 )
break;
}
}
return v1;
} | func0:
ENDBR64
MOV ECX,EDI
CMP EDI,0x2
JLE 0x0010116e
ADD EDI,0x1
MOV EAX,0x3
MOV ESI,0x1
MOV EDX,0x2
JMP 0x00101162
LAB_00101160:
MOV EDX,ECX
LAB_00101162:
ADD EAX,0x1
LEA ECX,[RSI + RDX*0x2]
MOV ESI,EDX
CMP EDI,EAX
JNZ 0x00101160
LAB_0010116e:
MOV EAX,ECX
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (2 < param_1) {
iVar4 = param_1 + 1;
iVar1 = 3;
iVar3 = 1;
iVar2 = 2;
do {
iVar1 = iVar1 + 1;
param_1 = iVar3 + iVar2 * 2;
iVar3 = iVar2;
iVar2 = param_1;
} while (iVar4 != iVar1);
}
return param_1;
} |
676 | func0 | #include <vector>
#include <cassert>
| int func0(const std::vector<int>& list1, int m, int n) {
int sum_range = 0;
for (int i = m; i <= n; ++i) {
sum_range += list1[i];
}
return sum_range;
}
| int main() {
std::vector<int> list1 = {2,1,5,6,8,3,4,9,10,11,8,12};
assert(func0(list1, 8, 10) == 29);
assert(func0(list1, 5, 7) == 16);
assert(func0(list1, 7, 10) == 38);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
mov -0x1c(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x20(%rbp),%eax
jg 1274 <_Z5func0RKSt6vectorIiSaIiEEii+0x4b>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1444 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
jmp 124c <_Z5func0RKSt6vectorIiSaIiEEii+0x23>
mov -0x8(%rbp),%eax
leaveq
retq
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_8], 0
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
jmp short loc_128C
loc_126E:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_128C:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_20]
jle short loc_126E
mov eax, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2, int a3)
{
unsigned int v5; // [rsp+18h] [rbp-8h]
v5 = 0;
while ( a2 <= a3 )
v5 += *(_DWORD *)std::vector<int>::operator[](a1, a2++);
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0010128c
LAB_0010126e:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010146e
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_0010128c:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x20]
JLE 0x0010126e
MOV EAX,dword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
int *piVar1;
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = param_2; local_c <= param_3; local_c = local_c + 1) {
piVar1 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)local_c);
local_10 = local_10 + *piVar1;
}
return local_10;
} |
677 | func0 | #include <vector>
#include <cassert>
| int func0(const std::vector<int>& list1, int m, int n) {
int sum_range = 0;
for (int i = m; i <= n; ++i) {
sum_range += list1[i];
}
return sum_range;
}
| int main() {
std::vector<int> list1 = {2,1,5,6,8,3,4,9,10,11,8,12};
assert(func0(list1, 8, 10) == 29);
assert(func0(list1, 5, 7) == 16);
assert(func0(list1, 7, 10) == 38);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
cmp %edx,%esi
jg 11d8 <_Z5func0RKSt6vectorIiSaIiEEii+0x2f>
mov (%rdi),%rcx
movslq %esi,%rdi
lea (%rcx,%rdi,4),%rax
sub %esi,%edx
add %rdi,%rdx
lea 0x4(%rcx,%rdx,4),%rcx
mov $0x0,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rcx,%rax
jne 11ca <_Z5func0RKSt6vectorIiSaIiEEii+0x21>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 11d5 <_Z5func0RKSt6vectorIiSaIiEEii+0x2c>
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
cmp esi, edx
jg short loc_11D8
mov rcx, [rdi]
movsxd rdi, esi
lea rax, [rcx+rdi*4]
sub edx, esi
add rdx, rdi
lea rcx, [rcx+rdx*4+4]
mov edx, 0
loc_11CA:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_11CA
loc_11D5:
mov eax, edx
retn
loc_11D8:
mov edx, 0
jmp short loc_11D5 | long long func0(_QWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
unsigned long long v4; // rcx
unsigned int v5; // edx
if ( a2 > a3 )
{
return 0;
}
else
{
v3 = (_DWORD *)(*a1 + 4LL * a2);
v4 = *a1 + 4 * (a2 + (unsigned long long)(unsigned int)(a3 - a2)) + 4;
v5 = 0;
do
v5 += *v3++;
while ( v3 != (_DWORD *)v4 );
}
return v5;
} | func0:
ENDBR64
CMP ESI,EDX
JG 0x001011d8
MOV RCX,qword ptr [RDI]
MOVSXD RDI,ESI
LEA RAX,[RCX + RDI*0x4]
SUB EDX,ESI
ADD RDX,RDI
LEA RCX,[RCX + RDX*0x4 + 0x4]
MOV EDX,0x0
LAB_001011ca:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001011ca
LAB_001011d5:
MOV EAX,EDX
RET
LAB_001011d8:
MOV EDX,0x0
JMP 0x001011d5 | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (param_3 < param_2) {
iVar2 = 0;
}
else {
piVar1 = (int *)(*(long *)param_1 + (long)param_2 * 4);
iVar2 = 0;
do {
iVar2 = iVar2 + *piVar1;
piVar1 = piVar1 + 1;
} while (piVar1 != (int *)(*(long *)param_1 + 4 +
((ulong)(uint)(param_3 - param_2) + (long)param_2) * 4));
}
return iVar2;
} |
678 | func0 | #include <vector>
#include <cassert>
| int func0(const std::vector<int>& list1, int m, int n) {
int sum_range = 0;
for (int i = m; i <= n; ++i) {
sum_range += list1[i];
}
return sum_range;
}
| int main() {
std::vector<int> list1 = {2,1,5,6,8,3,4,9,10,11,8,12};
assert(func0(list1, 8, 10) == 29);
assert(func0(list1, 5, 7) == 16);
assert(func0(list1, 7, 10) == 38);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
cmp %edx,%esi
jg 1330 <_Z5func0RKSt6vectorIiSaIiEEii+0x30>
mov (%rdi),%rcx
sub %esi,%edx
movslq %esi,%rdi
xor %r8d,%r8d
add %rdi,%rdx
lea (%rcx,%rdi,4),%rax
lea 0x4(%rcx,%rdx,4),%rdx
add (%rax),%r8d
add $0x4,%rax
cmp %rdx,%rax
jne 1320 <_Z5func0RKSt6vectorIiSaIiEEii+0x20>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
cmp esi, edx
jg short loc_1250
mov rcx, [rdi]
sub edx, esi
movsxd rdi, esi
add rdx, rdi
lea rax, [rcx+rdi*4]
lea rcx, [rcx+rdx*4+4]
xor edx, edx
xchg ax, ax
loc_1240:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1240
mov eax, edx
retn
loc_1250:
xor edx, edx
mov eax, edx
retn | long long func0(_QWORD *a1, int a2, int a3)
{
_DWORD *v3; // rax
unsigned long long v4; // rcx
unsigned int v5; // edx
if ( a2 > a3 )
return 0LL;
v3 = (_DWORD *)(*a1 + 4LL * a2);
v4 = *a1 + 4 * (a2 + (unsigned long long)(unsigned int)(a3 - a2)) + 4;
v5 = 0;
do
v5 += *v3++;
while ( v3 != (_DWORD *)v4 );
return v5;
} | func0:
ENDBR64
CMP ESI,EDX
JG 0x00101250
MOV RCX,qword ptr [RDI]
SUB EDX,ESI
MOVSXD RDI,ESI
ADD RDX,RDI
LEA RAX,[RCX + RDI*0x4]
LEA RCX,[RCX + RDX*0x4 + 0x4]
XOR EDX,EDX
NOP
LAB_00101240:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101240
MOV EAX,EDX
RET
LAB_00101250:
XOR EDX,EDX
MOV EAX,EDX
RET | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (param_2 <= param_3) {
piVar1 = (int *)(*(long *)param_1 + (long)param_2 * 4);
iVar2 = 0;
do {
iVar2 = iVar2 + *piVar1;
piVar1 = piVar1 + 1;
} while (piVar1 != (int *)(*(long *)param_1 + 4 +
((ulong)(uint)(param_3 - param_2) + (long)param_2) * 4));
return iVar2;
}
return 0;
} |
679 | func0 | #include <vector>
#include <cassert>
| int func0(const std::vector<int>& list1, int m, int n) {
int sum_range = 0;
for (int i = m; i <= n; ++i) {
sum_range += list1[i];
}
return sum_range;
}
| int main() {
std::vector<int> list1 = {2,1,5,6,8,3,4,9,10,11,8,12};
assert(func0(list1, 8, 10) == 29);
assert(func0(list1, 5, 7) == 16);
assert(func0(list1, 7, 10) == 38);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
cmp %edx,%esi
jg 1390 <_Z5func0RKSt6vectorIiSaIiEEii+0xb0>
mov %edx,%eax
mov (%rdi),%r8
lea 0x1(%rdx),%edi
sub %esi,%eax
sub %esi,%edi
cmp $0x3,%eax
jbe 1399 <_Z5func0RKSt6vectorIiSaIiEEii+0xb9>
mov %edi,%ecx
movslq %esi,%rax
pxor %xmm0,%xmm0
shr $0x2,%ecx
lea (%r8,%rax,4),%rax
shl $0x4,%rcx
add %rax,%rcx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rcx,%rax
jne 1320 <_Z5func0RKSt6vectorIiSaIiEEii+0x40>
movdqa %xmm0,%xmm1
mov %edi,%ecx
psrldq $0x8,%xmm1
and $0xfffffffc,%ecx
paddd %xmm1,%xmm0
add %ecx,%esi
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
cmp %ecx,%edi
je 1398 <_Z5func0RKSt6vectorIiSaIiEEii+0xb8>
movslq %esi,%rcx
add (%r8,%rcx,4),%eax
lea 0x1(%rsi),%ecx
cmp %ecx,%edx
jl 1392 <_Z5func0RKSt6vectorIiSaIiEEii+0xb2>
movslq %ecx,%rcx
add (%r8,%rcx,4),%eax
lea 0x2(%rsi),%ecx
cmp %ecx,%edx
jl 1392 <_Z5func0RKSt6vectorIiSaIiEEii+0xb2>
movslq %ecx,%rcx
add $0x3,%esi
add (%r8,%rcx,4),%eax
cmp %esi,%edx
jl 1392 <_Z5func0RKSt6vectorIiSaIiEEii+0xb2>
movslq %esi,%rsi
add (%r8,%rsi,4),%eax
retq
nopl 0x0(%rax)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %eax,%eax
jmp 135a <_Z5func0RKSt6vectorIiSaIiEEii+0x7a>
nopl (%rax)
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
mov ecx, esi
mov esi, edx
cmp ecx, edx
jg loc_12C0
mov eax, edx
mov r8, [rdi]
sub eax, ecx
lea edi, [rax+1]
cmp eax, 2
jbe loc_12C3
mov edx, edi
movsxd rax, ecx
pxor xmm0, xmm0
shr edx, 2
lea rax, [r8+rax*4]
shl rdx, 4
add rdx, rax
nop word ptr [rax+rax+00h]
loc_1260:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp rdx, rax
jnz short loc_1260
movdqa xmm1, xmm0
psrldq xmm1, 8
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
test dil, 3
jz short locret_12C2
and edi, 0FFFFFFFCh
add ecx, edi
loc_129A:
movsxd rdx, ecx
lea rdi, ds:0[rdx*4]
add eax, [r8+rdx*4]
cmp esi, ecx
jle short locret_12C2
add ecx, 2
add eax, [r8+rdi+4]
cmp esi, ecx
jl short locret_12C2
add eax, [r8+rdi+8]
retn
loc_12C0:
xor eax, eax
locret_12C2:
retn
loc_12C3:
xor eax, eax
jmp short loc_129A | long long func0(long long *a1, int a2, int a3)
{
long long v5; // r8
unsigned int v6; // edi
__m128i v7; // xmm0
const __m128i *v8; // rax
const __m128i *v9; // rdx
__m128i v10; // xmm2
__m128i v11; // xmm0
long long result; // rax
long long v13; // rdi
if ( a2 > a3 )
return 0LL;
v5 = *a1;
v6 = a3 - a2 + 1;
if ( (unsigned int)(a3 - a2) <= 2 )
{
LODWORD(result) = 0;
}
else
{
v7 = 0LL;
v8 = (const __m128i *)(v5 + 4LL * a2);
v9 = &v8[v6 >> 2];
do
{
v10 = _mm_loadu_si128(v8++);
v7 = _mm_add_epi32(v7, v10);
}
while ( v9 != v8 );
v11 = _mm_add_epi32(v7, _mm_srli_si128(v7, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v11, _mm_srli_si128(v11, 4)));
if ( (v6 & 3) == 0 )
return result;
a2 += v6 & 0xFFFFFFFC;
}
v13 = 4LL * a2;
result = (unsigned int)(*(_DWORD *)(v5 + v13) + result);
if ( a3 > a2 )
{
result = (unsigned int)(*(_DWORD *)(v5 + v13 + 4) + result);
if ( a3 >= a2 + 2 )
return (unsigned int)(*(_DWORD *)(v5 + v13 + 8) + result);
}
return result;
} | func0:
ENDBR64
MOV ECX,ESI
MOV ESI,EDX
CMP ECX,EDX
JG 0x001012c0
MOV EAX,EDX
MOV R8,qword ptr [RDI]
SUB EAX,ECX
LEA EDI,[RAX + 0x1]
CMP EAX,0x2
JBE 0x001012c3
MOV EDX,EDI
MOVSXD RAX,ECX
PXOR XMM0,XMM0
SHR EDX,0x2
LEA RAX,[R8 + RAX*0x4]
SHL RDX,0x4
ADD RDX,RAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101260:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RDX,RAX
JNZ 0x00101260
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
TEST DIL,0x3
JZ 0x001012c2
AND EDI,0xfffffffc
ADD ECX,EDI
LAB_0010129a:
MOVSXD RDX,ECX
LEA RDI,[RDX*0x4]
ADD EAX,dword ptr [R8 + RDX*0x4]
CMP ESI,ECX
JLE 0x001012c2
ADD ECX,0x2
ADD EAX,dword ptr [R8 + RDI*0x1 + 0x4]
CMP ESI,ECX
JL 0x001012c2
ADD EAX,dword ptr [R8 + RDI*0x1 + 0x8]
RET
LAB_001012c0:
XOR EAX,EAX
LAB_001012c2:
RET
LAB_001012c3:
XOR EAX,EAX
JMP 0x0010129a | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int func0(vector *param_1,int param_2,int param_3)
{
uint uVar1;
long lVar2;
long lVar3;
int iVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int *piVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
if (param_3 < param_2) {
iVar10 = 0;
}
else {
lVar3 = *(long *)param_1;
uVar1 = (param_3 - param_2) + 1;
if ((uint)(param_3 - param_2) < 3) {
iVar10 = 0;
}
else {
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
iVar13 = 0;
piVar8 = (int *)(lVar3 + (long)param_2 * 4);
piVar9 = piVar8 + (ulong)(uVar1 >> 2) * 4;
do {
iVar4 = *piVar8;
piVar5 = piVar8 + 1;
piVar6 = piVar8 + 2;
piVar7 = piVar8 + 3;
piVar8 = piVar8 + 4;
iVar10 = iVar10 + iVar4;
iVar11 = iVar11 + *piVar5;
iVar12 = iVar12 + *piVar6;
iVar13 = iVar13 + *piVar7;
} while (piVar9 != piVar8);
iVar10 = iVar10 + iVar12 + iVar11 + iVar13;
if ((uVar1 & 3) == 0) {
return iVar10;
}
param_2 = param_2 + (uVar1 & 0xfffffffc);
}
lVar2 = (long)param_2 * 4;
iVar10 = iVar10 + *(int *)(lVar3 + (long)param_2 * 4);
if ((param_2 < param_3) &&
(iVar10 = iVar10 + *(int *)(lVar3 + 4 + lVar2), param_2 + 2 <= param_3)) {
return iVar10 + *(int *)(lVar3 + 8 + lVar2);
}
}
return iVar10;
} |
680 | func0 |
#include <cassert>
| double func0(double a) {
double perimeter = 5 * a;
return perimeter;
}
| int main() {
assert(func0(5) == 25);
assert(func0(10) == 50);
assert(func0(15) == 75);
return 0;
}
| O0 | cpp | func0(double):
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf2d(%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:dbl_2068
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1)
{
return 5.0 * a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x00102068]
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_00102068 * param_1;
} |
681 | func0 |
#include <cassert>
| double func0(double a) {
double perimeter = 5 * a;
return perimeter;
}
| int main() {
assert(func0(5) == 25);
assert(func0(10) == 50);
assert(func0(15) == 75);
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 * 5.0;
} | 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;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.